databricks-sqlalchemy 0.0.1b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

databricks/sqlalchemy/test/_unsupported.py

@@ -0,0 +1,450 @@
+# 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,189 @@
+"""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

@@ -0,0 +1,33 @@
+"""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

@@ -0,0 +1,13 @@
+"""
+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