class MySQLDialect(default.DefaultDialect): (source)
Known subclasses: sqlalchemy.dialects.mysql.mariadb.MariaDBDialect
, sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
, sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc
Details of the MySQL dialect. Not used directly in application code.
Method | __init__ |
Undocumented |
Method | do |
Begin a two phase transaction on the given connection. |
Method | do |
Commit a two phase transaction on the given connection. |
Method | do |
Prepare a two phase transaction on the given connection. |
Method | do |
Recover list of uncommitted prepared two phase transaction identifiers on the given connection. |
Method | do |
Rollback a two phase transaction on the given connection. |
Method | get |
Return information about check constraints in ``table_name``. |
Method | get |
Return information about columns in ``table_name``. |
Method | get |
Return information about foreign_keys in ``table_name``. |
Method | get |
Return information about indexes in ``table_name``. |
Method | get |
Given a DBAPI connection, return its isolation level. |
Method | get |
return a sequence of string isolation level names that are accepted by this dialect. |
Method | get |
Return information about the primary key constraint on table_name`. |
Method | get |
Return a list of all schema names available in the database. |
Method | get |
Return a list of all sequence names available in the database. |
Method | get |
Return the "comment" for the table identified by ``table_name``. |
Method | get |
Return a Unicode SHOW TABLES from a given schema. |
Method | get |
Return a dictionary of options specified when ``table_name`` was created. |
Method | get |
Return information about unique constraints in ``table_name``. |
Method | get |
Return plain or materialized view definition. |
Method | get |
Return a list of all non-materialized view names available in the database. |
Method | has |
Check the existence of a particular sequence in the database. |
Method | has |
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 |
Return True if the given DB-API error indicates an invalid connection |
Method | set |
Given a DBAPI connection, set its isolation level. |
Class Variable | construct |
Optional set of argument specifiers for various SQLAlchemy constructs, typically schema items. |
Class Variable | cte |
target database, when given a CTE with an INSERT statement, needs the CTE to be below the INSERT |
Class Variable | default |
Undocumented |
Class Variable | div |
target database treats the / division operator as "floor division" |
Class Variable | inline |
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 |
Undocumented |
Class Variable | max |
Undocumented |
Class Variable | max |
The maximum length of identifier names. |
Class Variable | max |
Undocumented |
Class Variable | name |
identifying name for the dialect from a DBAPI-neutral point of view (i.e. 'sqlite') |
Class Variable | sequences |
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 | supports |
``True`` if the database supports ``ALTER TABLE`` - used only for generating foreign key constraints in certain circumstances |
Class Variable | supports |
Indicates the dialect supports comment DDL on tables and columns. |
Class Variable | supports |
dialect supports INSERT... VALUES (DEFAULT) syntax |
Class Variable | supports |
dialect supports INSERT... DEFAULT VALUES syntax |
Class Variable | supports |
Target database supports INSERT...VALUES with multiple value sets, i.e. INSERT INTO table (cols) VALUES (...), (...), (...), ... |
Class Variable | supports |
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 |
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 |
Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements when executed via executemany. |
Class Variable | supports |
Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements. |
Class Variable | supports |
indicates if this dialect supports caching. |
Class Variable | use |
if True, indicates "insertmanyvalues" functionality should be used to allow for ``insert_executemany_returning`` behavior, if possible. |
Instance Variable | delete |
if the dialect supports RETURNING with DELETE |
Instance Variable | identifier |
This element will refer to an instance of :class:`.IdentifierPreparer` once a :class:`.DefaultDialect` has been constructed. |
Instance Variable | insert |
if the dialect supports RETURNING with INSERT |
Instance Variable | is |
Undocumented |
Instance Variable | preparer |
a :class:`.IdentifierPreparer` class used to quote identifiers. |
Instance Variable | server |
a tuple containing a version number for the DB backend in use. |
Instance Variable | supports |
Undocumented |
Instance Variable | supports |
Indicates if the dialect supports CREATE SEQUENCE or similar. |
Class Method | _is |
Undocumented |
Method | _compat |
Proxy result rows to smooth over MySQL-Python driver inconsistencies. |
Method | _compat |
Proxy a result row to smooth over MySQL-Python driver inconsistencies. |
Method | _compat |
Proxy a result row to smooth over MySQL-Python driver inconsistencies. |
Method | _correct |
Undocumented |
Method | _describe |
Run DESCRIBE for a ``Table`` and return processed rows. |
Method | _detect |
Detect and adjust for the ANSI_QUOTES sql mode. |
Method | _detect |
Sniff out identifier case sensitivity. |
Method | _detect |
Undocumented |
Method | _detect |
Pull the active COLLATIONS list from the server. |
Method | _detect |
Undocumented |
Method | _extract |
Undocumented |
Method | _fetch |
Undocumented |
Method | _get |
Return the string name of the currently selected schema from the given connection. |
Method | _get |
Retrieve the server version info from the given connection. |
Method | _parse |
Undocumented |
Method | _parsed |
Undocumented |
Method | _sequences |
Undocumented |
Method | _set |
Undocumented |
Method | _setup |
Undocumented |
Method | _show |
Run SHOW CREATE TABLE for a ``Table``. |
Method | _warn |
Undocumented |
Instance Variable | _backslash |
Undocumented |
Instance Variable | _casing |
Undocumented |
Instance Variable | _connection |
Undocumented |
Instance Variable | _json |
Undocumented |
Instance Variable | _json |
Undocumented |
Instance Variable | _mariadb |
Undocumented |
Instance Variable | _needs |
Undocumented |
Instance Variable | _requires |
Undocumented |
Instance Variable | _server |
Undocumented |
Instance Variable | _sql |
Undocumented |
Property | _is |
Undocumented |
Property | _is |
Undocumented |
Property | _is |
Undocumented |
Property | _support |
Undocumented |
Property | _tabledef |
return the MySQLTableDefinitionParser, generate if needed. |
Inherited from DefaultDialect
:
Class Method | get |
Undocumented |
Class Method | load |
set up the provision.py module for this dialect. |
Method | connect |
Establish a connection using this dialect's DBAPI. |
Method | create |
Build DB-API compatible connection arguments. |
Method | create |
Create a random two-phase transaction ID. |
Method | denormalize |
convert the given name to a case insensitive identifier for the backend if it is an all-lowercase name. |
Method | do |
Provide an implementation of ``connection.begin()``, given a DB-API connection. |
Method | do |
Provide an implementation of ``connection.close()``, given a DBAPI connection. |
Method | do |
Provide an implementation of ``connection.commit()``, given a DB-API connection. |
Method | do |
Provide an implementation of ``cursor.execute(statement, parameters)``. |
Method | do |
Provide an implementation of ``cursor.execute(statement)``. |
Method | do |
Provide an implementation of ``cursor.executemany(statement, parameters)``. |
Method | do |
ping the DBAPI connection and return True if the connection is usable. |
Method | do |
Release the named savepoint on a connection. |
Method | do |
Provide an implementation of ``connection.rollback()``, given a DB-API connection. |
Method | do |
Rollback a connection to the named savepoint. |
Method | do |
Create a savepoint with the given name. |
Method | do |
Provide an implementation of ``connection.close()`` that tries as much as possible to not block, given a DBAPI connection. |
Method | get |
Given a DBAPI connection, return its isolation level, or a default isolation level if one cannot be retrieved. |
Method | get |
return a Pool class to use for a given URL |
Method | get |
Returns the connection object as returned by the external driver package. |
Method | get |
Return information about check constraints in all tables in the given ``schema``. |
Method | get |
Return information about columns in all tables in the given ``schema``. |
Method | get |
Return information about foreign_keys in all tables in the given ``schema``. |
Method | get |
Return information about indexes in in all tables in the given ``schema``. |
Method | get |
Return information about primary key constraints in all tables in the given ``schema``. |
Method | get |
Return information about the table comment in all tables in the given ``schema``. |
Method | get |
Return a dictionary of options specified when the tables in the given schema were created. |
Method | get |
Return information about unique constraints in all tables in the given ``schema``. |
Method | has |
Check the existence of a particular index name in the database. |
Method | has |
Check the existence of a particular schema name in the database. |
Method | normalize |
convert the given name to lowercase if it is detected as case insensitive. |
Method | on |
return a callable which sets up a newly created DBAPI connection. |
Method | reset |
Given a DBAPI connection, revert its isolation to the default. |
Method | set |
Establish execution options for a given connection. |
Method | set |
Establish execution options for a given engine. |
Method | type |
Provide a database-specific :class:`.TypeEngine` object, given the generic object which comes from the types module. |
Method | validate |
Undocumented |
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 | connection |
Undocumented |
Class Variable | default |
for INSERT... VALUES (DEFAULT) syntax, the token to put in the parenthesis. |
Class Variable | default |
the default value that will be rendered as the "START WITH" portion of a CREATE SEQUENCE DDL statement. |
Class Variable | delete |
dialect supports DELETE..RETURNING with executemany. |
Class Variable | delete |
if the dialect supports RETURNING with DELETE..FROM |
Class Variable | engine |
a mapping of string keys that can be in an engine config linked to type conversion functions. |
Class Variable | exclude |
set of DBAPI type objects that should be excluded in automatic cursor.setinputsizes() calls. |
Class Variable | favor |
for backends that support both a lastrowid and a RETURNING insert strategy, favor RETURNING for simple single-int pk inserts. |
Class Variable | has |
Whether or not this dialect has a separate "terminate" implementation that does not block or require awaiting. |
Class Variable | include |
set of DBAPI type objects that should be included in automatic cursor.setinputsizes() calls. |
Class Variable | insertmanyvalues |
Alternate to insertmanyvalues_page_size, will additionally limit page size based on number of parameters total in the statement. |
Class Variable | is |
Whether or not this dialect is intended for asyncio use. |
Class Variable | isolation |
Undocumented |
Class Variable | non |
Undocumented |
Class Variable | postfetch |
Undocumented |
Class Variable | preexecute |
True if 'implicit' primary key functions must be executed separately in order to get their value, if RETURNING is not used. |
Class Variable | requires |
Undocumented |
Class Variable | server |
deprecated; indicates if the dialect should attempt to use server side cursors by default |
Class Variable | supports |
Indicates if the dialect supports comment DDL on constraints. |
Class Variable | supports |
dialect supports INSERT () VALUES () |
Class Variable | supports |
target database supports IDENTITY |
Class Variable | supports |
Undocumented |
Class Variable | supports |
indicates if Decimal objects are handled and returned for precision numeric types, or if floats are returned |
Class Variable | supports |
indicates if Python UUID() objects are handled natively by the driver for SQL UUID datatypes. |
Class Variable | supports |
Undocumented |
Class Variable | supports |
indicates if the dialect supports server side cursors |
Class Variable | supports |
target database supports ORDER BY <labelname>, where <labelname> refers to a label in the columns clause of the SELECT |
Class Variable | supports |
Undocumented |
Class Variable | tuple |
target database supports tuple IN, i.e. (x, y) IN ((q, p), (r, z)) |
Class Variable | update |
dialect supports UPDATE..RETURNING with executemany. |
Class Variable | update |
if the dialect supports RETURNING with UPDATE |
Class Variable | update |
if the dialect supports RETURNING with UPDATE..FROM |
Class Variable | use |
if True, and use_insertmanyvalues is also True, INSERT statements that don't include RETURNING will also use "insertmanyvalues". |
Instance Variable | bind |
Undocumented |
Instance Variable | compiler |
Undocumented |
Instance Variable | dbapi |
A reference to the DBAPI module object itself. |
Instance Variable | default |
the isolation that is implicitly present on new connections |
Instance Variable | default |
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. |
Instance Variable | insertmanyvalues |
Number of rows to render into an individual INSERT..VALUES() statement for :attr:`.ExecuteStyle.INSERTMANYVALUES` executions. |
Instance Variable | label |
optional user-defined max length for SQL labels |
Instance Variable | paramstyle |
the paramstyle to be used (some DB-APIs support multiple paramstyles). |
Instance Variable | positional |
True if the paramstyle for this Dialect is positional. |
Instance Variable | type |
legacy; this is a TypeCompiler class at the class level, a TypeCompiler instance at the instance level. |
Instance Variable | type |
instance of a :class:`.Compiled` class used to compile SQL type objects |
Property | dialect |
Undocumented |
Property | full |
Undocumented |
Property | insert |
dialect / driver / database supports some means of providing INSERT...RETURNING support when dialect.do_executemany() is used. |
Property | loaded |
same as .dbapi, but is never None; will raise an error if no DBAPI was set up. |
Property | supports |
True if this dialect supports sane rowcount even if RETURNING is in use. |
Method | _assert |
Undocumented |
Method | _builtin |
Undocumented |
Method | _check |
Perform a connection / server version specific check to determine the max_identifier_length. |
Method | _default |
Undocumented |
Method | _deliver |
convert executemany parameters for an INSERT into an iterator of statement/single execute values, used by the insertmanyvalues feature. |
Method | _do |
Undocumented |
Method | _ensure |
Undocumented |
Method | _gen |
Undocumented |
Method | _overrides |
Undocumented |
Method | _reset |
Undocumented |
Method | _set |
Undocumented |
Class Variable | _legacy |
Undocumented |
Instance Variable | _ischema |
Undocumented |
Instance Variable | _on |
Undocumented |
Instance Variable | _user |
Undocumented |
Property | _bind |
Undocumented |
Property | _dialect |
Undocumented |
Property | _supports |
internal evaluation for supports_statement_cache |
Property | _type |
Undocumented |
Inherited from Dialect
(via DefaultDialect
):
Class Method | engine |
A convenience hook called before returning the final :class:`_engine.Engine`. |
Class Method | get |
Given a URL, return the :class:`.Dialect` that will be used by an async engine. |
Class Method | get |
Given a URL, return the :class:`.Dialect` that will be used. |
Class Method | import |
Import the DBAPI module that is used by this dialect. |
Method | do |
invoke the cursor.setinputsizes() method with appropriate arguments |
Method | get |
Return a list of all materialized view names available in the database. |
Method | get |
Return a list of temporary table names on the given connection, if supported by the underlying backend. |
Method | get |
Return a list of temporary view names on the given connection, if supported by the underlying backend. |
Method | on |
return a callable which sets up a newly created DBAPI connection. |
Class Variable | ddl |
a :class:`.Compiled` class used to compile DDL statements |
Class Variable | dispatch |
Undocumented |
Class Variable | driver |
identifying name for the dialect's DBAPI |
Class Variable | execute |
either the 'tuple' or 'list' type, depending on what cursor.execute() accepts for the second argument (they vary). |
Class Variable | execution |
a :class:`.ExecutionContext` class used to handle statement execution |
Class Variable | reflection |
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 | statement |
a :class:`.Compiled` class used to compile SQL statements |
Class Variable | type |
a :class:`.Compiled` class used to compile SQL type objects |
Class Variable | _has |
Undocumented |
Begin a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid
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.
Prepare a two phase transaction on the given connection. :param connection: a :class:`_engine.Connection`. :param xid: xid
Recover list of uncommitted prepared two phase transaction identifiers on the given connection. :param connection: a :class:`_engine.Connection`.
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 get_check_constraints(self, connection, table_name, schema=None, **kw): (source) ¶
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
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`.
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`.
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`.
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
sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
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_pk_constraint(self, connection, table_name, schema=None, **kw): (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`.
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`.
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, table_name, schema=None, **kw): (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_options(self, connection, table_name, schema=None, **kw): (source) ¶
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_unique_constraints(self, connection, table_name, schema=None, **kw): (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, view_name, schema=None, **kw): (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.
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.
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`.
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.
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.
sqlalchemy.dialects.mysql.cymysql.MySQLDialect_cymysql
, sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector
, sqlalchemy.dialects.mysql.pymysql.MySQLDialect_pymysql
Return True if the given DB-API error indicates an invalid connection
sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
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
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`
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.
sqlalchemy.dialects.mysql.mariadb.MariaDBDialect
identifying name for the dialect from a DBAPI-neutral point of view (i.e. 'sqlite')
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.
``True`` if the database supports ``ALTER TABLE`` - used only for generating foreign key constraints in certain circumstances
Target database supports INSERT...VALUES with multiple value sets, i.e. INSERT INTO table (cols) VALUES (...), (...), (...), ...
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.
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.
sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements when executed via executemany.
sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
Indicate whether the dialect properly implements rowcount for ``UPDATE`` and ``DELETE`` statements.
sqlalchemy.dialects.mysql.mariadb.MariaDBDialect
, sqlalchemy.dialects.mysql.mariadbconnector.MySQLDialect_mariadbconnector
, sqlalchemy.dialects.mysql.mysqlconnector.MySQLDialect_mysqlconnector
, sqlalchemy.dialects.mysql.mysqldb.MySQLDialect_mysqldb
, sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc
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`
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`
This element will refer to an instance of :class:`.IdentifierPreparer` once a :class:`.DefaultDialect` has been constructed.
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.
Sniff out identifier case sensitivity. Cached per-connection. This value can not change without a server restart.
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.
sqlalchemy.dialects.mysql.pyodbc.MySQLDialect_pyodbc
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.