sqlalchemy.engine.interfaces.Dialect

Return the string name of the currently selected schema from the given connection.

This is used by the default implementation to populate the "default_schema_name" attribute and is called exactly once upon first connect.

Retrieve the server version info from the given connection.

This is used by the default implementation to populate the "server_version_info" attribute and is called exactly once upon first connect.

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.

Parameters
*cargs	positional parameters returned from the .Dialect.create_connect_args method
**cparams	keyword parameters returned from the .Dialect.create_connect_args method.
Returns
a DBAPI connection, typically from the PEP 249 module level .connect() function.

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]

Parameters
url	a .URL object
Returns
a tuple of (*args, **kwargs) which will be passed to the .Dialect.connect method.

Create a 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.

Parameters
dbapi​_connection	a DBAPI connection, typically proxied within a .ConnectionFairy.

Begin a two phase transaction on the given connection.

Parameters
connection	a _engine.Connection.
xid	xid

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 connection.commit(), given a DB-API connection.

Parameters
dbapi​_connection	a DBAPI connection, typically proxied within a .ConnectionFairy.

Commit a two phase transaction on the given connection.

Parameters
connection	a _engine.Connection.
xid	xid
is​_prepared	whether or not .TwoPhaseTransaction.prepare was called.
recover	if the recover flag was passed.

Provide an implementation of cursor.execute(statement, parameters).

Provide an implementation of cursor.execute(statement).

The parameter collection should not be sent.

Provide an implementation of cursor.executemany(statement, parameters).

Prepare a two phase transaction on the given connection.

Parameters
connection	a _engine.Connection.
xid	xid

Recover list of uncommitted prepared two phase transaction identifiers on the given connection.

Parameters
connection	a _engine.Connection.

Release the named savepoint on a connection.

Parameters
connection	a _engine.Connection.
name	savepoint name.

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

Parameters
dbapi​_connection	a DBAPI connection, typically proxied within a .ConnectionFairy.

Rollback a connection to the named savepoint.

Parameters
connection	a _engine.Connection.
name	savepoint name.

Rollback a two phase transaction on the given connection.

Parameters
connection	a _engine.Connection.
xid	xid
is​_prepared	whether or not .TwoPhaseTransaction.prepare was called.
recover	if the recover flag was passed.

Create a savepoint with the given name.

Parameters
connection	a _engine.Connection.
name	savepoint name.

invoke the cursor.setinputsizes() method with appropriate arguments

This hook is called if the dialect.use_inputsizes flag is set to True. Parameter data is passed in a list of tuples (paramname, dbtype, sqltype), where paramname is the key of the parameter in the statement, dbtype is the DBAPI datatype and sqltype is the SQLAlchemy type. The order of tuples is in the correct parameter order.

Return information about check constraints in table_name.

Given a string table_name and an optional string schema, return check constraint information as a list of dicts with these keys:

• name - the check constraint's name
• sqltext - the check constraint's SQL expression
• **kw - other options passed to the dialect's get_check_constraints() method.

Return information about columns in table_name.

Given a _engine.Connection, a string table_name, and an optional string schema, return column information as a list of dictionaries with these keys:

name

the column's name

type

[sqlalchemy.types#TypeEngine]

nullable

boolean

default

the column's default value

autoincrement

boolean

sequence

a dictionary of the form

{'name' : str, 'start' :int, 'increment': int, 'minvalue': int,

'maxvalue': int, 'nominvalue': bool, 'nomaxvalue': bool, 'cycle': bool, 'cache': int, 'order': bool}

Additional column attributes may be present.

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

This method may only raise NotImplementedError and must not raise any other exception, as it is used implicitly upon first connect.

The method must return a value for a dialect that supports isolation level settings, as this level is what will be reverted towards when a per-connection isolation level change is made.

The method defaults to using the .Dialect.get_isolation_level method unless overridden by a dialect.

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.

Return information about foreign_keys in table_name.

Given a _engine.Connection, a string table_name, and an optional string schema, return foreign key information as a list of dicts with these keys:

name

the constraint's name

constrained_columns

a list of column names that make up the foreign key

referred_schema

the name of the referred schema

referred_table

the name of the referred table

referred_columns

a list of column names in the referred table that correspond to constrained_columns

Return information about indexes in table_name.

Given a _engine.Connection, a string table_name and an optional string schema, return index information as a list of dictionaries with these keys:

name

the index's name

column_names

list of column names in order

unique

boolean

Given a DBAPI connection, return its isolation level.

When working with a _engine.Connection object, the corresponding DBAPI connection may be procured using the _engine.Connection.connection accessor.

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.

Return information about the primary key constraint on table_name`.

Given a _engine.Connection, a string table_name, and an optional string schema, return primary key information as a dictionary with these keys:

constrained_columns

a list of column names that make up the primary key

name

optional name of the primary key constraint.

Return a list of all sequence names available in the database.

Parameters
connection	Undocumented
schema	schema name to query, if not the default schema.
**kw	Undocumented

Return the "comment" for the table identified by table_name.

Given a string table_name and an optional string schema, return table comment information as a dictionary with this key:

text

text of the comment

Raises NotImplementedError for dialects that don't support comments.

Return a list of table names for schema.

Return a list of temporary table names on the given connection, if supported by the underlying backend.

Return a list of temporary view names on the given connection, if supported by the underlying backend.

Return information about unique constraints in table_name.

Given a string table_name and an optional string schema, return unique constraint information as a list of dicts with these keys:

name

the unique constraint's name

column_names

list of column names in order

**kw

other options passed to the dialect's get_unique_constraints() method.

Return view definition.

Given a _engine.Connection, a string view_name, and an optional string schema, return the view definition.

Return a list of all view names available in the database.

Parameters
connection	Undocumented
schema	schema name to query, if not the default schema.
**kw	Undocumented

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.

Check the existence of a particular sequence in the database.

Given a _engine.Connection object and a string sequence_name, return True if the given sequence exists in the database, False otherwise.

For internal dialect use, check the existence of a particular table in the database.

Given a _engine.Connection object, a string table_name and optional schema name, return True if the given table exists in the database, False otherwise.

This method serves as the underlying implementation of the public facing .Inspector.has_table method, and is also used internally to implement the "checkfirst" behavior for methods like _schema.Table.create and _schema.MetaData.create_all.

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().

Return True if the given DB-API error indicates an invalid connection

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.

Returns

a callable that accepts a single DBAPI connection as an argument, or None.

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

This method is a new hook that supersedes the _engine.Dialect.on_connect method when implemented by a dialect. When not implemented by a dialect, it invokes the _engine.Dialect.on_connect method directly to maintain compatibility with existing dialects. There is no deprecation for _engine.Dialect.on_connect expected.

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_url(self, url):
        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.

This method differs from _engine.Dialect.on_connect in that it is passed the _engine.URL object that's relevant to the connect args. Normally the only way to get this is from the _engine.Dialect.on_connect hook is to look on the _engine.Engine itself, however this URL object may have been replaced by plugins.

Parameters
url	a _engine.URL object representing the _engine.URL that was passed to the _engine.Dialect.create_connect_args method.
Returns
a callable that accepts a single DBAPI connection as an argument, or None.

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.

Given a DBAPI connection, set its isolation level.

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.