sqlalchemy.engine.interfaces.Dialect

class documentation

class Dialect(EventTarget): (source)

Known subclasses: sqlalchemy.connectors.Connector, sqlalchemy.engine.default.DefaultDialect

Define the behavior of a specific database and DB-API combination. Any aspect of metadata definition, SQL query generation, execution, result-set handling, or anything else which varies between databases is defined under the general category of the Dialect. The Dialect acts as a factory for other database-specific object implementations including ExecutionContext, Compiled, DefaultGenerator, and TypeEngine. .. note:: Third party dialects should not subclass :class:`.Dialect` directly. Instead, subclass :class:`.default.DefaultDialect` or descendant class.

Class Method	`engine_created`	A convenience hook called before returning the final :class:`_engine.Engine`.
Class Method	`get_async_dialect_cls`	Given a URL, return the :class:`.Dialect` that will be used by an async engine.
Class Method	`get_dialect_cls`	Given a URL, return the :class:`.Dialect` that will be used.
Class Method	`import_dbapi`	Import the DBAPI module that is used by this dialect.
Class Method	`load_provisioning`	set up the provision.py module for this dialect.
Class Method	`type_descriptor`	Transform a generic type to a dialect-specific type.
Method	`connect`	Establish a connection using this dialect's DBAPI.
Method	`create_connect_args`	Build DB-API compatible connection arguments.
Method	`create_xid`	Create a two-phase transaction ID.
Method	`denormalize_name`	convert the given name to a case insensitive identifier for the backend if it is an all-lowercase name.
Method	`do_begin`	Provide an implementation of ``connection.begin()``, given a DB-API connection.
Method	`do_begin_twophase`	Begin a two phase transaction on the given connection.
Method	`do_close`	Provide an implementation of ``connection.close()``, given a DBAPI connection.
Method	`do_commit`	Provide an implementation of ``connection.commit()``, given a DB-API connection.
Method	`do_commit_twophase`	Commit a two phase transaction on the given connection.
Method	`do_execute`	Provide an implementation of ``cursor.execute(statement, parameters)``.
Method	`do_execute_no_params`	Provide an implementation of ``cursor.execute(statement)``.
Method	`do_executemany`	Provide an implementation of ``cursor.executemany(statement, parameters)``.
Method	`do_ping`	ping the DBAPI connection and return True if the connection is usable.
Method	`do_prepare_twophase`	Prepare a two phase transaction on the given connection.
Method	`do_recover_twophase`	Recover list of uncommitted prepared two phase transaction identifiers on the given connection.
Method	`do_release_savepoint`	Release the named savepoint on a connection.
Method	`do_rollback`	Provide an implementation of ``connection.rollback()``, given a DB-API connection.
Method	`do_rollback_to_savepoint`	Rollback a connection to the named savepoint.
Method	`do_rollback_twophase`	Rollback a two phase transaction on the given connection.
Method	`do_savepoint`	Create a savepoint with the given name.
Method	`do_set_input_sizes`	invoke the cursor.setinputsizes() method with appropriate arguments
Method	`do_terminate`	Provide an implementation of ``connection.close()`` that tries as much as possible to not block, given a DBAPI connection.
Method	`get_check_constraints`	Return information about check constraints in ``table_name``.
Method	`get_columns`	Return information about columns in ``table_name``.
Method	`get_default_isolation_level`	Given a DBAPI connection, return its isolation level, or a default isolation level if one cannot be retrieved.
Method	`get_dialect_pool_class`	return a Pool class to use for a given URL
Method	`get_driver_connection`	Returns the connection object as returned by the external driver package.
Method	`get_foreign_keys`	Return information about foreign_keys in ``table_name``.
Method	`get_indexes`	Return information about indexes in ``table_name``.
Method	`get_isolation_level`	Given a DBAPI connection, return its isolation level.
Method	`get_isolation_level_values`	return a sequence of string isolation level names that are accepted by this dialect.
Method	`get_materialized_view_names`	Return a list of all materialized view names available in the database.
Method	`get_multi_check_constraints`	Return information about check constraints in all tables in the given ``schema``.
Method	`get_multi_columns`	Return information about columns in all tables in the given ``schema``.
Method	`get_multi_foreign_keys`	Return information about foreign_keys in all tables in the given ``schema``.
Method	`get_multi_indexes`	Return information about indexes in in all tables in the given ``schema``.
Method	`get_multi_pk_constraint`	Return information about primary key constraints in all tables in the given ``schema``.
Method	`get_multi_table_comment`	Return information about the table comment in all tables in the given ``schema``.
Method	`get_multi_table_options`	Return a dictionary of options specified when the tables in the given schema were created.
Method	`get_multi_unique_constraints`	Return information about unique constraints in all tables in the given ``schema``.
Method	`get_pk_constraint`	Return information about the primary key constraint on table_name`.
Method	`get_schema_names`	Return a list of all schema names available in the database.
Method	`get_sequence_names`	Return a list of all sequence names available in the database.
Method	`get_table_comment`	Return the "comment" for the table identified by ``table_name``.
Method	`get_table_names`	Return a list of table names for ``schema``.
Method	`get_table_options`	Return a dictionary of options specified when ``table_name`` was created.
Method	`get_temp_table_names`	Return a list of temporary table names on the given connection, if supported by the underlying backend.
Method	`get_temp_view_names`	Return a list of temporary view names on the given connection, if supported by the underlying backend.
Method	`get_unique_constraints`	Return information about unique constraints in ``table_name``.
Method	`get_view_definition`	Return plain or materialized view definition.
Method	`get_view_names`	Return a list of all non-materialized view names available in the database.
Method	`has_index`	Check the existence of a particular index name in the database.
Method	`has_schema`	Check the existence of a particular schema name in the database.
Method	`has_sequence`	Check the existence of a particular sequence in the database.
Method	`has_table`	For internal dialect use, check the existence of a particular table or view in the database.
Method	`initialize`	Called during strategized creation of the dialect with a connection.
Method	`is_disconnect`	Return True if the given DB-API error indicates an invalid connection
Method	`normalize_name`	convert the given name to lowercase if it is detected as case insensitive.
Method	`on_connect`	return a callable which sets up a newly created DBAPI connection.
Method	`on_connect_url`	return a callable which sets up a newly created DBAPI connection.
Method	`reset_isolation_level`	Given a DBAPI connection, revert its isolation to the default.
Method	`set_connection_execution_options`	Establish execution options for a given connection.
Method	`set_engine_execution_options`	Establish execution options for a given engine.
Method	`set_isolation_level`	Given a DBAPI connection, set its isolation level.
Class Variable	`colspecs`	A dictionary of TypeEngine classes from sqlalchemy.types mapped to subclasses that are specific to the dialect class. This dictionary is class-level only and is not accessed from the dialect instance itself.
Class Variable	`compiler_linting`	Undocumented
Class Variable	`construct_arguments`	Optional set of argument specifiers for various SQLAlchemy constructs, typically schema items.
Class Variable	`cte_follows_insert`	target database, when given a CTE with an INSERT statement, needs the CTE to be below the INSERT
Class Variable	`dbapi`	A reference to the DBAPI module object itself.
Class Variable	`ddl_compiler`	a :class:`.Compiled` class used to compile DDL statements
Class Variable	`default_isolation_level`	the isolation that is implicitly present on new connections
Class Variable	`default_metavalue_token`	for INSERT... VALUES (DEFAULT) syntax, the token to put in the parenthesis.
Class Variable	`default_schema_name`	the name of the default schema. This value is only available for supporting dialects, and is typically populated during the initial connection to the database.
Class Variable	`default_sequence_base`	the default value that will be rendered as the "START WITH" portion of a CREATE SEQUENCE DDL statement.
Class Variable	`delete_executemany_returning`	dialect supports DELETE..RETURNING with executemany.
Class Variable	`delete_returning`	if the dialect supports RETURNING with DELETE
Class Variable	`delete_returning_multifrom`	if the dialect supports RETURNING with DELETE..FROM
Class Variable	`dialect_description`	Undocumented
Class Variable	`dispatch`	Undocumented
Class Variable	`div_is_floordiv`	target database treats the / division operator as "floor division"
Class Variable	`driver`	identifying name for the dialect's DBAPI
Class Variable	`engine_config_types`	a mapping of string keys that can be in an engine config linked to type conversion functions.
Class Variable	`exclude_set_input_sizes`	set of DBAPI type objects that should be excluded in automatic cursor.setinputsizes() calls.
Class Variable	`execute_sequence_format`	either the 'tuple' or 'list' type, depending on what cursor.execute() accepts for the second argument (they vary).
Class Variable	`execution_ctx_cls`	a :class:`.ExecutionContext` class used to handle statement execution
Class Variable	`favor_returning_over_lastrowid`	for backends that support both a lastrowid and a RETURNING insert strategy, favor RETURNING for simple single-int pk inserts.
Class Variable	`has_terminate`	Whether or not this dialect has a separate "terminate" implementation that does not block or require awaiting.
Class Variable	`identifier_preparer`	This element will refer to an instance of :class:`.IdentifierPreparer` once a :class:`.DefaultDialect` has been constructed.
Class Variable	`include_set_input_sizes`	set of DBAPI type objects that should be included in automatic cursor.setinputsizes() calls.
Class Variable	`inline_comments`	Indicates the dialect supports comment DDL that's inline with the definition of a Table or Column. If False, this implies that ALTER must be used to set table and column comments.
Class Variable	`insert_executemany_returning`	dialect / driver / database supports some means of providing INSERT...RETURNING support when dialect.do_executemany() is used.
Class Variable	`insert_returning`	if the dialect supports RETURNING with INSERT
Class Variable	`insertmanyvalues_max_parameters`	Alternate to insertmanyvalues_page_size, will additionally limit page size based on number of parameters total in the statement.
Class Variable	`insertmanyvalues_page_size`	Number of rows to render into an individual INSERT..VALUES() statement for :attr:`.ExecuteStyle.INSERTMANYVALUES` executions.
Class Variable	`is_async`	Whether or not this dialect is intended for asyncio use.
Class Variable	`label_length`	optional user-defined max length for SQL labels
Class Variable	`max_identifier_length`	The maximum length of identifier names.
Class Variable	`name`	identifying name for the dialect from a DBAPI-neutral point of view (i.e. 'sqlite')
Class Variable	`paramstyle`	the paramstyle to be used (some DB-APIs support multiple paramstyles).
Class Variable	`positional`	True if the paramstyle for this Dialect is positional.
Class Variable	`preexecute_autoincrement_sequences`	True if 'implicit' primary key functions must be executed separately in order to get their value, if RETURNING is not used.
Class Variable	`preparer`	a :class:`.IdentifierPreparer` class used to quote identifiers.
Class Variable	`reflection_options`	Sequence of string names indicating keyword arguments that can be established on a :class:`.Table` object which will be passed as "reflection options" when using :paramref:`.Table.autoload_with`.
Class Variable	`sequences_optional`	If True, indicates if the :paramref:`_schema.Sequence.optional` parameter on the :class:`_schema.Sequence` construct should signal to not generate a CREATE SEQUENCE. Applies only to dialects that support sequences...
Class Variable	`server_side_cursors`	deprecated; indicates if the dialect should attempt to use server side cursors by default
Class Variable	`server_version_info`	a tuple containing a version number for the DB backend in use.
Class Variable	`statement_compiler`	a :class:`.Compiled` class used to compile SQL statements
Class Variable	`supports_alter`	``True`` if the database supports ``ALTER TABLE`` - used only for generating foreign key constraints in certain circumstances
Class Variable	`supports_comments`	Indicates the dialect supports comment DDL on tables and columns.
Class Variable	`supports_constraint_comments`	Indicates if the dialect supports comment DDL on constraints.
Class Variable	`supports_default_metavalue`	dialect supports INSERT...(col) VALUES (DEFAULT) syntax.
Class Variable	`supports_default_values`	dialect supports INSERT... DEFAULT VALUES syntax
Class Variable	`supports_empty_insert`	dialect supports INSERT () VALUES (), i.e. a plain INSERT with no columns in it.
Class Variable	`supports_identity_columns`	target database supports IDENTITY
Class Variable	`supports_multivalues_insert`	Target database supports INSERT...VALUES with multiple value sets, i.e. INSERT INTO table (cols) VALUES (...), (...), (...), ...
Class Variable	`supports_native_boolean`	Indicates if the dialect supports a native boolean construct. This will prevent :class:`_types.Boolean` from generating a CHECK constraint when that type is used.
Class Variable	`supports_native_decimal`	indicates if Decimal objects are handled and returned for precision numeric types, or if floats are returned
Class Variable	`supports_native_enum`	Indicates if the dialect supports a native ENUM construct. This will prevent :class:`_types.Enum` from generating a CHECK constraint when that type is used in "native" mode.
Class Variable	`supports_native_uuid`	indicates if Python UUID() objects are handled natively by the driver for SQL UUID datatypes.
Class Variable	`supports_sane_multi_rowcount`	Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements when executed via executemany.
Class Variable	`supports_sane_rowcount`	Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements.
Class Variable	`supports_sequences`	Indicates if the dialect supports CREATE SEQUENCE or similar.
Class Variable	`supports_server_side_cursors`	indicates if the dialect supports server side cursors
Class Variable	`supports_simple_order_by_label`	target database supports ORDER BY <labelname>, where <labelname> refers to a label in the columns clause of the SELECT
Class Variable	`supports_statement_cache`	indicates if this dialect supports caching.
Class Variable	`tuple_in_values`	target database supports tuple IN, i.e. (x, y) IN ((q, p), (r, z))
Class Variable	`type_compiler`	legacy; this is a TypeCompiler class at the class level, a TypeCompiler instance at the instance level.
Class Variable	`type_compiler_cls`	a :class:`.Compiled` class used to compile SQL type objects
Class Variable	`type_compiler_instance`	instance of a :class:`.Compiled` class used to compile SQL type objects
Class Variable	`update_executemany_returning`	dialect supports UPDATE..RETURNING with executemany.
Class Variable	`update_returning`	if the dialect supports RETURNING with UPDATE
Class Variable	`update_returning_multifrom`	if the dialect supports RETURNING with UPDATE..FROM
Class Variable	`use_insertmanyvalues`	if True, indicates "insertmanyvalues" functionality should be used to allow for ``insert_executemany_returning`` behavior, if possible.
Class Variable	`use_insertmanyvalues_wo_returning`	if True, and use_insertmanyvalues is also True, INSERT statements that don't include RETURNING will also use "insertmanyvalues".
Property	`loaded_dbapi`	same as .dbapi, but is never None; will raise an error if no DBAPI was set up.
Method	`_assert_and_set_isolation_level`	Undocumented
Method	`_builtin_onconnect`	Undocumented
Method	`_deliver_insertmanyvalues_batches`	convert executemany parameters for an INSERT into an iterator of statement/single execute values, used by the insertmanyvalues feature.
Method	`_do_ping_w_event`	Undocumented
Method	`_get_default_schema_name`	Return the string name of the currently selected schema from the given connection.
Method	`_get_server_version_info`	Retrieve the server version info from the given connection.
Method	`_overrides_default`	Undocumented
Class Variable	`_bind_typing_render_casts`	Undocumented
Class Variable	`_has_events`	Undocumented
Class Variable	`_on_connect_isolation_level`	Undocumented
Class Variable	`_supports_statement_cache`	internal evaluation for supports_statement_cache
Class Variable	`_type_memos`	Undocumented

@classmethod
def engine_created(cls, engine: Engine): (source) ¶

A convenience hook called before returning the final :class:`_engine.Engine`. If the dialect returned a different class from the :meth:`.get_dialect_cls` method, then the hook is called on both classes, first on the dialect class returned by the :meth:`.get_dialect_cls` method and then on the class on which the method was called. The hook should be used by dialects and/or wrappers to apply special events to the engine or its components. In particular, it allows a dialect-wrapping class to apply dialect-level events. .. versionadded:: 1.0.3

@classmethod
def get_async_dialect_cls(cls, url: URL) -> Type[Dialect]: (source) ¶

overridden in sqlalchemy.dialects.postgresql.psycopg.PGDialect_psycopg

Given a URL, return the :class:`.Dialect` that will be used by an async engine. By default this is an alias of :meth:`.Dialect.get_dialect_cls` and just returns the cls. It may be used if a dialect provides both a sync and async version under the same name, like the ``psycopg`` driver. .. versionadded:: 2 .. seealso:: :meth:`.Dialect.get_dialect_cls`

@classmethod
def get_dialect_cls(cls, url: URL) -> Type[Dialect]: (source) ¶

Given a URL, return the :class:`.Dialect` that will be used. This is a hook that allows an external plugin to provide functionality around an existing dialect, by allowing the plugin to be loaded from the url based on an entrypoint, and then the plugin returns the actual dialect to be used. By default this just returns the cls. .. versionadded:: 1.0.3

@classmethod
def import_dbapi(cls) -> ModuleType: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.dialects.mssql.pymssql.MSDialect_pymssql, sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.asyncpg.PGDialect_asyncpg, sqlalchemy.dialects.postgresql.pg8000.PGDialect_pg8000, sqlalchemy.dialects.postgresql.psycopg.PGDialect_psycopg, sqlalchemy.dialects.postgresql.psycopg2.PGDialect_psycopg2, sqlalchemy.dialects.sqlite.pysqlite.SQLiteDialect_pysqlite

Import the DBAPI module that is used by this dialect. The Python module object returned here will be assigned as an instance variable to a constructed dialect under the name ``.dbapi``. .. versionchanged:: 2.0 The :meth:`.Dialect.import_dbapi` class method is renamed from the previous method ``.Dialect.dbapi()``, which would be replaced at dialect instantiation time by the DBAPI module itself, thus using the same name in two different ways. If a ``.Dialect.dbapi()`` classmethod is present on a third-party dialect, it will be used and a deprecation warning will be emitted.

@classmethod
def load_provisioning(cls): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

set up the provision.py module for this dialect. For dialects that include a provision.py module that sets up provisioning followers, this method should initiate that process. A typical implementation would be:: @classmethod def load_provisioning(cls): __import__("mydialect.provision") The default method assumes a module named ``provision.py`` inside the owning package of the current dialect, based on the ``__module__`` attribute:: @classmethod def load_provisioning(cls): package = ".".join(cls.__module__.split(".")[0:-1]) try: __import__(package + ".provision") except ImportError: pass .. versionadded:: 1.3.14

@classmethod
def type_descriptor(cls, typeobj: TypeEngine[_T]) -> TypeEngine[_T]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Transform a generic type to a dialect-specific type. Dialect classes will usually use the :func:`_types.adapt_type` function in the types module to accomplish this. The returned result is cached *per dialect class* so can contain no dialect-instance state.

def connect(self, *cargs: Any, **cparams: Any) -> DBAPIConnection: (source) ¶

overridden in 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 :meth:`.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. :param \*cargs: positional parameters returned from the :meth:`.Dialect.create_connect_args` method :param \*\*cparams: keyword parameters returned from the :meth:`.Dialect.create_connect_args` method. :return: a DBAPI connection, typically from the :pep:`249` module level ``.connect()`` function. .. seealso:: :meth:`.Dialect.create_connect_args` :meth:`.Dialect.on_connect`

def create_connect_args(self, url: URL) -> ConnectArgsType: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.engine.default.DefaultDialect

Build DB-API compatible connection arguments. Given a :class:`.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 :meth:`.Dialect.connect` method which then runs the DBAPI-level ``connect()`` function. The method typically makes use of the :meth:`.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] :param url: a :class:`.URL` object :return: a tuple of ``(*args, **kwargs)`` which will be passed to the :meth:`.Dialect.connect` method. .. seealso:: :meth:`.URL.translate_connect_args`

def create_xid(self) -> Any: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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.

def denormalize_name(self, name: str) -> str: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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.

def do_begin(self, dbapi_connection: PoolProxiedConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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. :param dbapi_connection: a DBAPI connection, typically proxied within a :class:`.ConnectionFairy`.

def do_begin_twophase(self, connection: Connection, xid: Any): (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect

Begin a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid

def do_close(self, dbapi_connection: DBAPIConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Provide an implementation of ``connection.close()``, given a DBAPI connection. This hook is called by the :class:`_pool.Pool` when a connection has been detached from the pool, or is being returned beyond the normal capacity of the pool.

def do_commit(self, dbapi_connection: PoolProxiedConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Provide an implementation of ``connection.commit()``, given a DB-API connection. :param dbapi_connection: a DBAPI connection, typically proxied within a :class:`.ConnectionFairy`.

def do_commit_twophase(self, connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False): (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect

Commit a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid :param is_prepared: whether or not :meth:`.TwoPhaseTransaction.prepare` was called. :param recover: if the recover flag was passed.

def do_execute(self, cursor: DBAPICursor, statement: str, parameters: Optional[_DBAPISingleExecuteParams], context: Optional[ExecutionContext] = None): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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

def do_execute_no_params(self, cursor: DBAPICursor, statement: str, context: Optional[ExecutionContext] = None): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Provide an implementation of ``cursor.execute(statement)``. The parameter collection should not be sent.

def do_executemany(self, cursor: DBAPICursor, statement: str, parameters: _DBAPIMultiExecuteParams, context: Optional[ExecutionContext] = None): (source) ¶

overridden in sqlalchemy.dialects.mssql.pyodbc.MSDialect_pyodbc, sqlalchemy.engine.default.DefaultDialect

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

def do_ping(self, dbapi_connection: DBAPIConnection) -> bool: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

ping the DBAPI connection and return True if the connection is usable.

def do_prepare_twophase(self, connection: Connection, xid: Any): (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect

Prepare a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid

def do_recover_twophase(self, connection: Connection) -> List[Any]: (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect

Recover list of uncommitted prepared two phase transaction identifiers on the given connection. :param connection: a :class:`_engine.Connection`.

def do_release_savepoint(self, connection: Connection, name: str): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Release the named savepoint on a connection. :param connection: a :class:`_engine.Connection`. :param name: savepoint name.

def do_rollback(self, dbapi_connection: PoolProxiedConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Provide an implementation of ``connection.rollback()``, given a DB-API connection. :param dbapi_connection: a DBAPI connection, typically proxied within a :class:`.ConnectionFairy`.

def do_rollback_to_savepoint(self, connection: Connection, name: str): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Rollback a connection to the named savepoint. :param connection: a :class:`_engine.Connection`. :param name: savepoint name.

def do_rollback_twophase(self, connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False): (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect

Rollback a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid :param is_prepared: whether or not :meth:`.TwoPhaseTransaction.prepare` was called. :param recover: if the recover flag was passed.

def do_savepoint(self, connection: Connection, name: str): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Create a savepoint with the given name. :param connection: a :class:`_engine.Connection`. :param name: savepoint name.

def do_set_input_sizes(self, cursor: DBAPICursor, list_of_tuples: _GenericSetInputSizesType, context: ExecutionContext) -> Any: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle

invoke the cursor.setinputsizes() method with appropriate arguments This hook is called if the :attr:`.Dialect.bind_typing` attribute is set to the :attr:`.BindTyping.SETINPUTSIZES` value. 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. .. versionadded:: 1.4 .. versionchanged:: 2.0 - setinputsizes mode is now enabled by setting :attr:`.Dialect.bind_typing` to :attr:`.BindTyping.SETINPUTSIZES`. Dialects which accept a ``use_setinputsizes`` parameter should set this value appropriately.

def do_terminate(self, dbapi_connection: DBAPIConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Provide an implementation of ``connection.close()`` that tries as much as possible to not block, given a DBAPI connection. In the vast majority of cases this just calls .close(), however for some asyncio dialects may call upon different API features. This hook is called by the :class:`_pool.Pool` when a connection is being recycled or has been invalidated. .. versionadded:: 1.4.41

def get_check_constraints(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> List[ReflectedCheckConstraint]: (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

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 corresponding to the :class:`.ReflectedCheckConstraint` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_check_constraints`. .. versionadded:: 1.1.0

def get_columns(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> List[ReflectedColumn]: (source) ¶

overridden in sqlalchemy.dialects.mssql.base.MSDialect, sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

Return information about columns in ``table_name``. Given a :class:`_engine.Connection`, a string ``table_name``, and an optional string ``schema``, return column information as a list of dictionaries corresponding to the :class:`.ReflectedColumn` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_columns`.

def get_default_isolation_level(self, dbapi_conn: DBAPIConnection) -> IsolationLevel: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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 :meth:`.Dialect.get_isolation_level` method unless overridden by a dialect. .. versionadded:: 1.3.22

def get_dialect_pool_class(self, url: URL) -> Type[Pool]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

return a Pool class to use for a given URL

def get_driver_connection(self, connection: DBAPIConnection) -> Any: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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. .. versionadded:: 1.4.24

def get_foreign_keys(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> List[ReflectedForeignKeyConstraint]: (source) ¶

Return information about foreign_keys in ``table_name``. Given a :class:`_engine.Connection`, a string ``table_name``, and an optional string ``schema``, return foreign key information as a list of dicts corresponding to the :class:`.ReflectedForeignKeyConstraint` dictionary. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_foreign_keys`.

def get_indexes(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> List[ReflectedIndex]: (source) ¶

Return information about indexes in ``table_name``. Given a :class:`_engine.Connection`, a string ``table_name`` and an optional string ``schema``, return index information as a list of dictionaries corresponding to the :class:`.ReflectedIndex` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_indexes`.

def get_isolation_level(self, dbapi_connection: DBAPIConnection) -> IsolationLevel: (source) ¶

overridden in sqlalchemy.dialects.mssql.base.MSDialect, sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

Given a DBAPI connection, return its isolation level. When working with a :class:`_engine.Connection` object, the corresponding DBAPI connection may be procured using the :attr:`_engine.Connection.connection` accessor. Note that this is a dialect-level method which is used as part of the implementation of the :class:`_engine.Connection` and :class:`_engine.Engine` isolation level facilities; these APIs should be preferred for most typical use cases. .. seealso:: :meth:`_engine.Connection.get_isolation_level` - view current level :attr:`_engine.Connection.default_isolation_level` - view default level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level

def get_isolation_level_values(self, dbapi_conn: DBAPIConnection) -> List[IsolationLevel]: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.dialects.mssql.base.MSDialect, sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

return a sequence of string isolation level names that are accepted by this dialect. The available names should use the following conventions: * use UPPERCASE names. isolation level methods will accept lowercase names but these are normalized into UPPERCASE before being passed along to the dialect. * separate words should be separated by spaces, not underscores, e.g. ``REPEATABLE READ``. isolation level names will have underscores converted to spaces before being passed along to the dialect. * The names for the four standard isolation names to the extent that they are supported by the backend should be ``READ UNCOMMITTED`` ``READ COMMITTED``, ``REPEATABLE READ``, ``SERIALIZABLE`` * if the dialect supports an autocommit option it should be provided using the isolation level name ``AUTOCOMMIT``. * Other isolation modes may also be present, provided that they are named in UPPERCASE and use spaces not underscores. This function is used so that the default dialect can check that a given isolation level parameter is valid, else raises an :class:`_exc.ArgumentError`. A DBAPI connection is passed to the method, in the unlikely event that the dialect needs to interrogate the connection itself to determine this list, however it is expected that most backends will return a hardcoded list of values. If the dialect supports "AUTOCOMMIT", that value should also be present in the sequence returned. The method raises ``NotImplementedError`` by default. If a dialect does not implement this method, then the default dialect will not perform any checking on a given isolation level value before passing it onto the :meth:`.Dialect.set_isolation_level` method. This is to allow backwards-compatibility with third party dialects that may not yet be implementing this method. .. versionadded:: 2.0

def get_materialized_view_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

overridden in sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect

Return a list of all materialized view names available in the database. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_materialized_view_names`. :param schema: schema name to query, if not the default schema. .. versionadded:: 2.0

def get_multi_check_constraints(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, List[ReflectedCheckConstraint]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about check constraints in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`.Inspector.get_multi_check_constraints`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_columns(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, List[ReflectedColumn]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about columns in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`.Inspector.get_multi_columns`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_foreign_keys(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, List[ReflectedForeignKeyConstraint]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about foreign_keys in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_multi_foreign_keys`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_indexes(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, List[ReflectedIndex]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about indexes in in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`.Inspector.get_multi_indexes`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_pk_constraint(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, ReflectedPrimaryKeyConstraint]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about primary key constraints in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`.Inspector.get_multi_pk_constraint`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_table_comment(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, ReflectedTableComment]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about the table comment in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_multi_table_comment`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_table_options(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, Dict[str, Any]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return a dictionary of options specified when the tables in the given schema were created. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_multi_table_options`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_multi_unique_constraints(self, connection: Connection, schema: Optional[str] = None, filter_names: Optional[Collection[str]] = None, **kw: Any) -> Iterable[Tuple[TableKey, List[ReflectedUniqueConstraint]]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Return information about unique constraints in all tables in the given ``schema``. This is an internal dialect method. Applications should use :meth:`.Inspector.get_multi_unique_constraints`. .. note:: The :class:`_engine.DefaultDialect` provides a default implementation that will call the single table method for each object returned by :meth:`Dialect.get_table_names`, :meth:`Dialect.get_view_names` or :meth:`Dialect.get_materialized_view_names` depending on the provided ``kind``. Dialects that want to support a faster implementation should implement this method. .. versionadded:: 2.0

def get_pk_constraint(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> ReflectedPrimaryKeyConstraint: (source) ¶

Return information about the primary key constraint on table_name`. Given a :class:`_engine.Connection`, a string ``table_name``, and an optional string ``schema``, return primary key information as a dictionary corresponding to the :class:`.ReflectedPrimaryKeyConstraint` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_pk_constraint`.

def get_schema_names(self, connection: Connection, **kw: Any) -> List[str]: (source) ¶

Return a list of all schema names available in the database. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_schema_names`.

def get_sequence_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

Return a list of all sequence names available in the database. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_sequence_names`. :param schema: schema name to query, if not the default schema. .. versionadded:: 1.4

def get_table_comment(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> ReflectedTableComment: (source) ¶

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 corresponding to the :class:`.ReflectedTableComment` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_table_comment`. :raise: ``NotImplementedError`` for dialects that don't support comments. .. versionadded:: 1.2

def get_table_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

Return a list of table names for ``schema``. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_table_names`.

def get_table_options(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> Dict[str, Any]: (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.base.OracleDialect

Return a dictionary of options specified when ``table_name`` was created. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_table_options`.

def get_temp_table_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

overridden in sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

Return a list of temporary table names on the given connection, if supported by the underlying backend. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_temp_table_names`.

def get_temp_view_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

overridden in sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

Return a list of temporary view names on the given connection, if supported by the underlying backend. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_temp_view_names`.

def get_unique_constraints(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> List[ReflectedUniqueConstraint]: (source) ¶

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 corresponding to the :class:`.ReflectedUniqueConstraint` dictionary. This is an internal dialect method. Applications should use :meth:`.Inspector.get_unique_constraints`.

def get_view_definition(self, connection: Connection, view_name: str, schema: Optional[str] = None, **kw: Any) -> str: (source) ¶

Return plain or materialized view definition. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_view_definition`. Given a :class:`_engine.Connection`, a string ``view_name``, and an optional string ``schema``, return the view definition.

def get_view_names(self, connection: Connection, schema: Optional[str] = None, **kw: Any) -> List[str]: (source) ¶

Return a list of all non-materialized view names available in the database. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.get_view_names`. :param schema: schema name to query, if not the default schema.

def has_index(self, connection: Connection, table_name: str, index_name: str, schema: Optional[str] = None, **kw: Any) -> bool: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Check the existence of a particular index name in the database. Given a :class:`_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 :class:`.DefaultDialect` implements this in terms of the :meth:`.Dialect.has_table` and :meth:`.Dialect.get_indexes` methods, however dialects can implement a more performant version. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.has_index`. .. versionadded:: 1.4

def has_schema(self, connection: Connection, schema_name: str, **kw: Any) -> bool: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Check the existence of a particular schema name in the database. Given a :class:`_engine.Connection` object, a string ``schema_name``, return ``True`` if a schema of the given exists, ``False`` otherwise. The :class:`.DefaultDialect` implements this by checking the presence of ``schema_name`` among the schemas returned by :meth:`.Dialect.get_schema_names`, however dialects can implement a more performant version. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.has_schema`. .. versionadded:: 2.0

def has_sequence(self, connection: Connection, sequence_name: str, schema: Optional[str] = None, **kw: Any) -> bool: (source) ¶

Check the existence of a particular sequence in the database. Given a :class:`_engine.Connection` object and a string `sequence_name`, return ``True`` if the given sequence exists in the database, ``False`` otherwise. This is an internal dialect method. Applications should use :meth:`_engine.Inspector.has_sequence`.

def has_table(self, connection: Connection, table_name: str, schema: Optional[str] = None, **kw: Any) -> bool: (source) ¶

For internal dialect use, check the existence of a particular table or view in the database. Given a :class:`_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 :meth:`.Inspector.has_table` method, and is also used internally to implement the "checkfirst" behavior for methods like :meth:`_schema.Table.create` and :meth:`_schema.MetaData.create_all`. .. note:: This method is used internally by SQLAlchemy, and is published so that third-party dialects may provide an implementation. It is **not** the public API for checking for table presence. Please use the :meth:`.Inspector.has_table` method. .. versionchanged:: 2.0:: :meth:`_engine.Dialect.has_table` now formally supports checking for additional table-like objects: * any type of views (plain or materialized) * temporary tables of any kind Previously, these two checks were not formally specified and different dialects would vary in their behavior. The dialect testing suite now includes tests for all of these object types, and dialects to the degree that the backing database supports views or temporary tables should seek to support locating these objects for full compliance.

def initialize(self, connection: Connection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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(). .. note:: as of SQLAlchemy 1.4, this method is called **before** any :meth:`_engine.Dialect.on_connect` hooks are called.

def is_disconnect(self, e: Exception, connection: Optional[Union[PoolProxiedConnection, DBAPIConnection]], cursor: Optional[DBAPICursor]) -> bool: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.engine.default.DefaultDialect

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

def normalize_name(self, name: str) -> str: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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.

def on_connect(self) -> Optional[Callable[[Any], Any]]: (source) ¶

overridden in sqlalchemy.dialects.mssql.pyodbc.MSDialect_pyodbc, sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc, sqlalchemy.engine.default.DefaultDialect

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 :meth:`_events.PoolEvents.connect` event hook, then unwrapping the DBAPI connection and passing it into the callable. .. versionchanged:: 1.4 the on_connect hook is no longer called twice for the first connection of a dialect. The on_connect hook is still called before the :meth:`_engine.Dialect.initialize` method however. .. versionchanged:: 1.4.3 the on_connect hook is invoked from a new method on_connect_url that passes the URL that was used to create the connect args. Dialects can implement on_connect_url instead of on_connect if they need the URL object that was used for the connection in order to get additional context. If None is returned, no event listener is generated. :return: a callable that accepts a single DBAPI connection as an argument, or None. .. seealso:: :meth:`.Dialect.connect` - allows the DBAPI ``connect()`` sequence itself to be controlled. :meth:`.Dialect.on_connect_url` - supersedes :meth:`.Dialect.on_connect` to also receive the :class:`_engine.URL` object in context.

def on_connect_url(self, url: URL) -> Optional[Callable[[Any], Any]]: (source) ¶

overridden in sqlalchemy.dialects.sqlite.pysqlcipher.SQLiteDialect_pysqlcipher

return a callable which sets up a newly created DBAPI connection. This method is a new hook that supersedes the :meth:`_engine.Dialect.on_connect` method when implemented by a dialect. When not implemented by a dialect, it invokes the :meth:`_engine.Dialect.on_connect` method directly to maintain compatibility with existing dialects. There is no deprecation for :meth:`_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 :meth:`_engine.Dialect.on_connect` in that it is passed the :class:`_engine.URL` object that's relevant to the connect args. Normally the only way to get this is from the :meth:`_engine.Dialect.on_connect` hook is to look on the :class:`_engine.Engine` itself, however this URL object may have been replaced by plugins. .. note:: The default implementation of :meth:`_engine.Dialect.on_connect_url` is to invoke the :meth:`_engine.Dialect.on_connect` method. Therefore if a dialect implements this method, the :meth:`_engine.Dialect.on_connect` method **will not be called** unless the overriding dialect calls it directly from here. .. versionadded:: 1.4.3 added :meth:`_engine.Dialect.on_connect_url` which normally calls into :meth:`_engine.Dialect.on_connect`. :param url: a :class:`_engine.URL` object representing the :class:`_engine.URL` that was passed to the :meth:`_engine.Dialect.create_connect_args` method. :return: a callable that accepts a single DBAPI connection as an argument, or None. .. seealso:: :meth:`_engine.Dialect.on_connect`

def reset_isolation_level(self, dbapi_connection: DBAPIConnection): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

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 :class:`_engine.Connection` and :class:`_engine.Engine` isolation level facilities; these APIs should be preferred for most typical use cases. .. seealso:: :meth:`_engine.Connection.get_isolation_level` - view current level :attr:`_engine.Connection.default_isolation_level` - view default level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level

def set_connection_execution_options(self, connection: Connection, opts: CoreExecuteOptionsParameter): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Establish execution options for a given connection. This is implemented by :class:`.DefaultDialect` in order to implement the :paramref:`_engine.Connection.execution_options.isolation_level` execution option. Dialects can intercept various execution options which may need to modify state on a particular DBAPI connection. .. versionadded:: 1.4

def set_engine_execution_options(self, engine: Engine, opts: CoreExecuteOptionsParameter): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Establish execution options for a given engine. This is implemented by :class:`.DefaultDialect` to establish event hooks for new :class:`.Connection` instances created by the given :class:`.Engine` which will then invoke the :meth:`.Dialect.set_connection_execution_options` method for that connection.

def set_isolation_level(self, dbapi_connection: DBAPIConnection, level: IsolationLevel): (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.dialects.mssql.base.MSDialect, sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.base.SQLiteDialect

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 :class:`_engine.Connection` and :class:`_engine.Engine` isolation level facilities; these APIs should be preferred for most typical use cases. If the dialect also implements the :meth:`.Dialect.get_isolation_level_values` method, then the given level is guaranteed to be one of the string names within that sequence, and the method will not need to anticipate a lookup failure. .. seealso:: :meth:`_engine.Connection.get_isolation_level` - view current level :attr:`_engine.Connection.default_isolation_level` - view default level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level

colspecs: MutableMapping[Type[TypeEngine[Any]], Type[TypeEngine[Any]]] = (source) ¶

overridden in sqlalchemy.dialects.mssql.pyodbc.MSDialect_pyodbc, sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc, sqlalchemy.engine.default.DefaultDialect

A dictionary of TypeEngine classes from sqlalchemy.types mapped to subclasses that are specific to the dialect class. This dictionary is class-level only and is not accessed from the dialect instance itself.

compiler_linting: Linting = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

construct_arguments: Optional[List[Tuple[Type[Union[SchemaItem, ClauseElement]], Mapping[str, Any]]]] = (source) ¶

Optional set of argument specifiers for various SQLAlchemy constructs, typically schema items. To implement, establish as a series of tuples, as in:: construct_arguments = [ (schema.Index, { "using": False, "where": None, "ops": None }) ] If the above construct is established on the PostgreSQL dialect, the :class:`.Index` construct will now accept the keyword arguments ``postgresql_using``, ``postgresql_where``, nad ``postgresql_ops``. Any other argument specified to the constructor of :class:`.Index` which is prefixed with ``postgresql_`` will raise :class:`.ArgumentError`. A dialect which does not include a ``construct_arguments`` member will not participate in the argument validation system. For such a dialect, any argument name is accepted by all participating constructs, within the namespace of arguments prefixed with that dialect name. The rationale here is so that third-party dialects that haven't yet implemented this feature continue to function in the old way. .. versionadded:: 0.9.2 .. seealso:: :class:`.DialectKWArgs` - implementing base class which consumes :attr:`.DefaultDialect.construct_arguments`

cte_follows_insert: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

target database, when given a CTE with an INSERT statement, needs the CTE to be below the INSERT

dbapi: Optional[ModuleType] = (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.engine.default.DefaultDialect

A reference to the DBAPI module object itself. SQLAlchemy dialects import DBAPI modules using the classmethod :meth:`.Dialect.import_dbapi`. The rationale is so that any dialect module can be imported and used to generate SQL statements without the need for the actual DBAPI driver to be installed. Only when an :class:`.Engine` is constructed using :func:`.create_engine` does the DBAPI get imported; at that point, the creation process will assign the DBAPI module to this attribute. Dialects should therefore implement :meth:`.Dialect.import_dbapi` which will import the necessary module and return it, and then refer to ``self.dbapi`` in dialect code in order to refer to the DBAPI module contents. .. versionchanged:: The :attr:`.Dialect.dbapi` attribute is exclusively used as the per-:class:`.Dialect`-instance reference to the DBAPI module. The previous not-fully-documented ``.Dialect.dbapi()`` classmethod is deprecated and replaced by :meth:`.Dialect.import_dbapi`.

ddl_compiler: Type[DDLCompiler] = (source) ¶

a :class:`.Compiled` class used to compile DDL statements

default_isolation_level: Optional[IsolationLevel] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

the isolation that is implicitly present on new connections

default_metavalue_token: str = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

for INSERT... VALUES (DEFAULT) syntax, the token to put in the parenthesis. E.g. for SQLite this is the keyword "NULL".

default_schema_name: Optional[str] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

the name of the default schema. This value is only available for supporting dialects, and is typically populated during the initial connection to the database.

default_sequence_base: int = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

the default value that will be rendered as the "START WITH" portion of a CREATE SEQUENCE DDL statement.

delete_executemany_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect supports DELETE..RETURNING with executemany.

delete_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if the dialect supports RETURNING with DELETE .. versionadded:: 2.0

delete_returning_multifrom: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if the dialect supports RETURNING with DELETE..FROM .. versionadded:: 2.0

dialect_description: str = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

dispatch: dispatcher[Dialect] = (source) ¶

Undocumented

div_is_floordiv: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

target database treats the / division operator as "floor division"

driver: str = (source) ¶

identifying name for the dialect's DBAPI

engine_config_types: Mapping[str, Any] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

a mapping of string keys that can be in an engine config linked to type conversion functions.

exclude_set_input_sizes: Optional[Set[Any]] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

set of DBAPI type objects that should be excluded in automatic cursor.setinputsizes() calls. This is only used if bind_typing is BindTyping.SET_INPUT_SIZES

execute_sequence_format: Union[Type[Tuple[Any, ...]], Type[Tuple[List[Any]]]] = (source) ¶

either the 'tuple' or 'list' type, depending on what cursor.execute() accepts for the second argument (they vary).

execution_ctx_cls: Type[ExecutionContext] = (source) ¶

a :class:`.ExecutionContext` class used to handle statement execution

favor_returning_over_lastrowid: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

for backends that support both a lastrowid and a RETURNING insert strategy, favor RETURNING for simple single-int pk inserts. cursor.lastrowid tends to be more performant on most backends.

has_terminate: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Whether or not this dialect has a separate "terminate" implementation that does not block or require awaiting.

identifier_preparer: IdentifierPreparer = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

This element will refer to an instance of :class:`.IdentifierPreparer` once a :class:`.DefaultDialect` has been constructed.

include_set_input_sizes: Optional[Set[Any]] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

set of DBAPI type objects that should be included in automatic cursor.setinputsizes() calls. This is only used if bind_typing is BindTyping.SET_INPUT_SIZES

inline_comments: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates the dialect supports comment DDL that's inline with the definition of a Table or Column. If False, this implies that ALTER must be used to set table and column comments.

insert_executemany_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect / driver / database supports some means of providing INSERT...RETURNING support when dialect.do_executemany() is used.

insert_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if the dialect supports RETURNING with INSERT .. versionadded:: 2.0

insertmanyvalues_max_parameters: int = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Alternate to insertmanyvalues_page_size, will additionally limit page size based on number of parameters total in the statement.

insertmanyvalues_page_size: int = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Number of rows to render into an individual INSERT..VALUES() statement for :attr:`.ExecuteStyle.INSERTMANYVALUES` executions. The default dialect defaults this to 1000. .. versionadded:: 2.0 .. seealso:: :paramref:`_engine.Connection.execution_options.insertmanyvalues_page_size` - execution option available on :class:`_engine.Connection`, statements

is_async: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Whether or not this dialect is intended for asyncio use.

label_length: Optional[int] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

optional user-defined max length for SQL labels

max_identifier_length: int = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

The maximum length of identifier names.

name: str = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

identifying name for the dialect from a DBAPI-neutral point of view (i.e. 'sqlite')

paramstyle: str = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

the paramstyle to be used (some DB-APIs support multiple paramstyles).

positional: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

True if the paramstyle for this Dialect is positional.

preexecute_autoincrement_sequences: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

True if 'implicit' primary key functions must be executed separately in order to get their value, if RETURNING is not used. This is currently oriented towards PostgreSQL when the ``implicit_returning=False`` parameter is used on a :class:`.Table` object.

preparer: Type[IdentifierPreparer] = (source) ¶

overridden in sqlalchemy.dialects.mysql.base.MySQLDialect

a :class:`.IdentifierPreparer` class used to quote identifiers.

reflection_options: Sequence[str] = (source) ¶

overridden in sqlalchemy.dialects.oracle.base.OracleDialect, sqlalchemy.dialects.postgresql.base.PGDialect

Sequence of string names indicating keyword arguments that can be established on a :class:`.Table` object which will be passed as "reflection options" when using :paramref:`.Table.autoload_with`. Current example is "oracle_resolve_synonyms" in the Oracle dialect.

sequences_optional: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

If True, indicates if the :paramref:`_schema.Sequence.optional` parameter on the :class:`_schema.Sequence` construct should signal to not generate a CREATE SEQUENCE. Applies only to dialects that support sequences. Currently used only to allow PostgreSQL SERIAL to be used on a column that specifies Sequence() for usage on other backends.

server_side_cursors: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

deprecated; indicates if the dialect should attempt to use server side cursors by default

server_version_info: Optional[Tuple[Any, ...]] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

a tuple containing a version number for the DB backend in use. This value is only available for supporting dialects, and is typically populated during the initial connection to the database.

statement_compiler: Type[SQLCompiler] = (source) ¶

a :class:`.Compiled` class used to compile SQL statements

supports_alter: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

``True`` if the database supports ``ALTER TABLE`` - used only for generating foreign key constraints in certain circumstances

supports_comments: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates the dialect supports comment DDL on tables and columns.

supports_constraint_comments: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates if the dialect supports comment DDL on constraints. .. versionadded: 2.0

supports_default_metavalue: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect supports INSERT...(col) VALUES (DEFAULT) syntax. Most databases support this in some way, e.g. SQLite supports it using ``VALUES (NULL)``. MS SQL Server supports the syntax also however is the only included dialect where we have this disabled, as MSSQL does not support the field for the IDENTITY column, which is usually where we like to make use of the feature.

supports_default_values: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect supports INSERT... DEFAULT VALUES syntax

supports_empty_insert: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect supports INSERT () VALUES (), i.e. a plain INSERT with no columns in it. This is not usually supported; an "empty" insert is typically suited using either "INSERT..DEFAULT VALUES" or "INSERT ... (col) VALUES (DEFAULT)".

supports_identity_columns: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

target database supports IDENTITY

supports_multivalues_insert: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Target database supports INSERT...VALUES with multiple value sets, i.e. INSERT INTO table (cols) VALUES (...), (...), (...), ...

supports_native_boolean: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates if the dialect supports a native boolean construct. This will prevent :class:`_types.Boolean` from generating a CHECK constraint when that type is used.

supports_native_decimal: bool = (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.engine.default.DefaultDialect

indicates if Decimal objects are handled and returned for precision numeric types, or if floats are returned

supports_native_enum: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates if the dialect supports a native ENUM construct. This will prevent :class:`_types.Enum` from generating a CHECK constraint when that type is used in "native" mode.

supports_native_uuid: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

indicates if Python UUID() objects are handled natively by the driver for SQL UUID datatypes. .. versionadded:: 2.0

supports_sane_multi_rowcount: bool = (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.engine.default.DefaultDialect

Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements when executed via executemany.

supports_sane_rowcount: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements.

supports_sequences: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Indicates if the dialect supports CREATE SEQUENCE or similar.

supports_server_side_cursors: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

indicates if the dialect supports server side cursors

supports_simple_order_by_label: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

target database supports ORDER BY <labelname>, where <labelname> refers to a label in the columns clause of the SELECT

supports_statement_cache: bool = (source) ¶

overridden in sqlalchemy.dialects.mssql.pyodbc.MSDialect_pyodbc, sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc, sqlalchemy.engine.default.DefaultDialect

indicates if this dialect supports caching. All dialects that are compatible with statement caching should set this flag to True directly on each dialect class and subclass that supports it. SQLAlchemy tests that this flag is locally present on each dialect subclass before it will use statement caching. This is to provide safety for legacy or new dialects that are not yet fully tested to be compliant with SQL statement caching. .. versionadded:: 1.4.5 .. seealso:: :ref:`engine_thirdparty_caching`

tuple_in_values: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

target database supports tuple IN, i.e. (x, y) IN ((q, p), (r, z))

type_compiler: Any = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

legacy; this is a TypeCompiler class at the class level, a TypeCompiler instance at the instance level. Refer to type_compiler_instance instead.

type_compiler_cls: ClassVar[Type[TypeCompiler]] = (source) ¶

a :class:`.Compiled` class used to compile SQL type objects .. versionadded:: 2.0

type_compiler_instance: TypeCompiler = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

instance of a :class:`.Compiled` class used to compile SQL type objects .. versionadded:: 2.0

update_executemany_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

dialect supports UPDATE..RETURNING with executemany.

update_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if the dialect supports RETURNING with UPDATE .. versionadded:: 2.0

update_returning_multifrom: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if the dialect supports RETURNING with UPDATE..FROM .. versionadded:: 2.0

use_insertmanyvalues: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if True, indicates "insertmanyvalues" functionality should be used to allow for ``insert_executemany_returning`` behavior, if possible. In practice, setting this to True means: if ``supports_multivalues_insert``, ``insert_returning`` and ``use_insertmanyvalues`` are all True, the SQL compiler will produce an INSERT that will be interpreted by the :class:`.DefaultDialect` as an :attr:`.ExecuteStyle.INSERTMANYVALUES` execution that allows for INSERT of many rows with RETURNING by rewriting a single-row INSERT statement to have multiple VALUES clauses, also executing the statement multiple times for a series of batches when large numbers of rows are given. The parameter is False for the default dialect, and is set to True for SQLAlchemy internal dialects SQLite, MySQL/MariaDB, PostgreSQL, SQL Server. It remains at False for Oracle, which provides native "executemany with RETURNING" support and also does not support ``supports_multivalues_insert``. For MySQL/MariaDB, those MySQL dialects that don't support RETURNING will not report ``insert_executemany_returning`` as True. .. versionadded:: 2.0 .. seealso:: :ref:`engine_insertmanyvalues`

use_insertmanyvalues_wo_returning: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

if True, and use_insertmanyvalues is also True, INSERT statements that don't include RETURNING will also use "insertmanyvalues". .. versionadded:: 2.0

@util.non_memoized_property
loaded_dbapi: ModuleType = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

same as .dbapi, but is never None; will raise an error if no DBAPI was set up. .. versionadded:: 2.0

def _assert_and_set_isolation_level(self, dbapi_conn: DBAPIConnection, level: IsolationLevel): (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

def _builtin_onconnect(self) -> Optional[_ListenerFnType]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

def _deliver_insertmanyvalues_batches(self, cursor: DBAPICursor, statement: str, parameters: _DBAPIMultiExecuteParams, generic_setinputsizes: Optional[_GenericSetInputSizesType], context: ExecutionContext) -> Iterator[Tuple[str, _DBAPISingleExecuteParams, _GenericSetInputSizesType, int, int]]: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

convert executemany parameters for an INSERT into an iterator of statement/single execute values, used by the insertmanyvalues feature.

def _do_ping_w_event(self, dbapi_connection: DBAPIConnection) -> bool: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

def _get_default_schema_name(self, connection: Connection) -> str: (source) ¶

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.

def _get_server_version_info(self, connection: Connection) -> Any: (source) ¶

overridden in sqlalchemy.connectors.pyodbc.PyODBCConnector, sqlalchemy.dialects.mssql.pymssql.MSDialect_pymssql, sqlalchemy.dialects.mssql.pyodbc.MSDialect_pyodbc, sqlalchemy.dialects.mysql.base.MySQLDialect, sqlalchemy.dialects.oracle.cx_oracle.OracleDialect_cx_oracle, sqlalchemy.dialects.postgresql.base.PGDialect, sqlalchemy.dialects.sqlite.pysqlite.SQLiteDialect_pysqlite

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.

def _overrides_default(self, method_name: str) -> bool: (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

_bind_typing_render_casts: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

_has_events: bool = (source) ¶

Undocumented

_on_connect_isolation_level: Optional[IsolationLevel] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented

_supports_statement_cache: bool = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

internal evaluation for supports_statement_cache

_type_memos: MutableMapping[TypeEngine[Any], _TypeMemoDict] = (source) ¶

overridden in sqlalchemy.engine.default.DefaultDialect

Undocumented