How Factory Method pattern make code maintainable in this case

I'm new to design patterns, I was reading a book says:
In an application, you may have different database users. For example, one user may use
Oracle, and the other may use SQL Server. Whenever you need to insert data into your
database, you need to create either a SqlConnection or an OracleConnection and only
then can you proceed. If you put the code into if-else (or switch) statements, you need to repeat a lot of code, which isn’t easily maintainable. This is because whenever you
need to support a new type of connection, you need to reopen your code and make those
modifications. This type of problem can be resolved using the Factory Method pattern.

I'm a little bit confused here, if you need to use a new type of connection, don't you just add a new class file of that connection class (e.g.

NEWGenerationConnection), then just use NewGenerationConnection connection = new NewGenerationConnection(connectionString);
connection.open();
....

how does if-else get involved here? and why you need to modify the base code file? can someone write some pseudo code for me so that I can understand the problem better?

The point here is centralizing the code blocks having possibility of change. If you scatter same if-else blocks around multiple classes then if a change needs on it later, you have to make changes in all places. An IDE offers you find and replace utility, but even in this case it is not a good practice at least because of separate compilation.

With factory pattern you put that if-else logic in one place and pass the object which is a polymorphic super type you get from the factory to your classes and then you will use the benefits of dynamic dispatch with for example strategy or template method patterns.

Let's see in example(for the sake of brevity it's a basic example so I did't refactor for unrelated stuff):

public class ConnectionPolicyFactory {

    public ConnectionPolicy getPolicy(String dbVendor) {
        if (dbVendor == "ORACLE") {
            return new OracleConnectionPolicy();
        } else if (dbVendor == "SQL_SERVER")) {
            return new SqlServerConnectionPolicy();
        }
        //exceptional cases
    }

}

then in the client:

ConnectionPolicyFactory connectionPolicyFactory = new ConnectionPolicyFactory();

//this is the parent of Connection types.
ConnectionPolicy connectionPolicy = connectionPolicyFactory.getPolicy("ORACLE");//which is OracleConnectionPolicy

MyClass myClass = new MyClass();
myClass.foo(connectionPolicy);

then in your class maybe you are doing something like:

public class MyClass {
   //...
   
   public void foo(ConnectionPolicy conn) {
      conn.someVendorSpecificAction();
   }

   //...
   
}

If you didn't use a factory and when you probably had more classes using this ConnectionPolicy then you would have all if-else logics in all your classes.