def drop_all_schema_objects_pre_tables(cfg, eng):
with eng.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
inspector = inspect(conn)
+
+ conn.exec_driver_sql(
+ "IF EXISTS (SELECT 1 FROM sys.fulltext_catalogs "
+ "WHERE name = 'Catalog') "
+ "DROP FULLTEXT CATALOG Catalog"
+ )
for schema in (None, "dbo", cfg.test_schema, cfg.test_schema_2):
for tname in inspector.get_table_names(schema=schema):
tb = Table(
# This module is part of SQLAlchemy and is released under
# the MIT License: https://www.opensource.org/licenses/mit-license.php
# mypy: ignore-errors
+import contextlib
+
+from ... import event
from ... import exc
+from ...testing.provision import allow_stale_update_impl
from ...testing.provision import configure_follower
from ...testing.provision import create_db
from ...testing.provision import drop_db
*returning, sort_by_parameter_order=sort_by_parameter_order
)
return stmt
+
+
+@allow_stale_update_impl.for_db("mariadb")
+def _allow_stale_update_impl(cfg):
+ @contextlib.contextmanager
+ def go():
+ @event.listens_for(cfg.db, "engine_connect")
+ def turn_off_snapshot_isolation(conn):
+ conn.exec_driver_sql("SET innodb_snapshot_isolation = 'OFF'")
+ conn.rollback()
+
+ try:
+ yield
+ finally:
+ event.remove(cfg.db, "engine_connect", turn_off_snapshot_isolation)
+
+ # dispose the pool; quick way to just have those reset
+ cfg.db.dispose()
+
+ return go()
from typing import Optional
from typing import Union
-import sqlalchemy.types as types
-from sqlalchemy.types import Float
+from ... import types
+from ...types import Float
class VectorIndexType(Enum):
"""
cache_ok = True
+
__visit_name__ = "VECTOR"
_typecode_map = {
def generate_sub_tests(cls, module, markers):
- if "backend" in markers or "sparse_backend" in markers:
+ if (
+ "backend" in markers
+ or "sparse_backend" in markers
+ or "sparse_driver_backend" in markers
+ ):
sparse = "sparse_backend" in markers
- for cfg in _possible_configs_for_cls(cls, sparse=sparse):
+ sparse_driver = "sparse_driver_backend" in markers
+ for cfg in _possible_configs_for_cls(
+ cls, sparse=sparse, sparse_driver=sparse_driver
+ ):
orig_name = cls.__name__
# we can have special chars in these names except for the
engines.testing_reaper.after_test_outside_fixtures(test)
-def _possible_configs_for_cls(cls, reasons=None, sparse=False):
+def _possible_configs_for_cls(
+ cls, reasons=None, sparse=False, sparse_driver=False
+):
all_configs = set(config.Config.all_configs())
if cls.__unsupported_on__:
cfg.db.name,
cfg.db.driver,
cfg.db.dialect.server_version_info,
+ cfg.db.dialect.is_async,
),
)
)
+
for cfg in sorted_all_configs:
db = cfg.db.name
if db not in per_dialect:
per_dialect[db] = cfg
return per_dialect.values()
+ elif sparse_driver:
+ # a more liberal form of "sparse" that will select for one driver,
+ # but still return for multiple database servers
+
+ dbs = {}
+
+ sorted_all_configs = list(
+ reversed(
+ sorted(
+ all_configs,
+ key=lambda cfg: (
+ cfg.db.name,
+ cfg.db.driver,
+ cfg.db.dialect.server_version_info,
+ cfg.db.dialect.is_async,
+ ),
+ )
+ )
+ )
+
+ for cfg in sorted_all_configs:
+ key = (cfg.db.name, cfg.db.dialect.server_version_info)
+ if key in dbs and dbs[key].is_default_dialect:
+ continue
+ else:
+ dbs[key] = cfg
+
+ chosen_cfgs = set(dbs.values())
+ return [cfg for cfg in sorted_all_configs if cfg in chosen_cfgs]
return all_configs
):
add_markers = {"backend"}
elif getattr(test_class.cls, "__sparse_backend__", False):
- add_markers = {"sparse_backend"}
+ add_markers = {"sparse_backend", "backend"}
+ elif getattr(test_class.cls, "__sparse_driver_backend__", False):
+ add_markers = {"sparse_driver_backend", "backend"}
else:
add_markers = frozenset()
from __future__ import annotations
import collections
+import contextlib
import logging
from . import config
from ..engine import url as sa_url
from ..sql import ddl
from ..sql import schema
+from ..util import decorator
log = logging.getLogger(__name__)
The default implementation does nothing
"""
return sequence
+
+
+@register.init
+def allow_stale_update_impl(cfg):
+ return contextlib.nullcontext()
+
+
+@decorator
+def allow_stale_updates(fn, *arg, **kw):
+ """decorator around a test function that indicates the test will
+ be UPDATING rows that have been read and are now stale.
+
+ This normally doesn't require intervention except for mariadb 12
+ which now raises its own error for that, and we want to turn off
+ that setting just within the scope of the test that needs it
+ to be turned off (i.e. ORM stale version tests)
+
+ """
+ with allow_stale_update_impl(config._current):
+ return fn(*arg, **kw)
if database in ["oracle", "mssql", "sqlite_file"]:
# use equals sign so that we avoid
# https://github.com/pytest-dev/pytest/issues/13913
- cmd.extend(["--write-idents=db_idents.txt"])
+ cmd.extend(["--write-idents=db_idents.txt", "--low-connections"])
cmd.extend(posargs)
"mypy: mypy integration / plugin tests",
"timing_intensive: time-oriented tests that are sensitive to race conditions",
"backend: tests that should run on all backends; typically dialect-sensitive",
- "sparse_backend: tests that should run on multiple backends, not necessarily all",
+ "sparse_backend: tests that should run on just one backend for each kind of db",
+ "sparse_driver_backend: tests that should run on just one kind of driver for each kind of db",
"gc_intensive: needs extremely predictable GC behavior",
]
mssql_async = mssql+aioodbc://scott:tiger^5HHH@mssql2022:1433/test?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes&Encrypt=Optional
pymssql = mssql+pymssql://scott:tiger^5HHH@mssql2022:1433/test
docker_mssql = mssql+pyodbc://scott:tiger^5HHH@127.0.0.1:1433/test?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes&Encrypt=Optional
-oracle = oracle+cx_oracle://scott:tiger@oracle18c/xe
-cxoracle = oracle+cx_oracle://scott:tiger@oracle18c/xe
-oracledb = oracle+oracledb://scott:tiger@oracle18c/xe
-oracledb_async = oracle+oracledb_async://scott:tiger@oracle18c/xe
+oracle = oracle+cx_oracle://scott:tiger@oracle23c/freepdb1
+cxoracle = oracle+cx_oracle://scott:tiger@oracle23c/freepdb1
+oracledb = oracle+oracledb://scott:tiger@oracle23c/freepdb1
+oracledb_async = oracle+oracledb_async://scott:tiger@oracle23c/freepdb1
docker_oracle = oracle+cx_oracle://scott:tiger@127.0.0.1:1521/?service_name=FREEPDB1
class MultiSchemaTest(fixtures.TestBase, AssertsCompiledSQL):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class ConstraintTest(AssertsCompiledSQL, fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def plain_foo_table(self, metadata, connection):
class SystemTableTablenamesTest(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
def setup_test(self):
with testing.db.begin() as conn:
table_names."""
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
def setup_test(self):
with testing.db.begin() as conn:
class TableReflectionTest(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.only_on(enterprise_edition_or_version(18))
def test_reflect_basic_compression(self, metadata, connection):
class ViewReflectionTest(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class RoundTripIndexTest(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_no_pk(self, metadata, connection):
Table(
class DBLinkReflectionTest(fixtures.TestBase):
__requires__ = ("oracle_test_dblink",)
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class TypeReflectionTest(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
def _run_test(self, metadata, connection, specs, attributes):
columns = [Column("c%i" % (i + 1), t[0]) for i, t in enumerate(specs)]
class IdentityReflectionTest(fixtures.TablesTest):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("identity_columns",)
@classmethod
class AdditionalReflectionTests(fixtures.TestBase):
__only_on__ = "oracle"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
finally:
exec_sql(connection, "DROP TABLE Z_TEST")
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_dim(self, metadata, connection):
t1 = Table(
"t1",
t1.create(connection)
eq_(t1.c.c1.type.dim, 3)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_insert(self, metadata, connection):
t1 = Table(
"t1",
(1, [6, 7]),
)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_insert_array(self, metadata, connection):
t1 = Table(
"t1",
(1, [6, 7]),
)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_multiformat_insert(self, metadata, connection):
t1 = Table(
"t1",
(1, [6, 7]),
)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_format(self, metadata, connection):
t1 = Table(
"t1",
t1.create(connection)
eq_(t1.c.c1.type.storage_format, VectorStorageFormat.FLOAT32)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
+ @testing.skip_if(
+ lambda: True,
+ "Does not work on free versions of Oracle 23. "
+ "No testing platform available",
+ )
def test_vector_hnsw_index(self, metadata, connection):
t1 = Table(
"t1",
(1, [6.0, 7.0, 8.0]),
)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_ivf_index(self, metadata, connection):
t1 = Table(
"t1",
(1, [6.0, 7.0, 8.0]),
)
- @testing.only_on("oracle>=23.4")
+ @testing.requires.oracle_vector
def test_vector_l2_distance(self, metadata, connection):
t1 = Table(
"t1",
).first()
eq_(res.embedding, [1, 2, 3])
- @testing.only_on("oracle>=23.7")
+ @testing.requires.oracle_sparse_vector
def test_sparse_vector(self, metadata, connection):
t1 = Table(
"t1",
t1.create(connection)
eq_(t1.c.embedding.type.storage_type, VectorStorageType.SPARSE)
- @testing.only_on("oracle>=23.7")
+ @testing.requires.oracle_sparse_vector
def test_sparse_vector_insert(self, metadata, connection):
t1 = Table(
"t1",
class FunctionTypingTest(fixtures.TestBase, AssertsExecutionResults):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_count_star(self, connection):
eq_(connection.scalar(func.count("*")), 1)
__requires__ = ("postgresql_test_dblink",)
__only_on__ = "postgresql >= 9.3"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
# partitioned table reflection, issue #4237
__only_on__ = "postgresql >= 10"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""Test reflection on materialized views"""
__only_on__ = "postgresql >= 9.3"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""Test PostgreSQL domains"""
__only_on__ = "postgresql > 8.3"
- __backend__ = True
+ __sparse_driver_backend__ = True
# these fixtures are all currently using individual test scope,
# on a connection that's in a transaction that's rolled back.
class ArrayReflectionTest(fixtures.TablesTest):
__only_on__ = "postgresql >= 10"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
ReflectionFixtures, AssertsCompiledSQL, ComparesIndexes, fixtures.TestBase
):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_reflected_primary_key_order(self, metadata, connection):
meta1 = metadata
class IntervalReflectionTest(fixtures.TestBase):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
("YEAR",),
class IdentityReflectionTest(fixtures.TablesTest):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("identity_columns",)
_names = ("t1", "T2", "MiXeDCaSe!")
class TestReflectDifficultColTypes(fixtures.TablesTest):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
def define_tables(metadata):
Table(
class NamedTypeTest(
AssertsCompiledSQL, fixtures.TestBase, AssertsExecutionResults
):
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = "postgresql > 8.3"
class DomainTest(
AssertsCompiledSQL, fixtures.TestBase, AssertsExecutionResults
):
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = "postgresql > 8.3"
@testing.requires.postgresql_working_nullable_domains
class DomainDDLEventTest(DDLEventWCreateHarness, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = "postgresql > 8.3"
class EnumDDLEventTest(DDLEventWCreateHarness, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = "postgresql > 8.3"
class OIDTest(fixtures.TestBase):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_reflection(self, connection, metadata):
Table(
class RegClassTest(fixtures.TestBase):
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture()
def scalar(self, connection):
"""test DDL and reflection of PG-specific types"""
__only_on__ = ("postgresql >= 8.3.0",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.metadata_fixture()
def special_types_table(self, metadata):
class _RangeTypeRoundTrip(_RangeComparisonFixtures, fixtures.TablesTest):
__requires__ = ("range_types",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class _MultiRangeTypeRoundTrip(fixtures.TablesTest, _RangeTests):
__requires__ = ("multirange_types",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture(params=(True, False), ids=["multirange", "plain_list"])
def data_obj(self, request):
class ConvenienceExecuteTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class CompiledCacheTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_cache(self, connection, metadata):
users = Table(
class SchemaTranslateTest(fixtures.TestBase, testing.AssertsExecutionResults):
__requires__ = ("schemas",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def plain_tables(self, metadata):
class EngineEventsTest(fixtures.TestBase):
__requires__ = ("ad_hoc_engines",)
- __backend__ = True
+ __sparse_driver_backend__ = True
def teardown_test(self):
Engine.dispatch._clear()
class HandleErrorTest(fixtures.TestBase):
__requires__ = ("ad_hoc_engines",)
- __backend__ = True
+ __sparse_driver_backend__ = True
def teardown_test(self):
Engine.dispatch._clear()
class ReflectionTest(fixtures.TestBase, ComparesTables):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_basic_reflection(self, connection, metadata):
meta = metadata
class CreateDropTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
run_create_tables = None
class SchemaManipulationTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_append_constraint_unique(self):
meta = MetaData()
class UnicodeReflectionTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class SchemaTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.schemas
def test_has_schema(self):
class ReverseCasingReflectTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = "default"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.denormalized_names
def setup_test(self):
class CaseSensitiveTest(fixtures.TablesTest):
"""Nail down case sensitive behaviors, mostly on MySQL."""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ColumnEventsTest(fixtures.RemovesEvents, fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class IdentityColumnTest(fixtures.TablesTest):
run_inserts = run_deletes = None
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("identity_columns", "table_reflection")
@classmethod
class TransactionTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class AutoRollbackTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class IsolationLevelTest(fixtures.TestBase):
- """see also sqlalchemy/testing/suite/test_dialect.py::IsolationLevelTest"""
+ """see also sqlalchemy/testing/suite/test_dialect.py::IsolationLevelTest
+
+ this suite has sparse_backend / ad_hoc_engines so wont take place
+ for every dbdriver under a nox run. the suite test should cover
+ that end of it
+
+ """
__requires__ = (
"isolation_level",
"ad_hoc_engines",
)
- __backend__ = True
+ __sparse_driver_backend__ = True
def _default_isolation_level(self):
return testing.requires.get_isolation_levels(testing.config)["default"]
# the state is cleared. options to optimize this with clear
# docs etc. should be added.
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_begin_close(self, reset_agent):
with reset_agent.engine.connect() as connection:
class IndexPropertyArrayTest(fixtures.DeclarativeMappedTest):
__requires__ = ("array_type",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
__requires__ = ("json_type",)
__only_on__ = "postgresql"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class BackendTests(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation("native_enum", [True, False])
@testing.variation("include_column", [True, False])
class BackendTests(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation("native_enum", [True, False])
@testing.variation("include_column", [True, False])
class BulkInsertUpdateVersionId(BulkTest, fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class BulkInsertUpdateTest(BulkTest, _fixtures.FixtureTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_mappers(cls):
class BulkUDPostfetchTest(BulkTest, fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class BulkUDTestAltColKeys(BulkTest, fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class BulkInheritanceTest(BulkTest, fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class BulkIssue6793Test(BulkTest, fixtures.DeclarativeMappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class InsertStmtTest(testing.AssertsExecutionResults, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation(
"style",
class UpdateStmtTest(testing.AssertsExecutionResults, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation(
"use_onupdate",
BulkDMLReturningInhTest, fixtures.DeclarativeMappedTest
):
__requires__ = ("insert_returning", "insert_executemany_returning")
- __backend__ = True
+ __sparse_driver_backend__ = True
use_sentinel = False
randomize_returning = False
BulkDMLReturningInhTest, fixtures.DeclarativeMappedTest
):
__requires__ = ("insert_returning", "insert_executemany_returning")
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
BulkDMLReturningInhTest, fixtures.DeclarativeMappedTest
):
__requires__ = ("insert_returning", "insert_executemany_returning")
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class CTETest(fixtures.DeclarativeMappedTest):
__requires__ = ("insert_returning", "ctes_on_dml")
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class LoadFromReturningTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("insert_returning",)
@classmethod
class OnUpdatePopulationTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation("populate_existing", [True, False])
@testing.variation(
class PGIssue11849Test(fixtures.DeclarativeMappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = ("postgresql",)
@classmethod
class UpdateDeleteTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class UpdateDeleteFromTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
run_inserts = "each"
run_deletes = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class SingleTablePolymorphicTest(fixtures.DeclarativeMappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class ColExpressionsTest(fixtures.DeclarativeMappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_classes(cls):
class OptimizedLoadTest(fixtures.MappedTest):
"""tests for the "optimized load" routine."""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class _PolymorphicTestBase:
- __backend__ = True
+ __sparse_driver_backend__ = True
__dialect__ = "default_enhanced"
@classmethod
class PropagateAttrsTest(QueryTest):
+ __sparse_driver_backend__ = True
+
def propagate_cases():
return testing.combinations(
(lambda: select(1), False),
class TriggerDefaultsTest(fixtures.MappedTest):
__requires__ = ("row_triggers",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""test that computed columns are recognized as server
oninsert/onupdate defaults."""
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("computed_columns",)
@classmethod
"""test that computed columns are recognized as server
oninsert/onupdate defaults."""
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("identity_columns",)
run_create_tables = "each"
_fixtures.FixtureTest,
testing.AssertsExecutionResults,
):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def passive_deletes_fixture(self, decl_base, connection):
testing.AssertsExecutionResults,
):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.insert_executemany_returning
@testing.combinations(True, False, argnames="flush_user_first")
class InnerJoinSplicingTest(fixtures.MappedTest, testing.AssertsCompiledSQL):
__dialect__ = "default"
- __backend__ = True # exercise hardcore join nesting on backends
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
fixtures.MappedTest, testing.AssertsCompiledSQL
):
__dialect__ = "default"
- __backend__ = True # exercise hardcore join nesting on backends
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""test for issue 11449"""
__dialect__ = "default"
- __backend__ = True # exercise hardcore join nesting on backends
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
run_inserts = "once"
run_deletes = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_mappers(cls):
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
# we want to test the lambda expiration logic so use backend
# to exercise that
- __backend__ = True
+ __sparse_driver_backend__ = True
run_setup_mappers = None
@testing.fixture
class UpdateDeleteTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
run_setup_mappers = "once"
class TypeCoerceTest(fixtures.MappedTest, testing.AssertsExecutionResults):
"""ORM-level test for [ticket:3531]"""
- __backend__ = True
+ __sparse_driver_backend__ = True
class StringAsInt(TypeDecorator):
impl = String(50)
class BackendTest(_fixtures.FixtureTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
# test against the major backends. We are naming specific databases
# here rather than using requirements rules since the behavior of
# MySQL 5.5 on Windows crashes (the entire server, not the client)
# if you screw around with ON UPDATE CASCADE type of stuff.
__requires__ = ("skip_mysql_on_windows",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class TransientExceptionTesst(_fixtures.FixtureTest):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_transient_exception(self):
"""An object that goes from a pk value to transient/pending
"""reverse the primary keys of two entities and ensure bookkeeping
succeeds."""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
__unsupported_on__ = ("mssql", "mysql", "mariadb")
__requires__ = ("on_update_or_deferrable_fks",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class NonPKCascadeTest(fixtures.MappedTest):
__requires__ = "skip_mysql_on_windows", "on_update_or_deferrable_fks"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""A primary key mutation cascades onto a foreign key that is itself a
primary key."""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
__unsupported_on__ = ("mssql",)
__requires__ = ("skip_mysql_on_windows",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
__unsupported_on__ = ("mssql",)
__requires__ = ("skip_mysql_on_windows",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
# more slice tests are available in test/orm/generative.py
class SliceTest(QueryTest):
__dialect__ = "default"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_first(self):
User = self.classes.User
run_setup_mappers = "each"
run_inserts = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
def _eagerload_mappings(self, addresses_lazy=True, user_lazy=True):
User, Address = self.classes("User", "Address")
class ExecutionTest(_fixtures.FixtureTest):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
(True,), (False,), argnames="add_do_orm_execute_event"
class SessionStateWFixtureTest(_fixtures.FixtureTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_autoflush_rollback(self):
Address, addresses, users, User = (
class SessionTransactionTest(fixtures.RemovesEvents, FixtureTest):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_no_close_transaction_on_flush(self, connection):
User, users = self.classes.User, self.tables.users
)
class SubtransactionRecipeTest(FixtureTest):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def subtransaction_recipe(self):
class FixtureDataTest(_LocalFixture):
run_inserts = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_attrs_on_rollback(self):
User = self.classes.User
"""
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
def _run_test(self, update_fn):
User, users = self.classes.User, self.tables.users
class AutoExpireTest(_LocalFixture):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_expunge_pending_on_rollback(self):
User = self.classes.User
class TwoPhaseTest(_LocalFixture):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.two_phase_transactions
def test_rollback_on_prepare(self):
class RollbackRecoverTest(_LocalFixture):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_pk_violation(self):
User, Address = self.classes.User, self.classes.Address
class SavepointTest(_LocalFixture):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.savepoints
def test_savepoint_rollback(self):
class AccountingFlagsTest(_LocalFixture):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_no_expire_on_commit(self):
User, users = self.classes.User, self.tables.users
class ContextManagerPlusFutureTest(FixtureTest):
run_inserts = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.savepoints
@engines.close_open_connections
class NaturalPKRollbackTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ClauseAttributesTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
# the test manipulates INSERTS to become UPDATES to simulate
# "INSERT that returns no row" so both are needed; the manipulations
# are currently postgresql or SQLite specific
- __backend__ = True
+ __sparse_driver_backend__ = True
__only_on__ = ("postgresql", "sqlite")
@testing.fixture
class BasicStaleChecksTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class EagerDefaultsTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class EagerDefaultsSettingTest(
testing.AssertsExecutionResults, fixtures.TestBase
):
- __backend__ = True
+ __sparse_driver_backend__ = True
@variation_fixture("eager_defaults", ["unspecified", "auto", True, False])
def eager_defaults_variations(self, request):
class TryToFoolInsertManyValuesTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.variation(
"pk_type",
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
+from sqlalchemy.testing import provision
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
class NullVersionIdTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class VersioningTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
finally:
testing.db.dialect.supports_sane_rowcount = save
+ @provision.allow_stale_updates
def test_basic(self):
Foo = self.classes.Foo
s1.commit()
eq_(s1.query(Foo).count(), 0)
+ @provision.allow_stale_updates
@engines.close_open_connections
def test_versioncheck(self):
"""query.with_lockmode performs a 'version check' on an already loaded
class VersionOnPostUpdateTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class NoBumpOnRelationshipTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ColumnTypeTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("sane_rowcount",)
@classmethod
class RowSwitchTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class AlternateGeneratorTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("sane_rowcount",)
@classmethod
class PlainInheritanceTest(fixtures.MappedTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ServerVersioningTest(fixtures.MappedTest):
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ManualVersionTest(fixtures.MappedTest):
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ManualInheritanceVersionTest(fixtures.MappedTest):
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("sane_rowcount",)
@classmethod
class VersioningMappedSelectTest(fixtures.MappedTest):
# test for #4193, see also #4194 for related notes
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class QuotedBindVersioningTest(fixtures.MappedTest):
"""test for #8056"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
return skip_if(
[
no_support("oracle", "Oracle XE usually can't handle these"),
- no_support("mssql+pyodbc", "MS ODBC drivers struggle"),
+ no_support(
+ "mssql", "MS drivers struggle plus the DB does too"
+ ),
no_support("+aiosqlite", "very unreliable driver"),
self._running_on_windows(),
]
def oracle_test_dblink2(self):
return self._has_oracle_test_dblink("oracle_db_link2")
+ @property
+ def oracle_vector(self):
+ """oracle vector support"""
+ return only_on("oracle>=23.4") + only_on("oracle+oracledb")
+
+ @property
+ def oracle_sparse_vector(self):
+ """oracle vector support"""
+ return only_on("oracle>=23.7") + only_on("oracle+oracledb")
+
@property
def postgresql_test_dblink(self):
return skip_if(
class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults):
__dialect__ = "default"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.provide_metadata
def test_pk_fk_constraint_create(self):
class DefaultRoundTripTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class CTEDefaultTest(fixtures.TablesTest):
__requires__ = ("ctes", "insert_returning", "ctes_on_dml")
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class PKDefaultTest(fixtures.TestBase):
__requires__ = ("subqueries",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def table_fixture(self, metadata, connection):
class PKIncrementTest(fixtures.TablesTest):
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class AutoIncrementTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.empty_inserts
def test_autoincrement_single_col(self, metadata, connection):
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class ServerDefaultsOnPKTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.provide_metadata
def test_string_default_none_on_insert(self, connection):
class InsertFromSelectTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class CurrentParametersTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class DeleteFromRoundTripTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class DeprecationWarningsTest(fixtures.TestBase, AssertsCompiledSQL):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_ident_preparer_force(self):
preparer = testing.db.dialect.identifier_preparer
class KeyTargetingTest(fixtures.TablesTest):
run_inserts = "once"
run_deletes = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class PKIncrementTest(fixtures.TablesTest):
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class TestLinterRoundTrip(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class ExecuteTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
def teardown_test(self):
pass
class _IdentityDDLFixture(testing.AssertsCompiledSQL):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
(dict(always=True), "ALWAYS AS IDENTITY"),
class InsertExecTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""
run_create_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class InsertManyValuesTest(fixtures.RemovesEvents, fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("insertmanyvalues",)
@classmethod
class IMVSentinelTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("insert_returning",)
class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = "DefaultDialect"
- __backend__ = True
+ __sparse_driver_backend__ = True
table1 = table(
"some_large_named_table",
class SchemaTypeTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
class TrackEvents:
column = None
class QueryTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class LimitTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""test compound statements like UNION, INTERSECT, particularly their
ability to nest on different databases."""
- __backend__ = True
+ __sparse_driver_backend__ = True
run_inserts = "each"
database seems to be sensitive to this.
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class OperatorTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class QuoteExecTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class CursorResultTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class KeyTargetingTest(fixtures.TablesTest):
run_inserts = "once"
run_deletes = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class PositionalTextTest(fixtures.TablesTest):
run_inserts = "once"
run_deletes = None
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class MergeCursorResultTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
__requires__ = ("independent_cursors",)
class GenerativeResultTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class InsertReturningTest(fixtures.TablesTest, AssertsExecutionResults):
__requires__ = ("insert_returning",)
- __backend__ = True
+ __sparse_driver_backend__ = True
run_create_tables = "each"
class UpdateReturningTest(fixtures.TablesTest, AssertsExecutionResults):
__requires__ = ("update_returning",)
- __backend__ = True
+ __sparse_driver_backend__ = True
run_create_tables = "each"
class DeleteReturningTest(fixtures.TablesTest, AssertsExecutionResults):
__requires__ = ("delete_returning",)
- __backend__ = True
+ __sparse_driver_backend__ = True
run_create_tables = "each"
class CompositeStatementTest(fixtures.TestBase):
__requires__ = ("insert_returning",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.provide_metadata
def test_select_doesnt_pollute_result(self, connection):
class SequenceReturningTest(fixtures.TablesTest):
__requires__ = "insert_returning", "sequences"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
"""test returning() works with columns that define 'key'."""
__requires__ = ("insert_returning",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class InsertReturnDefaultsTest(fixtures.TablesTest):
__requires__ = ("insert_returning",)
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class UpdatedReturnDefaultsTest(fixtures.TablesTest):
__requires__ = ("update_returning",)
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
define_tables = InsertReturnDefaultsTest.define_tables
class DeleteReturnDefaultsTest(fixtures.TablesTest):
__requires__ = ("delete_returning",)
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
define_tables = InsertReturnDefaultsTest.define_tables
class InsertManyReturnDefaultsTest(fixtures.TablesTest):
__requires__ = ("insert_executemany_returning",)
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
define_tables = InsertReturnDefaultsTest.define_tables
class InsertManyReturningTest(fixtures.TablesTest):
__requires__ = ("insert_executemany_returning",)
run_define_tables = "each"
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class SequenceDDLTest(fixtures.TestBase, testing.AssertsCompiledSQL):
__dialect__ = "default"
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
(Sequence("foo_seq"), ""),
class SequenceExecTest(fixtures.TestBase):
__requires__ = ("sequences",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def setup_test_class(cls):
class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL):
__requires__ = ("sequences",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
(Sequence("foo_seq"),),
class TableBoundSequenceTest(fixtures.TablesTest):
__requires__ = ("sequences",)
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def table_fixture(self, metadata, connection, implicit_returning):
testing.AssertsExecutionResults, fixtures.TablesTest
):
__requires__ = ("sequences_as_server_defaults",)
- __backend__ = True
+ __sparse_driver_backend__ = True
run_create_tables = "each"
class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
def _data_fixture(self, connection):
users = self.tables.users
class TypeDecoratorSpecialCasesTest(AssertsCompiledSQL, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.array_type
def test_typedec_of_array_modified(self, metadata, connection):
"""related to #6770, test that insert().values() applies to
bound parameter handlers including the None value."""
- __backend__ = True
+ __sparse_driver_backend__ = True
def _data_fixture(self, connection):
users = self.tables.users
class TypeCoerceCastTest(fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class VariantBackendTest(fixtures.TestBase, AssertsCompiledSQL):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.fixture
def variant_roundtrip(self, metadata, connection):
class EnumTest(AssertsCompiledSQL, fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
SomeEnum = pep435_enum("SomeEnum")
class BinaryTest(fixtures.TablesTest, AssertsExecutionResults):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class TestKWArgPassThru(AssertsCompiledSQL, fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_user_defined(self):
"""test that dialects pass the column through on DDL."""
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
def _fixture(self, connection, metadata, type_, data):
t = Table("t", metadata, Column("val", type_))
class IntervalTest(fixtures.TablesTest, AssertsExecutionResults):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class IntegerTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
def test_integer_literal_processor(self):
typ = Integer()
"""
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
class LiteralTest(fixtures.TestBase):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.combinations(
("datetime", datetime.datetime.now()),
class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest):
- __backend__ = True
+ __sparse_driver_backend__ = True
@testing.requires.update_from
def test_exec_two_table(self, connection):
class UpdateFromMultiTableUpdateDefaultsTest(
_UpdateFromTestBase, fixtures.TablesTest
):
- __backend__ = True
+ __sparse_driver_backend__ = True
@classmethod
def define_tables(cls, metadata):
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
