sqlalchemy.databases.mssql.MSDialect

Undocumented

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.

Undocumented

Undocumented

Undocumented

Undocumented

Return information about columns in table_name.

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

name

the column's name

type

[sqlalchemy.types#TypeEngine]

nullable

boolean

default

the column's default value

autoincrement

boolean

sequence

a dictionary of the form

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

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

Additional column attributes may be present.

Return information about foreign_keys in table_name.

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

name

the constraint's name

constrained_columns

a list of column names that make up the foreign key

referred_schema

the name of the referred schema

referred_table

the name of the referred table

referred_columns

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

Return information about indexes in table_name.

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

name

the index's name

column_names

list of column names in order

unique

boolean

Given a DBAPI connection, return its isolation level.

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

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

Return information about the primary key constraint on table_name`.

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

constrained_columns

a list of column names that make up the primary key

name

optional name of the primary key constraint.

Undocumented

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

Return view definition.

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

Check the existence of a particular sequence in the database.

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

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

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

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

Called during strategized creation of the dialect with a connection.

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

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

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

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

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

E.g.:

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

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

        return do_on_connect

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

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

If None is returned, no event listener is generated.

Given a DBAPI connection, set its isolation level.

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