databricks-sqlalchemy 2.0.2__tar.gz → 2.0.4__tar.gz

{databricks_sqlalchemy-2.0.2 → databricks_sqlalchemy-2.0.4}/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Release History
 
-# 2.0.2 
+# 2.0.4 (2025-01-27)
 
 - All the SQLAlchemy features from `databricks-sql-connector>=4.0.0` have been moved to this `databricks-sqlalchemy` library
-- Support for SQLAlchemy v2 dialect is provided 
+- Support for SQLAlchemy v2 dialect is provided

{databricks_sqlalchemy-2.0.2 → databricks_sqlalchemy-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: databricks-sqlalchemy
-Version: 2.0.2
+Version: 2.0.4
 Summary: Databricks SQLAlchemy plugin for Python
 License: Apache-2.0
 Author: Databricks
@@ -13,7 +13,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: databricks_sql_connector (==4.0.0.b4)
+Requires-Dist: databricks_sql_connector (>=4.0.0)
+Requires-Dist: pyarrow (>=14.0.1,<17)
 Requires-Dist: sqlalchemy (>=2.0.21)
 Project-URL: Bug Tracker, https://github.com/databricks/databricks-sqlalchemy/issues
 Project-URL: Homepage, https://github.com/databricks/databricks-sqlalchemy

{databricks_sqlalchemy-2.0.2 → databricks_sqlalchemy-2.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "databricks-sqlalchemy"
-version = "2.0.2"
+version = "2.0.4"
 description = "Databricks SQLAlchemy plugin for Python"
 authors = ["Databricks <databricks-sql-connector-maintainers@databricks.com>"]
 license = "Apache-2.0"
@@ -10,7 +10,8 @@ include = ["CHANGELOG.md"]
 
 [tool.poetry.dependencies]
 python = "^3.8.0"
-databricks_sql_connector = { version = "==4.0.0.b4"}
+databricks_sql_connector = { version = ">=4.0.0"}
+pyarrow = { version = ">=14.0.1,<17"}
 sqlalchemy = { version = ">=2.0.21" }
 
 [tool.poetry.dev-dependencies]
@@ -39,5 +40,8 @@ markers = {"reviewed" = "Test case has been reviewed by Databricks"}
 minversion = "6.0"
 log_cli = "false"
 log_cli_level = "INFO"
-testpaths = ["tests", "src/databricks/sqlalchemy/test_local"]
+testpaths = ["tests", "tests/test_local"]
 env_files = ["test.env"]
+
+[tool.mypy]
+ignore_missing_imports = true

databricks_sqlalchemy-2.0.2/src/databricks/sqlalchemy/dependency_test/test_dependency.py

@@ -1,22 +0,0 @@
-import pytest
-
-class DatabricksImportError(Exception):
-    pass
-
-class TestLibraryDependencySuite:
-
-    @pytest.mark.skipif(pytest.importorskip("databricks_sql_connector"), reason="databricks_sql_connector is present")
-    def test_sql_core(self):
-        with pytest.raises(DatabricksImportError, match="databricks_sql_connector module is not available"):
-            try:
-                import databricks
-            except ImportError:
-                raise DatabricksImportError("databricks_sql_connector_core module is not available")
-
-    @pytest.mark.skipif(pytest.importorskip("sqlalchemy"), reason="SQLAlchemy is present")
-    def test_sqlalchemy(self):
-        with pytest.raises(DatabricksImportError, match="sqlalchemy module is not available"):
-            try:
-                import sqlalchemy
-            except ImportError:
-                raise DatabricksImportError("sqlalchemy module is not available")

databricks_sqlalchemy-2.0.2/src/databricks/sqlalchemy/test/_extra.py

@@ -1,70 +0,0 @@
-"""Additional tests authored by Databricks that use SQLAlchemy's test fixtures
-"""
-
-import datetime
-
-from sqlalchemy.testing.suite.test_types import (
-    _LiteralRoundTripFixture,
-    fixtures,
-    testing,
-    eq_,
-    select,
-    Table,
-    Column,
-    config,
-    _DateFixture,
-    literal,
-)
-from databricks.sqlalchemy import TINYINT, TIMESTAMP
-
-
-class TinyIntegerTest(_LiteralRoundTripFixture, fixtures.TestBase):
-    __backend__ = True
-
-    def test_literal(self, literal_round_trip):
-        literal_round_trip(TINYINT, [5], [5])
-
-    @testing.fixture
-    def integer_round_trip(self, metadata, connection):
-        def run(datatype, data):
-            int_table = Table(
-                "tiny_integer_table",
-                metadata,
-                Column(
-                    "id",
-                    TINYINT,
-                    primary_key=True,
-                    test_needs_autoincrement=False,
-                ),
-                Column("tiny_integer_data", datatype),
-            )
-
-            metadata.create_all(config.db)
-
-            connection.execute(int_table.insert(), {"id": 1, "integer_data": data})
-
-            row = connection.execute(select(int_table.c.integer_data)).first()
-
-            eq_(row, (data,))
-
-            assert isinstance(row[0], int)
-
-        return run
-
-
-class DateTimeTZTestCustom(_DateFixture, fixtures.TablesTest):
-    """This test confirms that when a user uses the TIMESTAMP
-    type to store a datetime object, it retains its timezone
-    """
-
-    __backend__ = True
-    datatype = TIMESTAMP
-    data = datetime.datetime(2012, 10, 15, 12, 57, 18, tzinfo=datetime.timezone.utc)
-
-    @testing.requires.datetime_implicit_bound
-    def test_select_direct(self, connection):
-
-        # We need to pass the TIMESTAMP type to the literal function
-        # so that the value is processed correctly.
-        result = connection.scalar(select(literal(self.data, TIMESTAMP)))
-        eq_(result, self.data)

databricks_sqlalchemy-2.0.2/src/databricks/sqlalchemy/test/_future.py

@@ -1,331 +0,0 @@
-# type: ignore
-
-from enum import Enum
-
-import pytest
-from databricks.sqlalchemy.test._regression import (
-    ExpandingBoundInTest,
-    IdentityAutoincrementTest,
-    LikeFunctionsTest,
-    NormalizedNameTest,
-)
-from databricks.sqlalchemy.test._unsupported import (
-    ComponentReflectionTest,
-    ComponentReflectionTestExtra,
-    CTETest,
-    InsertBehaviorTest,
-)
-from sqlalchemy.testing.suite import (
-    ArrayTest,
-    BinaryTest,
-    BizarroCharacterFKResolutionTest,
-    CollateTest,
-    ComputedColumnTest,
-    ComputedReflectionTest,
-    DifficultParametersTest,
-    FutureWeCanSetDefaultSchemaWEventsTest,
-    IdentityColumnTest,
-    IdentityReflectionTest,
-    JSONLegacyStringCastIndexTest,
-    JSONTest,
-    NativeUUIDTest,
-    QuotedNameArgumentTest,
-    RowCountTest,
-    SimpleUpdateDeleteTest,
-    WeCanSetDefaultSchemaWEventsTest,
-)
-
-
-class FutureFeature(Enum):
-    ARRAY = "ARRAY column type handling"
-    BINARY = "BINARY column type handling"
-    CHECK = "CHECK constraint handling"
-    COLLATE = "COLLATE DDL generation"
-    CTE_FEAT = "required CTE features"
-    EMPTY_INSERT = "empty INSERT support"
-    FK_OPTS = "foreign key option checking"
-    GENERATED_COLUMNS = "Delta computed / generated columns support"
-    IDENTITY = "identity reflection"
-    JSON = "JSON column type handling"
-    MULTI_PK = "get_multi_pk_constraint method"
-    PROVISION = "event-driven engine configuration"
-    REGEXP = "_visit_regexp"
-    SANE_ROWCOUNT = "sane_rowcount support"
-    TBL_OPTS = "get_table_options method"
-    TEST_DESIGN = "required test-fixture overrides"
-    TUPLE_LITERAL = "tuple-like IN markers completely"
-    UUID = "native Uuid() type"
-    VIEW_DEF = "get_view_definition method"
-
-
-def render_future_feature(rsn: FutureFeature, extra=False) -> str:
-    postfix = " More detail in _future.py" if extra else ""
-    return f"[FUTURE][{rsn.name}]: This dialect doesn't implement {rsn.value}.{postfix}"
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.BINARY))
-class BinaryTest(BinaryTest):
-    """Databricks doesn't support binding of BINARY type values. When DBR supports this, we can implement
-    in this dialect.
-    """
-
-    pass
-
-
-class ExpandingBoundInTest(ExpandingBoundInTest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL))
-    def test_empty_heterogeneous_tuples_bindparam(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL))
-    def test_empty_heterogeneous_tuples_direct(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL))
-    def test_empty_homogeneous_tuples_bindparam(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL))
-    def test_empty_homogeneous_tuples_direct(self):
-        pass
-
-
-class NormalizedNameTest(NormalizedNameTest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True))
-    def test_get_table_names(self):
-        """I'm not clear how this test can ever pass given that it's assertion looks like this:
-
-        ```python
-                eq_(tablenames[0].upper(), tablenames[0].lower())
-                eq_(tablenames[1].upper(), tablenames[1].lower())
-        ```
-
-        It's forcibly calling .upper() and .lower() on the same string and expecting them to be equal.
-        """
-        pass
-
-
-class CTETest(CTETest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.CTE_FEAT, True))
-    def test_delete_from_round_trip(self):
-        """Databricks dialect doesn't implement multiple-table criteria within DELETE"""
-        pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True))
-class IdentityColumnTest(IdentityColumnTest):
-    """Identity works. Test needs rewrite for Databricks. See comments in test_suite.py
-
-    The setup for these tests tries to create a table with a DELTA IDENTITY column but has two problems:
-    1. It uses an Integer() type for the column. Whereas DELTA IDENTITY columns must be BIGINT.
-    2. It tries to set the start == 42, which Databricks doesn't support
-
-    I can get the tests to _run_ by patching the table fixture to use BigInteger(). But it asserts that the
-    identity of two rows are 42 and 43, which is not possible since they will be rows 1 and 2 instead.
-
-    I'm satisified through manual testing that our implementation of visit_identity_column works but a better test is needed.
-    """
-
-    pass
-
-
-class IdentityAutoincrementTest(IdentityAutoincrementTest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True))
-    def test_autoincrement_with_identity(self):
-        """This test has the same issue as IdentityColumnTest.test_select_all in that it creates a table with identity
-        using an Integer() rather than a BigInteger(). If I override this behaviour to use a BigInteger() instead, the
-        test passes.
-        """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN))
-class BizarroCharacterFKResolutionTest(BizarroCharacterFKResolutionTest):
-    """Some of the combinations in this test pass. Others fail. Given the esoteric nature of these failures,
-    we have opted to defer implementing fixes to a later time, guided by customer feedback. Passage of
-    these tests is not an acceptance criteria for our dialect.
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN))
-class DifficultParametersTest(DifficultParametersTest):
-    """Some of the combinations in this test pass. Others fail. Given the esoteric nature of these failures,
-    we have opted to defer implementing fixes to a later time, guided by customer feedback. Passage of
-    these tests is not an acceptance criteria for our dialect.
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.IDENTITY, True))
-class IdentityReflectionTest(IdentityReflectionTest):
-    """It's not clear _how_ to implement this for SQLAlchemy. Columns created with GENERATED ALWAYS AS IDENTITY
-    are not specially demarked in the output of TGetColumnsResponse or DESCRIBE TABLE EXTENDED.
-
-    We could theoretically parse this from the contents of `SHOW CREATE TABLE` but that feels like a hack.
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.JSON))
-class JSONTest(JSONTest):
-    """Databricks supports JSON path expressions in queries it's just not implemented in this dialect."""
-
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.JSON))
-class JSONLegacyStringCastIndexTest(JSONLegacyStringCastIndexTest):
-    """Same comment applies as JSONTest"""
-
-    pass
-
-
-class LikeFunctionsTest(LikeFunctionsTest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.REGEXP))
-    def test_not_regexp_match(self):
-        """The defaul dialect doesn't implement _visit_regexp methods so we don't get them automatically."""
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.REGEXP))
-    def test_regexp_match(self):
-        """The defaul dialect doesn't implement _visit_regexp methods so we don't get them automatically."""
-        pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.COLLATE))
-class CollateTest(CollateTest):
-    """This is supported in Databricks. Not implemented here."""
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.UUID, True))
-class NativeUUIDTest(NativeUUIDTest):
-    """Type implementation will be straightforward. Since Databricks doesn't have a native UUID type we can use
-    a STRING field, create a custom TypeDecorator for sqlalchemy.types.Uuid and add it to the dialect's colspecs.
-
-    Then mark requirements.uuid_data_type as open() so this test can run.
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.SANE_ROWCOUNT))
-class RowCountTest(RowCountTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.SANE_ROWCOUNT))
-class SimpleUpdateDeleteTest(SimpleUpdateDeleteTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.PROVISION, True))
-class WeCanSetDefaultSchemaWEventsTest(WeCanSetDefaultSchemaWEventsTest):
-    """provision.py allows us to define event listeners that emit DDL for things like setting up a test schema
-    or, in this case, changing the default schema for the connection after it's been built. This would override
-    the schema defined in the sqlalchemy connection string. This support is possible but is not implemented
-    in the dialect. Deferred for now.
-    """
-
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.PROVISION, True))
-class FutureWeCanSetDefaultSchemaWEventsTest(FutureWeCanSetDefaultSchemaWEventsTest):
-    """provision.py allows us to define event listeners that emit DDL for things like setting up a test schema
-    or, in this case, changing the default schema for the connection after it's been built. This would override
-    the schema defined in the sqlalchemy connection string. This support is possible but is not implemented
-    in the dialect. Deferred for now.
-    """
-
-    pass
-
-
-class ComponentReflectionTest(ComponentReflectionTest):
-    @pytest.mark.skip(reason=render_future_feature(FutureFeature.TBL_OPTS, True))
-    def test_multi_get_table_options_tables(self):
-        """It's not clear what the expected ouput from this method would even _be_. Requires research."""
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.VIEW_DEF))
-    def test_get_view_definition(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.VIEW_DEF))
-    def test_get_view_definition_does_not_exist(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.MULTI_PK))
-    def test_get_multi_pk_constraint(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.CHECK))
-    def test_get_multi_check_constraints(self):
-        pass
-
-
-class ComponentReflectionTestExtra(ComponentReflectionTestExtra):
-    @pytest.mark.skip(render_future_feature(FutureFeature.CHECK))
-    def test_get_check_constraints(self):
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.FK_OPTS))
-    def test_get_foreign_key_options(self):
-        """It's not clear from the test code what the expected output is here. Further research required."""
-        pass
-
-
-class InsertBehaviorTest(InsertBehaviorTest):
-    @pytest.mark.skip(render_future_feature(FutureFeature.EMPTY_INSERT, True))
-    def test_empty_insert(self):
-        """Empty inserts are possible using DEFAULT VALUES on Databricks. To implement it, we need
-        to hook into the SQLCompiler to render a no-op column list. With SQLAlchemy's default implementation
-        the request fails with a syntax error
-        """
-        pass
-
-    @pytest.mark.skip(render_future_feature(FutureFeature.EMPTY_INSERT, True))
-    def test_empty_insert_multiple(self):
-        """Empty inserts are possible using DEFAULT VALUES on Databricks. To implement it, we need
-        to hook into the SQLCompiler to render a no-op column list. With SQLAlchemy's default implementation
-        the request fails with a syntax error
-        """
-        pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.ARRAY))
-class ArrayTest(ArrayTest):
-    """While Databricks supports ARRAY types, DBR cannot handle bound parameters of this type.
-    This makes them unusable to SQLAlchemy without some workaround. Potentially we could inline
-    the values of these parameters (which risks sql injection).
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True))
-class QuotedNameArgumentTest(QuotedNameArgumentTest):
-    """These tests are challenging. The whole test setup depends on a table with a name like `quote ' one`
-    which will never work on Databricks because table names can't contains spaces. But QuotedNamedArgumentTest
-    also checks the behaviour of DDL identifier preparation process. We need to override some of IdentifierPreparer
-    methods because these are the ultimate control for whether or not CHECK and UNIQUE constraints are emitted.
-    """
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_future_feature(FutureFeature.GENERATED_COLUMNS))
-class ComputedColumnTest(ComputedColumnTest):
-    pass
-
-
-@pytest.mark.reviewed
-@pytest.mark.skip(reason=render_future_feature(FutureFeature.GENERATED_COLUMNS))
-class ComputedReflectionTest(ComputedReflectionTest):
-    pass