sqlalchemy.engine.default.DefaultDialect

Establish a connection using this dialect's DBAPI.

The default implementation of this method is:

def connect(self, *cargs, **cparams):
    return self.dbapi.connect(*cargs, **cparams)

The *cargs, **cparams parameters are generated directly from this dialect's .Dialect.create_connect_args method.

This method may be used for dialects that need to perform programmatic per-connection steps when a new connection is procured from the DBAPI.

Build DB-API compatible connection arguments.

Given a .URL object, returns a tuple consisting of a (*args, **kwargs) suitable to send directly to the dbapi's connect function. The arguments are sent to the .Dialect.connect method which then runs the DBAPI-level connect() function.

The method typically makes use of the .URL.translate_connect_args method in order to generate a dictionary of options.

The default implementation is:

def create_connect_args(self, url):
    opts = url.translate_connect_args()
    opts.update(url.query)
    return [[], opts]

Create a random two-phase transaction ID.

This id will be passed to do_begin_twophase(), do_rollback_twophase(), do_commit_twophase(). Its format is unspecified.

convert the given name to a case insensitive identifier for the backend if it is an all-lowercase name.

This method is only used if the dialect defines requires_name_normalize=True.

Provide an implementation of connection.begin(), given a DB-API connection.

The DBAPI has no dedicated "begin" method and it is expected that transactions are implicit. This hook is provided for those DBAPIs that might need additional help in this area.

Note that .Dialect.do_begin is not called unless a .Transaction object is in use. The .Dialect.do_autocommit hook is provided for DBAPIs that need some extra commands emitted after a commit in order to enter the next transaction, when the SQLAlchemy _engine.Connection is used in its default "autocommit" mode.

Provide an implementation of connection.close(), given a DBAPI connection.

This hook is called by the _pool.Pool when a connection has been detached from the pool, or is being returned beyond the normal capacity of the pool.

Provide an implementation of cursor.execute(statement).

The parameter collection should not be sent.

Given a DBAPI connection, return its isolation level, or a default isolation level if one cannot be retrieved.

May be overridden by subclasses in order to provide a "fallback" isolation level for databases that cannot reliably retrieve the actual isolation level.

By default, calls the _engine.Interfaces.get_isolation_level method, propagating any exceptions raised.

Returns the connection object as returned by the external driver package.

For normal dialects that use a DBAPI compliant driver this call will just return the connection passed as argument. For dialects that instead adapt a non DBAPI compliant driver, like when adapting an asyncio driver, this call will return the connection-like object as returned by the driver.

Check the existence of a particular index name in the database.

Given a _engine.Connection object, a string table_name and string index name, return True if an index of the given name on the given table exists, false otherwise.

The .DefaultDialect implements this in terms of the .Dialect.has_table and .Dialect.get_indexes methods, however dialects can implement a more performant version.

Called during strategized creation of the dialect with a connection.

Allows dialects to configure options based on server version info or other properties.

The connection passed here is a SQLAlchemy Connection object, with full capabilities.

The initialize() method of the base dialect should be called via super().

convert the given name to lowercase if it is detected as case insensitive.

This method is only used if the dialect defines requires_name_normalize=True.

return a callable which sets up a newly created DBAPI connection.

The callable should accept a single argument "conn" which is the DBAPI connection itself. The inner callable has no return value.

E.g.:

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect(self):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

This is used to set dialect-wide per-connection options such as isolation modes, Unicode modes, etc.

The "do_on_connect" callable is invoked by using the _events.PoolEvents.connect event hook, then unwrapping the DBAPI connection and passing it into the callable.

If None is returned, no event listener is generated.

Given a DBAPI connection, revert its isolation to the default.

Note that this is a dialect-level method which is used as part of the implementation of the _engine.Connection and _engine.Engine isolation level facilities; these APIs should be preferred for most typical use cases.

Provide a database-specific .TypeEngine object, given the generic object which comes from the types module.

This method looks for a dictionary called colspecs as a class or instance-level variable, and passes on to _types.adapt_type.