sqlalchemy-cratedb 0.41.0.dev2__py3-none-any.whl → 0.42.0.dev1__py3-none-any.whl

sqlalchemy_cratedb/__init__.py

@@ -52,7 +52,22 @@ if SA_VERSION < SA_1_4:
     monkeypatch_add_exec_driver_sql()
 
 
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except (ImportError, ModuleNotFoundError):  # pragma:nocover
+    from importlib_metadata import (  # type: ignore[assignment,no-redef,unused-ignore]
+        PackageNotFoundError,
+        version,
+    )
+
+try:
+    __version__ = version("sqlalchemy-cratedb")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+
+
 __all__ = [
+    __version__,
     dialect,
     FloatVector,
     Geopoint,

sqlalchemy_cratedb/compat/core14.py

@@ -317,11 +317,7 @@ def _get_crud_params(compiler, stmt, compile_state, **kw):
             _column_as_key,
             kw,
         )
-    elif (
-        not values
-        and compiler.for_executemany  # noqa: W503
-        and compiler.dialect.supports_default_metavalue  # noqa: W503
-    ):
+    elif not values and compiler.for_executemany and compiler.dialect.supports_default_metavalue:
         # convert an "INSERT DEFAULT VALUES"
         # into INSERT (firstcol) VALUES (DEFAULT) which can be turned
         # into an in-place multi values.  This supports

sqlalchemy_cratedb/compiler.py

@@ -200,6 +200,17 @@ class CrateDDLCompiler(compiler.DDLCompiler):
         )
         return
 
+    def visit_create_index(self, create, **kw) -> str:
+        """
+        CrateDB does not support `CREATE INDEX` statements.
+        """
+        warnings.warn(
+            "CrateDB does not support `CREATE INDEX` statements, "
+            "they will be omitted when generating DDL statements.",
+            stacklevel=2,
+        )
+        return "SELECT 1"
+
 
 class CrateTypeCompiler(compiler.GenericTypeCompiler):
     def visit_string(self, type_, **kw):
@@ -254,6 +265,36 @@ class CrateTypeCompiler(compiler.GenericTypeCompiler):
         """
         return "TIMESTAMP %s" % ((type_.timezone and "WITH" or "WITHOUT") + " TIME ZONE",)
 
+    def visit_BLOB(self, type_, **kw):
+        return "STRING"
+
+    def visit_FLOAT(self, type_, **kw):
+        """
+        From `sqlalchemy.sql.sqltypes.Float`.
+
+        When a :paramref:`.Float.precision` is not provided in a
+        :class:`_types.Float` type some backend may compile this type as
+        an 8 bytes / 64 bit float datatype. To use a 4 bytes / 32 bit float
+        datatype a precision <= 24 can usually be provided or the
+        :class:`_types.REAL` type can be used.
+        This is known to be the case in the PostgreSQL and MSSQL dialects
+        that render the type as ``FLOAT`` that's in both an alias of
+        ``DOUBLE PRECISION``. Other third party dialects may have similar
+        behavior.
+        """
+        if not type_.precision:
+            return "FLOAT"
+        elif type_.precision <= 24:
+            return "FLOAT"
+        else:
+            return "DOUBLE"
+
+    def visit_JSON(self, type_, **kw):
+        return "OBJECT"
+
+    def visit_JSONB(self, type_, **kw):
+        return "OBJECT"
+
 
 class CrateCompiler(compiler.SQLCompiler):
     def visit_getitem_binary(self, binary, operator, **kw):

sqlalchemy_cratedb/dialect.py

@@ -34,46 +34,60 @@ from .compiler import (
 )
 from .sa_version import SA_1_4, SA_2_0, SA_VERSION
 from .type import FloatVector, ObjectArray, ObjectType
+from .type.binary import LargeBinary
 
+# For SQLAlchemy >= 1.1.
 TYPES_MAP = {
-    "boolean": sqltypes.Boolean,
-    "short": sqltypes.SmallInteger,
-    "smallint": sqltypes.SmallInteger,
-    "timestamp": sqltypes.TIMESTAMP(timezone=False),
-    "timestamp with time zone": sqltypes.TIMESTAMP(timezone=True),
+    "boolean": sqltypes.BOOLEAN,
+    "short": sqltypes.SMALLINT,
+    "smallint": sqltypes.SMALLINT,
+    "timestamp": sqltypes.TIMESTAMP,
+    "timestamp with time zone": sqltypes.TIMESTAMP(timezone=False),
+    "timestamp without time zone": sqltypes.TIMESTAMP(timezone=True),
     "object": ObjectType,
-    "integer": sqltypes.Integer,
-    "long": sqltypes.NUMERIC,
-    "bigint": sqltypes.NUMERIC,
+    "object_array": ObjectArray,  # TODO: Can this also be improved to use `sqltypes.ARRAY`?
+    "integer": sqltypes.INTEGER,
+    "long": sqltypes.BIGINT,
+    "bigint": sqltypes.BIGINT,
+    "float": sqltypes.FLOAT,
     "double": sqltypes.DECIMAL,
     "double precision": sqltypes.DECIMAL,
-    "object_array": ObjectArray,
-    "float": sqltypes.Float,
-    "real": sqltypes.Float,
-    "string": sqltypes.String,
-    "text": sqltypes.String,
+    "real": sqltypes.REAL,
+    "string": sqltypes.VARCHAR,
+    "text": sqltypes.VARCHAR,
     "float_vector": FloatVector,
 }
 
-# Needed for SQLAlchemy >= 1.1.
-# TODO: Dissolve.
+# For SQLAlchemy >= 1.4.
 try:
     from sqlalchemy.types import ARRAY
 
-    TYPES_MAP["integer_array"] = ARRAY(sqltypes.Integer)
-    TYPES_MAP["boolean_array"] = ARRAY(sqltypes.Boolean)
-    TYPES_MAP["short_array"] = ARRAY(sqltypes.SmallInteger)
-    TYPES_MAP["smallint_array"] = ARRAY(sqltypes.SmallInteger)
+    TYPES_MAP["integer_array"] = ARRAY(sqltypes.INTEGER)
+    TYPES_MAP["boolean_array"] = ARRAY(sqltypes.BOOLEAN)
+    TYPES_MAP["short_array"] = ARRAY(sqltypes.SMALLINT)
+    TYPES_MAP["smallint_array"] = ARRAY(sqltypes.SMALLINT)
+    TYPES_MAP["timestamp_array"] = ARRAY(sqltypes.TIMESTAMP)
     TYPES_MAP["timestamp_array"] = ARRAY(sqltypes.TIMESTAMP(timezone=False))
     TYPES_MAP["timestamp with time zone_array"] = ARRAY(sqltypes.TIMESTAMP(timezone=True))
-    TYPES_MAP["long_array"] = ARRAY(sqltypes.NUMERIC)
-    TYPES_MAP["bigint_array"] = ARRAY(sqltypes.NUMERIC)
-    TYPES_MAP["double_array"] = ARRAY(sqltypes.DECIMAL)
-    TYPES_MAP["double precision_array"] = ARRAY(sqltypes.DECIMAL)
-    TYPES_MAP["float_array"] = ARRAY(sqltypes.Float)
-    TYPES_MAP["real_array"] = ARRAY(sqltypes.Float)
-    TYPES_MAP["string_array"] = ARRAY(sqltypes.String)
-    TYPES_MAP["text_array"] = ARRAY(sqltypes.String)
+    TYPES_MAP["long_array"] = ARRAY(sqltypes.BIGINT)
+    TYPES_MAP["bigint_array"] = ARRAY(sqltypes.BIGINT)
+    TYPES_MAP["float_array"] = ARRAY(sqltypes.FLOAT)
+    TYPES_MAP["real_array"] = ARRAY(sqltypes.REAL)
+    TYPES_MAP["string_array"] = ARRAY(sqltypes.VARCHAR)
+    TYPES_MAP["text_array"] = ARRAY(sqltypes.VARCHAR)
+except Exception:  # noqa: S110
+    pass
+
+# For SQLAlchemy >= 2.0.
+try:
+    from sqlalchemy.types import DOUBLE, DOUBLE_PRECISION
+
+    TYPES_MAP["real"] = DOUBLE
+    TYPES_MAP["real_array"] = ARRAY(DOUBLE)
+    TYPES_MAP["double"] = DOUBLE
+    TYPES_MAP["double_array"] = ARRAY(DOUBLE)
+    TYPES_MAP["double precision"] = DOUBLE_PRECISION
+    TYPES_MAP["double precision_array"] = ARRAY(DOUBLE_PRECISION)
 except Exception:  # noqa: S110
     pass
 
@@ -158,6 +172,7 @@ colspecs = {
     sqltypes.Date: Date,
     sqltypes.DateTime: DateTime,
     sqltypes.TIMESTAMP: DateTime,
+    sqltypes.LargeBinary: LargeBinary,
 }
 
 
@@ -206,6 +221,15 @@ class CrateDialect(default.DefaultDialect):
         # start with _. Adding it here causes sqlalchemy to quote such columns.
         self.identifier_preparer.illegal_initial_characters.add("_")
 
+    def get_isolation_level_values(self, dbapi_conn):
+        return ()
+
+    def set_isolation_level(self, dbapi_connection, level):
+        pass
+
+    def get_isolation_level(self, dbapi_connection):
+        return "NONE"
+
     def initialize(self, connection):
         # get lowest server version
         self.server_version_info = self._get_server_version_info(connection)
@@ -228,8 +252,12 @@ class CrateDialect(default.DefaultDialect):
         servers = to_list(server)
         if servers:
             use_ssl = asbool(kwargs.pop("ssl", False))
-            if use_ssl:
+            # TODO: Switch to the canonical default `sslmode=prefer` later.
+            sslmode = kwargs.pop("sslmode", "disable")
+            if use_ssl or sslmode in ["allow", "prefer", "require", "verify-ca", "verify-full"]:
                 servers = ["https://" + server for server in servers]
+            if sslmode == "require":
+                kwargs["verify_ssl_cert"] = False
             return self.dbapi.connect(servers=servers, **kwargs)
         return self.dbapi.connect(**kwargs)
 

sqlalchemy_cratedb/type/__init__.py

@@ -1,4 +1,5 @@
 from .array import ObjectArray
+from .binary import LargeBinary
 from .geo import Geopoint, Geoshape
 from .object import ObjectType
 from .vector import FloatVector, knn_match
@@ -6,6 +7,7 @@ from .vector import FloatVector, knn_match
 __all__ = [
     Geopoint,
     Geoshape,
+    LargeBinary,
     ObjectArray,
     ObjectType,
     FloatVector,

sqlalchemy_cratedb/type/array.py

@@ -96,6 +96,8 @@ class Any(expression.ColumnElement):
         self.operator = operator
 
 
+# TODO: Should this be inherited from PostgreSQL's
+#       `ARRAY`, in order to improve type checking?
 class _ObjectArray(sqltypes.UserDefinedType):
     cache_ok = True
 
@@ -139,5 +141,8 @@ class _ObjectArray(sqltypes.UserDefinedType):
     def get_col_spec(self, **kws):
         return "ARRAY(OBJECT)"
 
+    def as_generic(self, **kwargs):
+        return sqltypes.ARRAY
+
 
 ObjectArray = MutableList.as_mutable(_ObjectArray)

sqlalchemy_cratedb/type/binary.py

@@ -0,0 +1,44 @@
+import base64
+
+import sqlalchemy as sa
+
+
+class LargeBinary(sa.String):
+    """A type for large binary byte data.
+
+    The :class:`.LargeBinary` type corresponds to a large and/or unlengthed
+    binary type for the target platform, such as BLOB on MySQL and BYTEA for
+    PostgreSQL.  It also handles the necessary conversions for the DBAPI.
+
+    """
+
+    __visit_name__ = "large_binary"
+
+    def bind_processor(self, dialect):
+        if dialect.dbapi is None:
+            return None
+
+        # TODO: DBAPIBinary = dialect.dbapi.Binary
+
+        def process(value):
+            if value is not None:
+                # TODO: return DBAPIBinary(value)
+                return base64.b64encode(value).decode()
+            else:
+                return None
+
+        return process
+
+    # Python 3 has native bytes() type
+    # both sqlite3 and pg8000 seem to return it,
+    # psycopg2 as of 2.5 returns 'memoryview'
+    def result_processor(self, dialect, coltype):
+        if dialect.returns_native_bytes:
+            return None
+
+        def process(value):
+            if value is not None:
+                return base64.b64decode(value)
+            return value
+
+        return process

{sqlalchemy_cratedb-0.41.0.dev2.dist-info → sqlalchemy_cratedb-0.42.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sqlalchemy-cratedb
-Version: 0.41.0.dev2
+Version: 0.42.0.dev1
 Summary: SQLAlchemy dialect for CrateDB.
 Author-email: "Crate.io" <office@crate.io>
 License: Apache License 2.0
@@ -64,19 +64,20 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: backports.zoneinfo<1; python_version < "3.9"
-Requires-Dist: crate<3,>=2.0.0.dev6
+Requires-Dist: crate<3,>=2
 Requires-Dist: geojson<4,>=2.5
+Requires-Dist: importlib-metadata; python_version < "3.8"
 Requires-Dist: importlib-resources; python_version < "3.9"
 Requires-Dist: sqlalchemy<2.1,>=1
-Requires-Dist: verlib2==0.2
+Requires-Dist: verlib2<0.4
 Provides-Extra: all
 Requires-Dist: sqlalchemy-cratedb[vector]; extra == "all"
 Provides-Extra: develop
-Requires-Dist: mypy<1.15; extra == "develop"
-Requires-Dist: poethepoet<0.33; extra == "develop"
-Requires-Dist: pyproject-fmt<2.6; extra == "develop"
-Requires-Dist: ruff<0.10; extra == "develop"
-Requires-Dist: validate-pyproject<0.24; extra == "develop"
+Requires-Dist: mypy<1.16; extra == "develop"
+Requires-Dist: poethepoet<1; extra == "develop"
+Requires-Dist: pyproject-fmt<3; extra == "develop"
+Requires-Dist: ruff<0.12; extra == "develop"
+Requires-Dist: validate-pyproject<1; extra == "develop"
 Provides-Extra: doc
 Requires-Dist: crate-docs-theme>=0.26.5; extra == "doc"
 Requires-Dist: sphinx<9,>=3.5; extra == "doc"
@@ -85,14 +86,15 @@ Requires-Dist: build<2; extra == "release"
 Requires-Dist: twine<7; extra == "release"
 Provides-Extra: test
 Requires-Dist: cratedb-toolkit[testing]; extra == "test"
-Requires-Dist: dask[dataframe]; python_version < "3.13" and extra == "test"
-Requires-Dist: pandas<2.3; extra == "test"
+Requires-Dist: dask[dataframe]; extra == "test"
+Requires-Dist: pandas[test]<2.3; extra == "test"
 Requires-Dist: pueblo>=0.0.7; extra == "test"
 Requires-Dist: pytest<9; extra == "test"
 Requires-Dist: pytest-cov<7; extra == "test"
 Requires-Dist: pytest-mock<4; extra == "test"
 Provides-Extra: vector
 Requires-Dist: numpy; extra == "vector"
+Dynamic: license-file
 
 # SQLAlchemy dialect for CrateDB
 

{sqlalchemy_cratedb-0.41.0.dev2.dist-info → sqlalchemy_cratedb-0.42.0.dev1.dist-info}/RECORD

@@ -1,26 +1,27 @@
-sqlalchemy_cratedb/__init__.py,sha256=1W1uYA3Ax7HJTQatj6UulvPEmetUICEx_S7C2bmp76Q,2326
-sqlalchemy_cratedb/compiler.py,sha256=obD3DivOzy6i-ewMZz2Qaj9I8J7EkPPhFTAESqvtNsA,13144
-sqlalchemy_cratedb/dialect.py,sha256=YEp5bYO6rfKM8rSXddaF40J0iz4bH6RurkBmly4tUpo,15037
+sqlalchemy_cratedb/__init__.py,sha256=G_VAyHNGzbjlqWNrxTz6cM_gfKPOQZtQxR8MGzCsfFQ,2748
+sqlalchemy_cratedb/compiler.py,sha256=hbjQDOj3LCBxNeiLJu_a0b9b7LOTRdVl9pHmTjmAFjM,14535
+sqlalchemy_cratedb/dialect.py,sha256=Rm7gAqXlzKovrSipHxytJ-gAyALYp5CwX7PIn3VXw7g,16067
 sqlalchemy_cratedb/predicate.py,sha256=mUIHwGv9tuNmN_BqRD5LC5Ll3Lxpb4WI_muZqbP6HRs,3568
 sqlalchemy_cratedb/sa_version.py,sha256=sQtmUQEJcguJRRSlbkVpYcdEzPduA-sUHtmOtWSH8qI,1168
 sqlalchemy_cratedb/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlalchemy_cratedb/compat/api13.py,sha256=cWgQxPuc47tOjWb4wvCAMBrOsrT9xJJffZqmdfyJA24,5619
 sqlalchemy_cratedb/compat/core10.py,sha256=VDugi9u4wr5tSoxyD8C9kPmxXgtik0avNPUPnSmP4DI,8191
-sqlalchemy_cratedb/compat/core14.py,sha256=qtL1UfvT7aZK2TafNi5KiXA1b0nO84PgoBMI0FgnXos,11144
+sqlalchemy_cratedb/compat/core14.py,sha256=cIqt6fSqWNvnOkeoBAO9A-Cmx6ijzxN4S9hY87xltZo,11084
 sqlalchemy_cratedb/compat/core20.py,sha256=bKeAqSZH0qyK3Mj6qpj8x8IG2hcchVsGUvPW9xS7z_I,14675
 sqlalchemy_cratedb/support/__init__.py,sha256=zPXmiW2M5-yLZFfKZX78mZiL0T5MzD0IhUNEoRs9NuY,507
 sqlalchemy_cratedb/support/pandas.py,sha256=yt5re_PmiwEv7nMK1A2xIufXbmxUjWXP_06pH3V2qyg,4397
 sqlalchemy_cratedb/support/polyfill.py,sha256=yyqlXBvb6FfWpA3ChDF8XoiCImHsMD8NknZe4gTfvI0,5009
 sqlalchemy_cratedb/support/util.py,sha256=HjZpOy8uTqkMwUrFYsL3JEDgjmAVSqk4zYMJAyNhpEE,2442
-sqlalchemy_cratedb/type/__init__.py,sha256=qT3s2Dt83BPp0ZXCv5e1vHod7MKzDjVzSSV8Pcnl9JM,249
-sqlalchemy_cratedb/type/array.py,sha256=N5tl_XrrTVhMOqHeDt0q4M0VOcQC_DSAkF3NlGDsXlc,4339
+sqlalchemy_cratedb/type/__init__.py,sha256=v9-2k_Nl1TJjm6L_iZZIFhPQbOQPp9yFbKMNg9IHdIc,298
+sqlalchemy_cratedb/type/array.py,sha256=m8zSmkVbVolp7xgENxsd9cpfokHdnw1nOQbV6_VaxW4,4509
+sqlalchemy_cratedb/type/binary.py,sha256=9LjMYmyxwE1G_HJcTmUQ9CVxuvIAc9SbZlGv--NQi7M,1185
 sqlalchemy_cratedb/type/geo.py,sha256=8Z81m8wtpb0TBdSy_3v5FeXd0MTGZD3LxVguf9PzCZA,1160
 sqlalchemy_cratedb/type/object.py,sha256=aAkmr55RYZUbJ2MVUDV1-5eQ7kKuATVy6oy2OFqmibU,3015
 sqlalchemy_cratedb/type/vector.py,sha256=g8_C-ObDWEBoGz7u5QdljDCRWYNSRVafCAsmWJSxXiE,4746
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/LICENSE,sha256=s_w3FXmAYQuatqsgvyYLnGyC_13KOqp3W1DUEXO9RpY,10175
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/METADATA,sha256=sRuNMYA5RucWhqZl01MDqpxVWGTgGYk086a4MfJNN94,6589
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/NOTICE,sha256=yU9CWOf_XrVU7fpqGgM9tDjppoMyfHHBmFVMiINZk-k,1167
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/entry_points.txt,sha256=c14wyCG3OeM64_DUbI_vLVUXR3e3GhDyO_PCjo6UQMU,57
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/top_level.txt,sha256=UjjXz0burl_-2MApzLzffHG_2RXm6KljZvoGJHISMPo,19
-sqlalchemy_cratedb-0.41.0.dev2.dist-info/RECORD,,
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/licenses/LICENSE,sha256=s_w3FXmAYQuatqsgvyYLnGyC_13KOqp3W1DUEXO9RpY,10175
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/licenses/NOTICE,sha256=yU9CWOf_XrVU7fpqGgM9tDjppoMyfHHBmFVMiINZk-k,1167
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/METADATA,sha256=Lx2wMVucDppNkGBh_WzI5VhafUVV-ImbWY77GnYoxsI,6629
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/entry_points.txt,sha256=c14wyCG3OeM64_DUbI_vLVUXR3e3GhDyO_PCjo6UQMU,57
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/top_level.txt,sha256=UjjXz0burl_-2MApzLzffHG_2RXm6KljZvoGJHISMPo,19
+sqlalchemy_cratedb-0.42.0.dev1.dist-info/RECORD,,

{sqlalchemy_cratedb-0.41.0.dev2.dist-info → sqlalchemy_cratedb-0.42.0.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any