sqlalchemy.testing.requirements.SuiteRequirements

Test environment must allow ad-hoc engine/connection creation. DBs that scale poorly for many connections, even when closed, i.e. Oracle, may use the "--low-connections" option which flags this requirement as not present.

dialect includes the required pep-249 attribute ``cursor.arraysize``

dialect makes use of await_() to invoke operations on the DBAPI.

Undocumented

target dialect supports 'AUTOCOMMIT' as an isolation_level

target platform generates new surrogate integer primary key values when insert() is executed, excluding the pk column.

If autoincrement=True on a column does not require an explicit sequence. This should be false only for oracle.

target database/driver can allow BLOB/BINARY fields to be compared against a bound parameter value.

target backend supports simple binary literals, e.g. an expression like:: SELECT CAST('foo' AS BINARY) Where ``BINARY`` is the type emitted from :class:`.LargeBinary`, e.g. it could be ``BLOB`` or similar. Basically fails on Oracle.

Target database must support boolean expressions as columns

target database can render LIMIT and/or OFFSET using a bound parameter

same as precision_numerics_many_significant_digits but within the context of a CAST statement (hello MySQL)

Undocumented

target dialect supports reflection of check constraints

Indicates if the database support table comment reflection

Supports computed columns

If the default persistence is virtual or stored when `persisted` is omitted

If persistence information is returned by the reflection of computed columns

Supports computed columns with `persisted=True`

Supports computed columns with `persisted=False`

indicates if the database support constraint on constraints and their reflection

Undocumented

target platform can emit basic CreateTable DDL.

target system must support reflection of inter-schema foreign keys

Target database supports CTEs

target database supports CTES which consist of INSERT, UPDATE or DELETE *within* the CTE, e.g. WITH x AS (UPDATE....)

target database supports CTES that ride on top of a normal UPDATE or DELETE statement which refers to the CTE in a correlated subquery.

target dialect supports representation of Python datetime.date() objects.

target dialect accepts a datetime object as the target of a date column.

target dialect supports representation of Python datetime.datetime() objects with historic (pre 1970) values.

target dialect when given a date object will bind it such that the database server knows the object is a date, and not a plain string.

target dialect supports representation of Python datetime.datetime() objects.

target dialect supports representation of Python datetime.datetime() objects with historic (pre 1970) values.

target dialect when given a datetime object will bind it such that the database server knows the object is a datetime, and not a plain string.

target dialect supports rendering of a date, time, or datetime as a literal string, e.g. via the TypeEngine.literal_processor() method.

target dialect supports representation of Python datetime.datetime() with microsecond objects.

target dialect supports representation of Python datetime.datetime() with tzinfo with DateTime(timezone=True).

target platform includes a 'lastrowid' accessor on the DBAPI cursor object.

target dialect implements provisioning module including set_default_schema_on_connection

Undocumented

Target must support DELETE FROM..FROM or DELETE..USING syntax

target platform supports DELETE ... RETURNING.

Target database must have 'denormalized', i.e. UPPERCASE as case insensitive names.

test that the dialect allows the 'isolation_level' argument to be handled by DefaultDialect

target platform can emit basic DropTable DDL.

target dialect raises IntegrityError when reporting an INSERT with a primary key violation. (hint: it should)

target platform supports a SELECT statement that has the same name repeated more than once in the columns list.

target platform supports INSERT with no values, i.e. INSERT DEFAULT VALUES or equivalent.

target platform supports INSERT with no values, i.e. INSERT DEFAULT VALUES or equivalent, within executemany()

target database can persist/return an empty string with an unbounded text.

target database can persist/return an empty string with a varchar.

target dialect retrieves cursor.lastrowid, or fetches from a database-side function after an insert() construct executes, within the get_lastrowid() method. Only dialects that "pre-execute", or need RETURNING to get last inserted id, would return closed/fail/skip for this.

target dialect retrieves cursor.lastrowid or an equivalent after an insert() construct executes, even if the table has a Sequence on it.

Target database must support EXCEPT or equivalent (i.e. MINUS).

target database supports use of an unbounded textual field in a WHERE clause.

backend supports fetch / offset with expression in them, like SELECT * FROM some_table OFFSET 1 + 1 ROWS FETCH FIRST 1 + 1 ROWS ONLY

backend supports the fetch first clause.

backend supports the fetch first without order by

target backend doesn't crash when you try to select a NUMERIC value that has a value of NULL. Added to support Pyodbc bug #351.

backend supports the offset when using fetch first with percent or ties. basically this is "not mssql"

backend supports the fetch first clause with percent.

target platform will allow cursor.fetchone() to proceed after a COMMIT. Typically this refers to an INSERT statement with RETURNING which is invoked within "autocommit". If the row can be returned after the autocommit, then this rule can be open.

backend supports the fetch first clause with ties.

Undocumented

Undocumented

Undocumented

target backend can return a floating-point number with four significant digits (such as 15.7563) accurately (i.e. without FP inaccuracies, such as 15.75629997253418).

Target supports refleciton of FOREIGN KEY constraints and will return the name of the constraint that was used in the "CONSTRAINT <name> FOREIGN KEY" DDL. MySQL prior to version 8 and MariaDB prior to version 10.5 don't support this.

Undocumented

Undocumented

Undocumented

Target database must support the DDL phrases for FOREIGN KEY.

Target database must support foreign keys.

Target database creates an index that's reflected for foreign keys.

If X[Y] can be implemented with ``__class_getitem__``. py3.7+

target dialect supports the :meth:`_engine.Dialect.get_isolation_level_values` method added in SQLAlchemy 2.0.

Target driver must raise a DBAPI-level exception, such as InterfaceError, when the underlying connection has been closed and the execute() method is called.

Undocumented

target platform supports SQL expressions in GROUP BY e.g. SELECT x + y AS somelabel FROM table GROUP BY x + y

target dialect supports checking a single temp table name

If a backend supports GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY

If a backend supports GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY with a standard syntax. This is mainly to exclude MSSql.

target dialect implements the executioncontext.get_lastrowid() method without reliance on RETURNING.

target backend will return a selected Decimal as a Decimal, not a string. e.g.:: expr = decimal.Decimal("15.7563") value = e.scalar( select(literal(expr)) ) assert value == expr See :ticket:`4036`

target system has a strong concept of 'default' schema that can be referred to implicitly. basically, PostgreSQL.

target database must apply names to unnamed constraints.

Target must support simultaneous, independent database connections.

target platform supports IF NOT EXISTS / IF EXISTS for indexes.

Undocumented

Undocumented

target database supports CREATE INDEX with per-column ASC/DESC.

target database supports CREATE INDEX against SQL expressions.

The Float type can persist and load float('inf'), float('-inf').

target platform supports RETURNING when INSERT is used with executemany(), e.g. multiple parameter sets, indicating as many rows come back as do parameter sets were passed.

target platform supports INSERT from a SELECT.

target platform supports INSERT ... RETURNING.

Undocumented

Target database must support INTERSECT or equivalent.

Undocumented

target dialect supports general isolation level settings. Note that this requirement, when enabled, also requires that the get_isolation_levels() method be implemented.

target platform supports numeric array indexes within a JSON structure

indicates if the json_deserializer function is called with bytes

Undocumented

target platform implements a native JSON type.

Backend has a JSON_EXTRACT or similar function that returns a valid JSON string in all cases. Used to test a legacy feature and is not needed.

target backend will return the exact float value 15.7563 with only four significant digits from this statement: SELECT :param where :param is the Python float 15.7563 i.e. it does not return 15.75629997253418

Target database must support MATERIALIZED VIEWs.

Target database reflect MATERIALIZED VIEWs pks.

Undocumented

target database must use a plain percent '%' as the 'modulus' operator.

target database must support multiple VALUES clauses in an INSERT statement.

target database must support names for constraints.

target database can select an aggregate from a subquery that's also using an aggregate

Test should be skipped if coverage is enabled. This is to block tests that exercise libraries that seem to be sensitive to coverage, such as PostgreSQL notice logging.

the opposite of supports_lastrowid

the opposite of "sequences", DB does not support sequences at all.

Undocumented

Undocumented

target database must *not* support ON UPDATE..CASCADE behavior in foreign keys.

Target database allows boolean columns to store NULL.

Target backends that support nulls ordering.

target backend will return result columns that are explicitly against NUMERIC or similar precision-numeric datatypes (not including FLOAT or INT types) as Python Decimal objects, and not as floats or ints, including when no SQLAlchemy-side typing information is associated with the statement (e.g. such as a raw SQL string). This should be enabled if either the DBAPI itself returns Decimal objects, or if the dialect has set up DBAPI-specific return type handlers such that Decimal objects come back automatically.

target database can render OFFSET, or an equivalent, in a SELECT.

target database must support ON UPDATE..CASCADE behavior in foreign keys.

Undocumented

target database supports ordering by a column from a SELECT inside of a UNION E.g. (SELECT id, ...) UNION (SELECT id, ...) ORDER BY id

Undocumented

target backend supports ORDER BY a column label within an expression. Basically this:: select data as foo from test order by foo || 'bar' Lots of databases including PostgreSQL don't support this, so this is off by default.

Target database must support parenthesized SELECT in UNION when LIMIT/OFFSET is specifically present. E.g. (SELECT ...) UNION (SELECT ..) This is known to fail on SQLite.

Target database must support parenthesized SELECT in UNION when OFFSET/LIMIT is specifically not present. E.g. (SELECT ... LIMIT ..) UNION (SELECT .. OFFSET ..) This is known to fail on SQLite. It also fails on Oracle because without LIMIT/OFFSET, there is currently no step that creates an additional subquery.

Undocumented

target backend supports weird identifiers with percent signs in them, e.g. 'some % column'. this is a very weird use case but often has problems because of DBAPIs that use python formatting. It's not a critical use case either.

target backend will return native floating point numbers with at least seven decimal places when using the generic Float type.

target backend supports Decimal() objects using E notation to represent very large values.

target backend supports Decimal() objects using E notation to represent very small values.

target backend has general support for moderately high-precision numerics.

target backend supports values with many digits on both sides, such as 319438950232418390.273596, 87673.594069654243

A precision numeric type will return empty significant digits, i.e. a value such as 10.000 will come back in Decimal form with the .000 maintained.

target platform must remove all cycles unconditionally when gc.collect() is called, as well as clean out unreferenced subclasses.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

target database is using QueuePool

target database must support ON DELETE CASCADE on a self-referential foreign key

target database supports reflecting INDEX with per-column ASC/DESC.

target database supports reflection of indexes with SQL expressions.

Target database must support reflecting table_options.

target database supports creation and reflection of tables with no columns, or at least tables that seem to have no columns.

Undocumented

backend supports the regexp_match operator.

backend supports the regexp_replace operator.

Undocumented

Undocumented

Undocumented

Target database must support savepoints.

target database supports schema create and dropped with 'CREATE SCHEMA' and 'DROP SCHEMA'

Undocumented

Target database must support external schemas, and have one named 'test_schema'.

target driver must support the literal statement 'select 1'

Target database must support self-referential foreign keys.

Target database must support SEQUENCEs.

Target database supports sequences, but also optionally as a means of generating new PK values.

Target dialect must support server side cursors.

Catchall for a large variety of MySQL on Windows failures

target database can render LIMIT and/or OFFSET with a complete SQL expression, such as one that uses the addition operator. parameter

Undocumented

Undocumented

target database/driver supports bound parameters as column expressions without being in the context of a typed column.

target database/driver supports bound parameters with NULL in the WHERE clause, in situations where it has to be typed.

Target database passes SQL-92 style statements to cursor.execute() when a statement like select() or insert() is run. A very small portion of dialect-level tests will ensure that certain conditions are present in SQL strings, and these tests use very basic SQL that will work on any SQL-like platform in order to assert results. It's normally a given for any pep-249 DBAPI that a statement like "SELECT id, name FROM table WHERE some_table.id=5" will work. However, there are dialects that don't actually produce SQL Strings and instead may work with symbolic objects instead, or dialects that aren't working with SQL, so for those this requirement can be marked as excluded.

Target database must support subqueries.

If a backend supports the DISTINCT ON in a select

Supports some form of "x IS [NOT] DISTINCT FROM y" construct. Different dialects will implement their own flavour, e.g., sqlite will emit "x IS NOT y" instead of "x IS DISTINCT FROM y". .. seealso:: :meth:`.ColumnOperators.is_distinct_from`

target database / driver supports cursor.lastrowid as a means of retrieving the last inserted primary key value. note that if the target DB supports sequences also, this is still assumed to work. This is a new use case brought on by MariaDB 10.3.

Target driver can create tables with a name like 'some " table'

target platform supports IF NOT EXISTS / IF EXISTS for tables.

target database has general support for table reflection

Database / dialect supports a query like:: SELECT * FROM VALUES ( (c1, c2), (c1, c2), ...) AS some_table(col1, col2) SQLAlchemy generates this with the :func:`_sql.values` function.

target dialect supports listing of temporary table names

Undocumented

Undocumented

target database supports temporary tables

target database supports temporary views

Target database must support an unbounded Text() " "type such as TEXT or CLOB

Mark tests that use threading and mock at the same time - stability issues have been observed with coverage

target dialect supports representation of Python datetime.time() objects.

target dialect when given a time object will bind it such that the database server knows the object is a time, and not a plain string.

target dialect supports representation of Python datetime.time() with microsecond objects.

target dialect supports representation of Python datetime.time() with tzinfo with Time(timezone=True).

target dialect supports representation of Python datetime.datetime() with microsecond objects but only if TIMESTAMP is used.

target dialect when given a datetime object which also includes a microseconds portion when using the TIMESTAMP data type will bind it such that the database server knows the object is a datetime with microseconds, and not a plain string.

Undocumented

Target platform supports the syntax "(x, y) IN ((x1, y1), (x2, y2), ...)"

Target platform tuple IN w/ empty set

Target database must support two-phase transactions.

Target database must support VARCHAR with no length

Target driver must support non-ASCII characters being passed at all.

Target database/dialect must support Python unicode objects with non-ASCII characters represented, delivered as bound parameters as well as in result rows.

Target database/dialect can receive / deliver / compare data with non-ASCII characters in plain VARCHAR, TEXT columns, without the need for special "national" datatypes like NVARCHAR or similar.

Target driver must support some degree of non-ascii symbol names.

target dialect supports reflection of unique constraints

Target database reflects unique constraints as indexes.

Target database reflects unique indexes as unique constrains.

target database allows column names that have unusual characters in them, such as dots, spaces, slashes, or percent signs. The column names are as always in such a case quoted, however the DB still needs to support those characters in the name somehow.

Target must support UPDATE..FROM syntax

target platform supports UPDATE ... RETURNING.

Target must support UPDATE (or DELETE) where the same table is present in a subquery in the WHERE clause. This is an ANSI-standard syntax that apparently MySQL can't handle, such as:: UPDATE documents SET flag=1 WHERE documents.title IN (SELECT max(documents.title) AS title FROM documents GROUP BY documents.user_id )

target database must support retrieval of the columns in a view, similarly to how a table is inspected. This does not include the full CREATE VIEW definition.

target database must support inspection of the full CREATE VIEW definition.

Target database must support VIEWs.

Target database must support window functions.