databricks-sqlalchemy 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

databricks/sqlalchemy/test/_unsupported.py

@@ -1,450 +0,0 @@
-# type: ignore
-
-from enum import Enum
-
-import pytest
-from databricks.sqlalchemy.test._regression import (
-    ComponentReflectionTest,
-    ComponentReflectionTestExtra,
-    CTETest,
-    FetchLimitOffsetTest,
-    FutureTableDDLTest,
-    HasTableTest,
-    InsertBehaviorTest,
-    NumericTest,
-    TableDDLTest,
-    UuidTest,
-)
-
-# These are test suites that are fully skipped with a SkipReason
-from sqlalchemy.testing.suite import (
-    AutocommitIsolationTest,
-    DateTimeTZTest,
-    ExceptionTest,
-    HasIndexTest,
-    HasSequenceTest,
-    HasSequenceTestEmpty,
-    IsolationLevelTest,
-    LastrowidTest,
-    LongNameBlowoutTest,
-    PercentSchemaNamesTest,
-    ReturningTest,
-    SequenceCompilerTest,
-    SequenceTest,
-    ServerSideCursorsTest,
-    UnicodeSchemaTest,
-)
-
-
-class SkipReason(Enum):
-    AUTO_INC = "implicit AUTO_INCREMENT"
-    CTE_FEAT = "required CTE features"
-    CURSORS = "server-side cursors"
-    DECIMAL_FEAT = "required decimal features"
-    ENFORCE_KEYS = "enforcing primary or foreign key restraints"
-    FETCH = "fetch clauses"
-    IDENTIFIER_LENGTH = "identifiers > 255 characters"
-    IMPL_FLOAT_PREC = "required implicit float precision"
-    IMPLICIT_ORDER = "deterministic return order if ORDER BY is not present"
-    INDEXES = "SQL INDEXes"
-    RETURNING = "INSERT ... RETURNING syntax"
-    SEQUENCES = "SQL SEQUENCES"
-    STRING_FEAT = "required STRING type features"
-    SYMBOL_CHARSET = "symbols expected by test"
-    TEMP_TBL = "temporary tables"
-    TIMEZONE_OPT = "timezone-optional TIMESTAMP fields"
-    TRANSACTIONS = "transactions"
-    UNIQUE = "UNIQUE constraints"
-
-
-def render_skip_reason(rsn: SkipReason, setup_error=False, extra=False) -> str:
-    prefix = "[BADSETUP]" if setup_error else ""
-    postfix = " More detail in _unsupported.py" if extra else ""
-    return f"[UNSUPPORTED]{prefix}[{rsn.name}]: Databricks does not support {rsn.value}.{postfix}"
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.ENFORCE_KEYS))
-class ExceptionTest(ExceptionTest):
-    """Per Databricks documentation, primary and foreign key constraints are informational only
-    and are not enforced.
-
-    https://docs.databricks.com/api/workspace/tableconstraints
-    """
-
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.IDENTIFIER_LENGTH))
-class LongNameBlowoutTest(LongNameBlowoutTest):
-    """These tests all include assertions that the tested name > 255 characters"""
-
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES))
-class HasSequenceTest(HasSequenceTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES))
-class HasSequenceTestEmpty(HasSequenceTestEmpty):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES))
-class HasIndexTest(HasIndexTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SYMBOL_CHARSET))
-class UnicodeSchemaTest(UnicodeSchemaTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.CURSORS))
-class ServerSideCursorsTest(ServerSideCursorsTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SYMBOL_CHARSET))
-class PercentSchemaNamesTest(PercentSchemaNamesTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.TRANSACTIONS))
-class IsolationLevelTest(IsolationLevelTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.TRANSACTIONS))
-class AutocommitIsolationTest(AutocommitIsolationTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.RETURNING))
-class ReturningTest(ReturningTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES))
-class SequenceTest(SequenceTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES))
-class SequenceCompilerTest(SequenceCompilerTest):
-    pass
-
-
-class FetchLimitOffsetTest(FetchLimitOffsetTest):
-    @pytest.mark.flaky
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.IMPLICIT_ORDER, extra=True))
-    def test_limit_render_multiple_times(self):
-        """This test depends on the order that records are inserted into the table. It's passing criteria requires that
-        a record inserted with id=1 is the first record returned when no ORDER BY clause is specified. But Databricks occasionally
-        INSERTS in a different order, which makes this test seem to fail. The test is flaky, but the underlying functionality
-        (can multiple LIMIT clauses be rendered) is not broken.
-
-        Unclear if this is a bug in Databricks, Delta, or some race-condition in the test itself.
-        """
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_bound_fetch_offset(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_no_order(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_nobinds(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_simple_fetch(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_simple_fetch_offset(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_simple_fetch_percent(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_simple_fetch_percent_ties(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_simple_fetch_ties(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_expr_fetch_offset(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_percent(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_percent_ties(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_ties(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH))
-    def test_fetch_offset_ties_exact_number(self):
-        pass
-
-
-class UuidTest(UuidTest):
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.RETURNING))
-    def test_uuid_returning(self):
-        pass
-
-
-class FutureTableDDLTest(FutureTableDDLTest):
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_create_index_if_not_exists(self):
-        """We could use requirements.index_reflection and requirements.index_ddl_if_exists
-        here to disable this but prefer a more meaningful skip message
-        """
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_drop_index_if_exists(self):
-        """We could use requirements.index_reflection and requirements.index_ddl_if_exists
-        here to disable this but prefer a more meaningful skip message
-        """
-        pass
-
-
-class TableDDLTest(TableDDLTest):
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES))
-    def test_create_index_if_not_exists(self, connection):
-        """We could use requirements.index_reflection and requirements.index_ddl_if_exists
-        here to disable this but prefer a more meaningful skip message
-        """
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES))
-    def test_drop_index_if_exists(self, connection):
-        """We could use requirements.index_reflection and requirements.index_ddl_if_exists
-        here to disable this but prefer a more meaningful skip message
-        """
-        pass
-
-
-class ComponentReflectionTest(ComponentReflectionTest):
-    """This test requires two schemas be present in the target Databricks workspace:
-    - The schema set in --dburi
-    - A second schema named "test_schema"
-
-    Note that test_get_multi_foreign keys is flaky because DBR does not guarantee the order of data returned in DESCRIBE TABLE EXTENDED
-    """
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.UNIQUE))
-    def test_get_multi_unique_constraints(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL, True, True))
-    def test_get_temp_view_names(self):
-        """While Databricks supports temporary views, this test creates a temp view aimed at a temp table.
-        Databricks doesn't support temp tables. So the test can never pass.
-        """
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL))
-    def test_get_temp_table_columns(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL))
-    def test_get_temp_table_indexes(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL))
-    def test_get_temp_table_names(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL))
-    def test_get_temp_table_unique_constraints(self):
-        pass
-
-    @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL))
-    def test_reflect_table_temp_table(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_get_indexes(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_multi_indexes(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def get_noncol_index(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.UNIQUE))
-    def test_get_unique_constraints(self):
-        pass
-
-
-class NumericTest(NumericTest):
-    @pytest.mark.skip(render_skip_reason(SkipReason.DECIMAL_FEAT))
-    def test_enotation_decimal(self):
-        """This test automatically runs if requirements.precision_numerics_enotation_large is open()"""
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.DECIMAL_FEAT))
-    def test_enotation_decimal_large(self):
-        """This test automatically runs if requirements.precision_numerics_enotation_large is open()"""
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.IMPL_FLOAT_PREC, extra=True))
-    def test_float_coerce_round_trip(self):
-        """
-        This automatically runs if requirements.literal_float_coercion is open()
-
-        Without additional work, Databricks returns 15.75629997253418 when you SELECT 15.7563.
-        This is a potential area where we could override the Float literal processor to add a CAST.
-        Will leave to a PM to decide if we should do so.
-        """
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.IMPL_FLOAT_PREC, extra=True))
-    def test_float_custom_scale(self):
-        """This test automatically runs if requirements.precision_generic_float_type is open()"""
-        pass
-
-
-class HasTableTest(HasTableTest):
-    """Databricks does not support temporary tables."""
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.TEMP_TBL))
-    def test_has_table_temp_table(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.TEMP_TBL, True, True))
-    def test_has_table_temp_view(self):
-        """Databricks supports temporary views but this test depends on requirements.has_temp_table, which we
-        explicitly close so that we can run other tests in this group. See the comment under has_temp_table in
-        requirements.py for details.
-
-        From what I can see, there is no way to run this test since it will fail during setup if we mark has_temp_table
-        open(). It _might_ be possible to hijack this behaviour by implementing temp_table_keyword_args in our own
-        provision.py. Doing so would mean creating a real table during this class setup instead of a temp table. Then
-        we could just skip the temp table tests but run the temp view tests. But this test fixture doesn't cleanup its
-        temp tables and has no hook to do so.
-
-        It would be ideal for SQLAlchemy to define a separate requirements.has_temp_views.
-        """
-        pass
-
-
-class ComponentReflectionTestExtra(ComponentReflectionTestExtra):
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_reflect_covering_index(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES))
-    def test_reflect_expression_based_indexes(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.STRING_FEAT, extra=True))
-    def test_varchar_reflection(self):
-        """Databricks doesn't enforce string length limitations like STRING(255)."""
-        pass
-
-
-class InsertBehaviorTest(InsertBehaviorTest):
-    @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True))
-    def test_autoclose_on_insert(self):
-        """The setup for this test creates a column with implicit autoincrement enabled.
-        This dialect does not implement implicit autoincrement - users must declare Identity() explicitly.
-        """
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True))
-    def test_insert_from_select_autoinc(self):
-        """Implicit autoincrement is not implemented in this dialect."""
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True))
-    def test_insert_from_select_autoinc_no_rows(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.RETURNING))
-    def test_autoclose_on_insert_implicit_returning(self):
-        pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, extra=True))
-class LastrowidTest(LastrowidTest):
-    """SQLAlchemy docs describe that a column without an explicit Identity() may implicitly create one if autoincrement=True.
-    That is what this method tests. Databricks supports auto-incrementing IDENTITY columns but they must be explicitly
-    declared. This limitation is present in our dialect as well. Which means that SQLAlchemy's autoincrement setting of a column
-    is ignored. We emit a logging.WARN message if you try it.
-
-    In the future we could handle this autoincrement by implicitly calling the visit_identity_column() method of our DDLCompiler
-    when autoincrement=True. There is an example of this in the Microsoft SQL Server dialect: MSSDDLCompiler.get_column_specification
-
-    For now, if you need to create a SQLAlchemy column with an auto-incrementing identity, you must set this explicitly in your column
-    definition by passing an Identity() to the column constructor.
-    """
-
-    pass
-
-
-class CTETest(CTETest):
-    """During the teardown for this test block, it tries to drop a constraint that it never named which raises
-    a compilation error. This could point to poor constraint reflection but our other constraint reflection
-    tests pass. Requires investigation.
-    """
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.CTE_FEAT, extra=True))
-    def test_select_recursive_round_trip(self):
-        pass
-
-    @pytest.mark.skip(render_skip_reason(SkipReason.CTE_FEAT, extra=True))
-    def test_delete_scalar_subq_round_trip(self):
-        """Error received is [UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.MUST_AGGREGATE_CORRELATED_SCALAR_SUBQUERY]
-
-        This suggests a limitation of the platform. But a workaround may be possible if customers require it.
-        """
-        pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_skip_reason(SkipReason.TIMEZONE_OPT, True))
-class DateTimeTZTest(DateTimeTZTest):
-    """Test whether the sqlalchemy.DateTime() type can _optionally_ include timezone info.
-    This dialect maps DateTime() → TIMESTAMP, which _always_ includes tzinfo.
-
-    Users can use databricks.sqlalchemy.TIMESTAMP_NTZ for a tzinfo-less timestamp. The SQLA docs
-    acknowledge this is expected for some dialects.
-
-    https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.DateTime
-    """
-
-    pass

databricks/sqlalchemy/test/conftest.py

@@ -1,13 +0,0 @@
-from sqlalchemy.dialects import registry
-import pytest
-
-registry.register("databricks", "databricks.sqlalchemy", "DatabricksDialect")
-# sqlalchemy's dialect-testing machinery wants an entry like this.
-# This seems to be based around dialects maybe having multiple drivers
-# and wanting to test driver-specific URLs, but doesn't seem to make
-# much sense for dialects with only one driver.
-registry.register("databricks.databricks", "databricks.sqlalchemy", "DatabricksDialect")
-
-pytest.register_assert_rewrite("sqlalchemy.testing.assertions")
-
-from sqlalchemy.testing.plugin.pytestplugin import *

databricks/sqlalchemy/test/overrides/_componentreflectiontest.py

@@ -1,189 +0,0 @@
-"""The default test setup uses self-referential foreign keys and indexes for a test table.
-We override to remove these assumptions.
-
-Note that test_multi_foreign_keys currently does not pass for all combinations due to
-an ordering issue. The dialect returns the expected information. But this test makes assertions
-on the order of the returned results. We can't guarantee that order at the moment.
-
-The test fixture actually tries to sort the outputs, but this sort isn't working. Will need
-to follow-up on this later.
-"""
-import sqlalchemy as sa
-from sqlalchemy.testing import config
-from sqlalchemy.testing.schema import Column
-from sqlalchemy.testing.schema import Table
-from sqlalchemy import ForeignKey
-from sqlalchemy import testing
-
-from sqlalchemy.testing.suite.test_reflection import ComponentReflectionTest
-
-
-class ComponentReflectionTest(ComponentReflectionTest):  # type: ignore
-    @classmethod
-    def define_reflected_tables(cls, metadata, schema):
-        if schema:
-            schema_prefix = schema + "."
-        else:
-            schema_prefix = ""
-
-        if testing.requires.self_referential_foreign_keys.enabled:
-            parent_id_args = (
-                ForeignKey(
-                    "%susers.user_id" % schema_prefix, name="user_id_fk", use_alter=True
-                ),
-            )
-        else:
-            parent_id_args = ()
-        users = Table(
-            "users",
-            metadata,
-            Column("user_id", sa.INT, primary_key=True),
-            Column("test1", sa.CHAR(5), nullable=False),
-            Column("test2", sa.Float(), nullable=False),
-            Column("parent_user_id", sa.Integer, *parent_id_args),
-            sa.CheckConstraint(
-                "test2 > 0",
-                name="zz_test2_gt_zero",
-                comment="users check constraint",
-            ),
-            sa.CheckConstraint("test2 <= 1000"),
-            schema=schema,
-            test_needs_fk=True,
-        )
-
-        Table(
-            "dingalings",
-            metadata,
-            Column("dingaling_id", sa.Integer, primary_key=True),
-            Column(
-                "address_id",
-                sa.Integer,
-                ForeignKey(
-                    "%semail_addresses.address_id" % schema_prefix,
-                    name="zz_email_add_id_fg",
-                    comment="di fk comment",
-                ),
-            ),
-            Column(
-                "id_user",
-                sa.Integer,
-                ForeignKey("%susers.user_id" % schema_prefix),
-            ),
-            Column("data", sa.String(30), unique=True),
-            sa.CheckConstraint(
-                "address_id > 0 AND address_id < 1000",
-                name="address_id_gt_zero",
-            ),
-            sa.UniqueConstraint(
-                "address_id",
-                "dingaling_id",
-                name="zz_dingalings_multiple",
-                comment="di unique comment",
-            ),
-            schema=schema,
-            test_needs_fk=True,
-        )
-        Table(
-            "email_addresses",
-            metadata,
-            Column("address_id", sa.Integer),
-            Column("remote_user_id", sa.Integer, ForeignKey(users.c.user_id)),
-            Column("email_address", sa.String(20)),
-            sa.PrimaryKeyConstraint(
-                "address_id", name="email_ad_pk", comment="ea pk comment"
-            ),
-            schema=schema,
-            test_needs_fk=True,
-        )
-        Table(
-            "comment_test",
-            metadata,
-            Column("id", sa.Integer, primary_key=True, comment="id comment"),
-            Column("data", sa.String(20), comment="data % comment"),
-            Column(
-                "d2",
-                sa.String(20),
-                comment=r"""Comment types type speedily ' " \ '' Fun!""",
-            ),
-            Column("d3", sa.String(42), comment="Comment\nwith\rescapes"),
-            schema=schema,
-            comment=r"""the test % ' " \ table comment""",
-        )
-        Table(
-            "no_constraints",
-            metadata,
-            Column("data", sa.String(20)),
-            schema=schema,
-            comment="no\nconstraints\rhas\fescaped\vcomment",
-        )
-
-        if testing.requires.cross_schema_fk_reflection.enabled:
-            if schema is None:
-                Table(
-                    "local_table",
-                    metadata,
-                    Column("id", sa.Integer, primary_key=True),
-                    Column("data", sa.String(20)),
-                    Column(
-                        "remote_id",
-                        ForeignKey("%s.remote_table_2.id" % testing.config.test_schema),
-                    ),
-                    test_needs_fk=True,
-                    schema=config.db.dialect.default_schema_name,
-                )
-            else:
-                Table(
-                    "remote_table",
-                    metadata,
-                    Column("id", sa.Integer, primary_key=True),
-                    Column(
-                        "local_id",
-                        ForeignKey(
-                            "%s.local_table.id" % config.db.dialect.default_schema_name
-                        ),
-                    ),
-                    Column("data", sa.String(20)),
-                    schema=schema,
-                    test_needs_fk=True,
-                )
-                Table(
-                    "remote_table_2",
-                    metadata,
-                    Column("id", sa.Integer, primary_key=True),
-                    Column("data", sa.String(20)),
-                    schema=schema,
-                    test_needs_fk=True,
-                )
-
-        if testing.requires.index_reflection.enabled:
-            Index("users_t_idx", users.c.test1, users.c.test2, unique=True)
-            Index("users_all_idx", users.c.user_id, users.c.test2, users.c.test1)
-
-            if not schema:
-                # test_needs_fk is at the moment to force MySQL InnoDB
-                noncol_idx_test_nopk = Table(
-                    "noncol_idx_test_nopk",
-                    metadata,
-                    Column("q", sa.String(5)),
-                    test_needs_fk=True,
-                )
-
-                noncol_idx_test_pk = Table(
-                    "noncol_idx_test_pk",
-                    metadata,
-                    Column("id", sa.Integer, primary_key=True),
-                    Column("q", sa.String(5)),
-                    test_needs_fk=True,
-                )
-
-                if (
-                    testing.requires.indexes_with_ascdesc.enabled
-                    and testing.requires.reflect_indexes_with_ascdesc.enabled
-                ):
-                    Index("noncol_idx_nopk", noncol_idx_test_nopk.c.q.desc())
-                    Index("noncol_idx_pk", noncol_idx_test_pk.c.q.desc())
-
-        if testing.requires.view_column_reflection.enabled:
-            cls.define_views(metadata, schema)
-        if not schema and testing.requires.temp_table_reflection.enabled:
-            cls.define_temp_tables(metadata)

databricks/sqlalchemy/test/overrides/_ctetest.py

@@ -1,33 +0,0 @@
-"""The default test setup uses a self-referential foreign key. With our dialect this requires
-`use_alter=True` and the fk constraint to be named. So we override this to make the test pass.
-"""
-
-from sqlalchemy.testing.suite import CTETest
-
-from sqlalchemy.testing.schema import Column
-from sqlalchemy.testing.schema import Table
-from sqlalchemy import ForeignKey
-from sqlalchemy import Integer
-from sqlalchemy import String
-
-
-class CTETest(CTETest):  # type: ignore
-    @classmethod
-    def define_tables(cls, metadata):
-        Table(
-            "some_table",
-            metadata,
-            Column("id", Integer, primary_key=True),
-            Column("data", String(50)),
-            Column(
-                "parent_id", ForeignKey("some_table.id", name="fk_test", use_alter=True)
-            ),
-        )
-
-        Table(
-            "some_other_table",
-            metadata,
-            Column("id", Integer, primary_key=True),
-            Column("data", String(50)),
-            Column("parent_id", Integer),
-        )

databricks/sqlalchemy/test/test_suite.py

@@ -1,13 +0,0 @@
-"""
-The order of these imports is important. Test cases are imported first from SQLAlchemy,
-then are overridden by our local skip markers in _regression, _unsupported, and _future.
-"""
-
-
-# type: ignore
-# fmt: off
-from sqlalchemy.testing.suite import *
-from databricks.sqlalchemy.test._regression import *
-from databricks.sqlalchemy.test._unsupported import *
-from databricks.sqlalchemy.test._future import *
-from databricks.sqlalchemy.test._extra import TinyIntegerTest, DateTimeTZTestCustom