sqlalchemy.databases.sqlite.SQLiteDialect

Undocumented

Undocumented

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

Return a data type from a reflected column, using affinity rules.

SQLite's goal for universal compatibility introduces some complexity during reflection, as a column's defined type might not actually be a type that SQLite understands - or indeed, my not be defined at all. Internally, SQLite handles this with a 'data type affinity' for each column definition, mapping to one of 'TEXT', 'NUMERIC', 'INTEGER', 'REAL', or 'NONE' (raw bits). The algorithm that determines this is listed in https://www.sqlite.org/datatype3.html section 2.1.

This method allows SQLAlchemy to support that algorithm, while still providing access to smarter reflection utilities by recognizing column definitions that SQLite only supports through affinity (like DATE and DOUBLE).

Return information about check constraints in table_name.

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

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

Return information about columns in table_name.

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

name

the column's name

type

[sqlalchemy.types#TypeEngine]

nullable

boolean

default

the column's default value

autoincrement

boolean

sequence

a dictionary of the form

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

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

Additional column attributes may be present.

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 information about unique constraints in table_name.

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

name

the unique constraint's name

column_names

list of column names in order

**kw

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

Return view definition.

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

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.

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.