sqlalchemy-cratedb 0.38.0.dev0__py3-none-any.whl → 0.40.0__py3-none-any.whl

sqlalchemy_cratedb/__init__.py

@@ -22,7 +22,7 @@
 from .compat.api13 import monkeypatch_add_exec_driver_sql
 from .dialect import dialect
 from .predicate import match
-from .sa_version import SA_1_4, SA_2_0, SA_VERSION
+from .sa_version import SA_1_4, SA_VERSION
 from .support import insert_bulk
 from .type.array import ObjectArray
 from .type.geo import Geopoint, Geoshape
@@ -34,7 +34,8 @@ if SA_VERSION < SA_1_4:
     import warnings
 
     # SQLAlchemy 1.3 is effectively EOL.
-    SA13_DEPRECATION_WARNING = textwrap.dedent("""
+    SA13_DEPRECATION_WARNING = textwrap.dedent(
+        """
     WARNING: SQLAlchemy 1.3 is effectively EOL.
 
     SQLAlchemy 1.3 is EOL since 2023-01-27.
@@ -43,8 +44,9 @@ if SA_VERSION < SA_1_4:
 
     - https://docs.sqlalchemy.org/en/14/changelog/migration_14.html
     - https://docs.sqlalchemy.org/en/20/changelog/migration_20.html
-    """.lstrip("\n"))
-    warnings.warn(message=SA13_DEPRECATION_WARNING, category=DeprecationWarning)
+    """.lstrip("\n")
+    )
+    warnings.warn(message=SA13_DEPRECATION_WARNING, category=DeprecationWarning, stacklevel=2)
 
     # SQLAlchemy 1.3 does not have the `exec_driver_sql` method, so add it.
     monkeypatch_add_exec_driver_sql()
@@ -59,4 +61,5 @@ __all__ = [
     ObjectType,
     match,
     knn_match,
+    insert_bulk,
 ]

sqlalchemy_cratedb/compat/api13.py

@@ -40,7 +40,6 @@ from sqlalchemy.sql import Select
 from sqlalchemy.sql import select as original_select
 from sqlalchemy.util import immutabledict
 
-
 # `_distill_params_20` copied from SA14's `sqlalchemy.engine.{base,util}`.
 _no_tuple = ()
 _no_kw = immutabledict()
@@ -52,9 +51,7 @@ def _distill_params_20(params):
     elif isinstance(params, list):
         # collections_abc.MutableSequence): # avoid abc.__instancecheck__
         if params and not isinstance(params[0], (collections_abc.Mapping, tuple)):
-            raise exc.ArgumentError(
-                "List argument must consist only of tuples or dictionaries"
-            )
+            raise exc.ArgumentError("List argument must consist only of tuples or dictionaries")
 
         return (params,), _no_kw
     elif isinstance(
@@ -74,8 +71,7 @@ def exec_driver_sql(self, statement, parameters=None, execution_options=None):
     """
     if execution_options is not None:
         raise ValueError(
-            "SA13 backward-compatibility: "
-            "`exec_driver_sql` does not support `execution_options`"
+            "SA13 backward-compatibility: " "`exec_driver_sql` does not support `execution_options`"
         )
     args_10style, kwargs_10style = _distill_params_20(parameters)
     return self.execute(statement, *args_10style, **kwargs_10style)
@@ -106,12 +102,11 @@ def select_sa14(*columns, **kw) -> Select:
     Derived from https://github.com/sqlalchemy/alembic/blob/b1fad6b6/alembic/util/sqla_compat.py#L557-L558
 
     sqlalchemy.exc.ArgumentError: columns argument to select() must be a Python list or other iterable
-    """
+    """  # noqa: E501
     if isinstance(columns, tuple) and isinstance(columns[0], list):
         if "whereclause" in kw:
             raise ValueError(
-                "SA13 backward-compatibility: "
-                "`whereclause` is both in kwargs and columns tuple"
+                "SA13 backward-compatibility: " "`whereclause` is both in kwargs and columns tuple"
             )
         columns, whereclause = columns
         kw["whereclause"] = whereclause
@@ -153,4 +148,5 @@ def connectionfairy_driver_connection_sa14(self):
 
 def monkeypatch_add_connectionfairy_driver_connection():
     import sqlalchemy.pool.base
+
     sqlalchemy.pool.base._ConnectionFairy.driver_connection = connectionfairy_driver_connection_sa14

sqlalchemy_cratedb/compat/core10.py

@@ -21,18 +21,21 @@
 
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql.base import PGCompiler
-from sqlalchemy.sql.crud import (REQUIRED, _create_bind_param,
-                                 _extend_values_for_multiparams,
-                                 _get_multitable_params,
-                                 _get_stmt_parameters_params,
-                                 _key_getters_for_crud_column, _scan_cols,
-                                 _scan_insert_from_select_cols)
+from sqlalchemy.sql.crud import (
+    REQUIRED,
+    _create_bind_param,
+    _extend_values_for_multiparams,
+    _get_multitable_params,
+    _get_stmt_parameters_params,
+    _key_getters_for_crud_column,
+    _scan_cols,
+    _scan_insert_from_select_cols,
+)
 
 from sqlalchemy_cratedb.compiler import CrateCompiler
 
 
 class CrateCompilerSA10(CrateCompiler):
-
     def returning_clause(self, stmt, returning_cols):
         """
         Generate RETURNING clause, PostgreSQL-compatible.
@@ -46,70 +49,58 @@ class CrateCompilerSA10(CrateCompiler):
         """
 
         # [10] CrateDB patch.
-        if not update_stmt.parameters and \
-                not hasattr(update_stmt, '_crate_specific'):
+        if not update_stmt.parameters and not hasattr(update_stmt, "_crate_specific"):
             return super().visit_update(update_stmt, **kw)
 
         self.isupdate = True
 
         extra_froms = update_stmt._extra_froms
 
-        text = 'UPDATE '
+        text = "UPDATE "
 
         if update_stmt._prefixes:
-            text += self._generate_prefixes(update_stmt,
-                                            update_stmt._prefixes, **kw)
+            text += self._generate_prefixes(update_stmt, update_stmt._prefixes, **kw)
 
-        table_text = self.update_tables_clause(update_stmt, update_stmt.table,
-                                               extra_froms, **kw)
+        table_text = self.update_tables_clause(update_stmt, update_stmt.table, extra_froms, **kw)
 
         dialect_hints = None
         if update_stmt._hints:
-            dialect_hints, table_text = self._setup_crud_hints(
-                update_stmt, table_text
-            )
+            dialect_hints, table_text = self._setup_crud_hints(update_stmt, table_text)
 
         # [10] CrateDB patch.
         crud_params = _get_crud_params(self, update_stmt, **kw)
 
         text += table_text
 
-        text += ' SET '
+        text += " SET "
 
         # [10] CrateDB patch begin.
-        include_table = \
-            extra_froms and self.render_table_with_column_in_update_from
+        include_table = extra_froms and self.render_table_with_column_in_update_from
 
         set_clauses = []
 
         for k, v in crud_params:
-            clause = k._compiler_dispatch(self,
-                                          include_table=include_table) + \
-                ' = ' + v
+            clause = k._compiler_dispatch(self, include_table=include_table) + " = " + v
             set_clauses.append(clause)
 
         for k, v in update_stmt.parameters.items():
-            if isinstance(k, str) and '[' in k:
+            if isinstance(k, str) and "[" in k:
                 bindparam = sa.sql.bindparam(k, v)
-                set_clauses.append(k + ' = ' + self.process(bindparam))
+                set_clauses.append(k + " = " + self.process(bindparam))
 
-        text += ', '.join(set_clauses)
+        text += ", ".join(set_clauses)
         # [10] CrateDB patch end.
 
         if self.returning or update_stmt._returning:
             if not self.returning:
                 self.returning = update_stmt._returning
             if self.returning_precedes_values:
-                text += " " + self.returning_clause(
-                    update_stmt, self.returning)
+                text += " " + self.returning_clause(update_stmt, self.returning)
 
         if extra_froms:
             extra_from_text = self.update_from_clause(
-                update_stmt,
-                update_stmt.table,
-                extra_froms,
-                dialect_hints,
-                **kw)
+                update_stmt, update_stmt.table, extra_froms, dialect_hints, **kw
+            )
             if extra_from_text:
                 text += " " + extra_from_text
 
@@ -123,8 +114,7 @@ class CrateCompilerSA10(CrateCompiler):
             text += " " + limit_clause
 
         if self.returning and not self.returning_precedes_values:
-            text += " " + self.returning_clause(
-                update_stmt, self.returning)
+            text += " " + self.returning_clause(update_stmt, self.returning)
 
         return text
 
@@ -149,8 +139,7 @@ def _get_crud_params(compiler, stmt, **kw):
     # compiled params - return binds for all columns
     if compiler.column_keys is None and stmt.parameters is None:
         return [
-            (c, _create_bind_param(compiler, c, None, required=True))
-            for c in stmt.table.columns
+            (c, _create_bind_param(compiler, c, None, required=True)) for c in stmt.table.columns
         ]
 
     if stmt._has_multi_parameters:

sqlalchemy_cratedb/compat/core14.py

@@ -22,18 +22,21 @@
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql.base import PGCompiler
 from sqlalchemy.sql import selectable
-from sqlalchemy.sql.crud import (REQUIRED, _create_bind_param,
-                                 _extend_values_for_multiparams,
-                                 _get_stmt_parameter_tuples_params,
-                                 _get_update_multitable_params,
-                                 _key_getters_for_crud_column, _scan_cols,
-                                 _scan_insert_from_select_cols)
+from sqlalchemy.sql.crud import (
+    REQUIRED,
+    _create_bind_param,
+    _extend_values_for_multiparams,
+    _get_stmt_parameter_tuples_params,
+    _get_update_multitable_params,
+    _key_getters_for_crud_column,
+    _scan_cols,
+    _scan_insert_from_select_cols,
+)
 
 from sqlalchemy_cratedb.compiler import CrateCompiler
 
 
 class CrateCompilerSA14(CrateCompiler):
-
     def returning_clause(self, stmt, returning_cols):
         """
         Generate RETURNING clause, PostgreSQL-compatible.
@@ -41,15 +44,11 @@ class CrateCompilerSA14(CrateCompiler):
         return PGCompiler.returning_clause(self, stmt, returning_cols)
 
     def visit_update(self, update_stmt, **kw):
-
-        compile_state = update_stmt._compile_state_factory(
-            update_stmt, self, **kw
-        )
+        compile_state = update_stmt._compile_state_factory(update_stmt, self, **kw)
         update_stmt = compile_state.statement
 
         # [14] CrateDB patch.
-        if not compile_state._dict_parameters and \
-                not hasattr(update_stmt, '_crate_specific'):
+        if not compile_state._dict_parameters and not hasattr(update_stmt, "_crate_specific"):
             return super().visit_update(update_stmt, **kw)
 
         toplevel = not self.stack
@@ -64,9 +63,7 @@ class CrateCompilerSA14(CrateCompiler):
         if is_multitable:
             # main table might be a JOIN
             main_froms = set(selectable._from_objects(update_stmt.table))
-            render_extra_froms = [
-                f for f in extra_froms if f not in main_froms
-            ]
+            render_extra_froms = [f for f in extra_froms if f not in main_froms]
             correlate_froms = main_froms.union(extra_froms)
         else:
             render_extra_froms = []
@@ -83,23 +80,17 @@ class CrateCompilerSA14(CrateCompiler):
         text = "UPDATE "
 
         if update_stmt._prefixes:
-            text += self._generate_prefixes(
-                update_stmt, update_stmt._prefixes, **kw
-            )
+            text += self._generate_prefixes(update_stmt, update_stmt._prefixes, **kw)
 
         table_text = self.update_tables_clause(
             update_stmt, update_stmt.table, render_extra_froms, **kw
         )
 
         # [14] CrateDB patch.
-        crud_params = _get_crud_params(
-            self, update_stmt, compile_state, **kw
-        )
+        crud_params = _get_crud_params(self, update_stmt, compile_state, **kw)
 
         if update_stmt._hints:
-            dialect_hints, table_text = self._setup_crud_hints(
-                update_stmt, table_text
-            )
+            dialect_hints, table_text = self._setup_crud_hints(update_stmt, table_text)
         else:
             dialect_hints = None
 
@@ -112,23 +103,22 @@ class CrateCompilerSA14(CrateCompiler):
         text += " SET "
 
         # [14] CrateDB patch begin.
-        include_table = \
-            extra_froms and self.render_table_with_column_in_update_from
+        include_table = extra_froms and self.render_table_with_column_in_update_from
 
         set_clauses = []
 
-        for c, expr, value in crud_params:
+        for c, expr, value in crud_params:  # noqa: B007
             key = c._compiler_dispatch(self, include_table=include_table)
-            clause = key + ' = ' + value
+            clause = key + " = " + value
             set_clauses.append(clause)
 
         for k, v in compile_state._dict_parameters.items():
-            if isinstance(k, str) and '[' in k:
+            if isinstance(k, str) and "[" in k:
                 bindparam = sa.sql.bindparam(k, v)
-                clause = k + ' = ' + self.process(bindparam)
+                clause = k + " = " + self.process(bindparam)
                 set_clauses.append(clause)
 
-        text += ', '.join(set_clauses)
+        text += ", ".join(set_clauses)
         # [14] CrateDB patch end.
 
         if self.returning or update_stmt._returning:
@@ -139,19 +129,13 @@ class CrateCompilerSA14(CrateCompiler):
 
         if extra_froms:
             extra_from_text = self.update_from_clause(
-                update_stmt,
-                update_stmt.table,
-                render_extra_froms,
-                dialect_hints,
-                **kw
+                update_stmt, update_stmt.table, render_extra_froms, dialect_hints, **kw
             )
             if extra_from_text:
                 text += " " + extra_from_text
 
         if update_stmt._where_criteria:
-            t = self._generate_delimited_and_list(
-                update_stmt._where_criteria, **kw
-            )
+            t = self._generate_delimited_and_list(update_stmt._where_criteria, **kw)
             if t:
                 text += " WHERE " + t
 
@@ -159,9 +143,7 @@ class CrateCompilerSA14(CrateCompiler):
         if limit_clause:
             text += " " + limit_clause
 
-        if (
-                self.returning or update_stmt._returning
-        ) and not self.returning_precedes_values:
+        if (self.returning or update_stmt._returning) and not self.returning_precedes_values:
             text += " " + self.returning_clause(
                 update_stmt, self.returning or update_stmt._returning
             )
@@ -232,14 +214,10 @@ def _get_crud_params(compiler, stmt, compile_state, **kw):
         parameters = {}
     elif stmt_parameter_tuples:
         parameters = dict(
-            (_column_as_key(key), REQUIRED)
-            for key in compiler.column_keys
-            if key not in spd
+            (_column_as_key(key), REQUIRED) for key in compiler.column_keys if key not in spd
         )
     else:
-        parameters = dict(
-            (_column_as_key(key), REQUIRED) for key in compiler.column_keys
-        )
+        parameters = dict((_column_as_key(key), REQUIRED) for key in compiler.column_keys)
 
     # create a list of column assignment clauses as tuples
     values = []
@@ -340,9 +318,9 @@ def _get_crud_params(compiler, stmt, compile_state, **kw):
             kw,
         )
     elif (
-            not values
-            and compiler.for_executemany  # noqa: W503
-            and compiler.dialect.supports_default_metavalue  # noqa: W503
+        not values
+        and compiler.for_executemany  # noqa: W503
+        and compiler.dialect.supports_default_metavalue  # noqa: W503
     ):
         # convert an "INSERT DEFAULT VALUES"
         # into INSERT (firstcol) VALUES (DEFAULT) which can be turned

sqlalchemy_cratedb/compat/core20.py

@@ -19,6 +19,8 @@
 # with Crate these terms will supersede the license and you may use the
 # software solely pursuant to the terms of the relevant commercial agreement.
 
+# ruff: noqa: S101 Use of `assert` detected
+
 from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union
 
 import sqlalchemy as sa
@@ -26,14 +28,20 @@ from sqlalchemy import ColumnClause, ValuesBase, cast, exc
 from sqlalchemy.sql import dml
 from sqlalchemy.sql.base import _from_objects
 from sqlalchemy.sql.compiler import SQLCompiler
-from sqlalchemy.sql.crud import (REQUIRED, _as_dml_column, _create_bind_param,
-                                 _CrudParamElement, _CrudParams,
-                                 _extend_values_for_multiparams,
-                                 _get_stmt_parameter_tuples_params,
-                                 _get_update_multitable_params,
-                                 _key_getters_for_crud_column, _scan_cols,
-                                 _scan_insert_from_select_cols,
-                                 _setup_delete_return_defaults)
+from sqlalchemy.sql.crud import (
+    REQUIRED,
+    _as_dml_column,
+    _create_bind_param,
+    _CrudParamElement,
+    _CrudParams,
+    _extend_values_for_multiparams,
+    _get_stmt_parameter_tuples_params,
+    _get_update_multitable_params,
+    _key_getters_for_crud_column,
+    _scan_cols,
+    _scan_insert_from_select_cols,
+    _setup_delete_return_defaults,
+)
 from sqlalchemy.sql.dml import DMLState, _DMLColumnElement
 from sqlalchemy.sql.dml import isinsert as _compile_state_isinsert
 
@@ -41,16 +49,12 @@ from sqlalchemy_cratedb.compiler import CrateCompiler
 
 
 class CrateCompilerSA20(CrateCompiler):
-
     def visit_update(self, update_stmt, **kw):
-        compile_state = update_stmt._compile_state_factory(
-            update_stmt, self, **kw
-        )
+        compile_state = update_stmt._compile_state_factory(update_stmt, self, **kw)
         update_stmt = compile_state.statement
 
         # [20] CrateDB patch.
-        if not compile_state._dict_parameters and \
-                not hasattr(update_stmt, '_crate_specific'):
+        if not compile_state._dict_parameters and not hasattr(update_stmt, "_crate_specific"):
             return super().visit_update(update_stmt, **kw)
 
         toplevel = not self.stack
@@ -67,9 +71,7 @@ class CrateCompilerSA20(CrateCompiler):
         if is_multitable:
             # main table might be a JOIN
             main_froms = set(_from_objects(update_stmt.table))
-            render_extra_froms = [
-                f for f in extra_froms if f not in main_froms
-            ]
+            render_extra_froms = [f for f in extra_froms if f not in main_froms]
             correlate_froms = main_froms.union(extra_froms)
         else:
             render_extra_froms = []
@@ -86,23 +88,17 @@ class CrateCompilerSA20(CrateCompiler):
         text = "UPDATE "
 
         if update_stmt._prefixes:
-            text += self._generate_prefixes(
-                update_stmt, update_stmt._prefixes, **kw
-            )
+            text += self._generate_prefixes(update_stmt, update_stmt._prefixes, **kw)
 
         table_text = self.update_tables_clause(
             update_stmt, update_stmt.table, render_extra_froms, **kw
         )
         # [20] CrateDB patch.
-        crud_params_struct = _get_crud_params(
-            self, update_stmt, compile_state, toplevel, **kw
-        )
+        crud_params_struct = _get_crud_params(self, update_stmt, compile_state, toplevel, **kw)
         crud_params = crud_params_struct.single_params
 
         if update_stmt._hints:
-            dialect_hints, table_text = self._setup_crud_hints(
-                update_stmt, table_text
-            )
+            dialect_hints, table_text = self._setup_crud_hints(update_stmt, table_text)
         else:
             dialect_hints = None
 
@@ -114,23 +110,22 @@ class CrateCompilerSA20(CrateCompiler):
         text += " SET "
 
         # [20] CrateDB patch begin.
-        include_table = extra_froms and \
-            self.render_table_with_column_in_update_from
+        include_table = extra_froms and self.render_table_with_column_in_update_from
 
         set_clauses = []
 
-        for c, expr, value, _ in crud_params:
+        for c, expr, value, _ in crud_params:  # noqa: B007
             key = c._compiler_dispatch(self, include_table=include_table)
-            clause = key + ' = ' + value
+            clause = key + " = " + value
             set_clauses.append(clause)
 
         for k, v in compile_state._dict_parameters.items():
-            if isinstance(k, str) and '[' in k:
+            if isinstance(k, str) and "[" in k:
                 bindparam = sa.sql.bindparam(k, v)
-                clause = k + ' = ' + self.process(bindparam)
+                clause = k + " = " + self.process(bindparam)
                 set_clauses.append(clause)
 
-        text += ', '.join(set_clauses)
+        text += ", ".join(set_clauses)
         # [20] CrateDB patch end.
 
         if self.implicit_returning or update_stmt._returning:
@@ -153,9 +148,7 @@ class CrateCompilerSA20(CrateCompiler):
                 text += " " + extra_from_text
 
         if update_stmt._where_criteria:
-            t = self._generate_delimited_and_list(
-                update_stmt._where_criteria, **kw
-            )
+            t = self._generate_delimited_and_list(update_stmt._where_criteria, **kw)
             if t:
                 text += " WHERE " + t
 
@@ -275,15 +268,10 @@ def _get_crud_params(
             [],
         )
 
-    stmt_parameter_tuples: Optional[
-        List[Tuple[Union[str, ColumnClause[Any]], Any]]
-    ]
+    stmt_parameter_tuples: Optional[List[Tuple[Union[str, ColumnClause[Any]], Any]]]
     spd: Optional[MutableMapping[_DMLColumnElement, Any]]
 
-    if (
-        _compile_state_isinsert(compile_state)
-        and compile_state._has_multi_parameters
-    ):
+    if _compile_state_isinsert(compile_state) and compile_state._has_multi_parameters:
         mp = compile_state._multi_parameters
         assert mp is not None
         spd = mp[0]
@@ -304,14 +292,10 @@ def _get_crud_params(
     elif stmt_parameter_tuples:
         assert spd is not None
         parameters = {
-            _column_as_key(key): REQUIRED
-            for key in compiler.column_keys
-            if key not in spd
+            _column_as_key(key): REQUIRED for key in compiler.column_keys if key not in spd
         }
     else:
-        parameters = {
-            _column_as_key(key): REQUIRED for key in compiler.column_keys
-        }
+        parameters = {_column_as_key(key): REQUIRED for key in compiler.column_keys}
 
     # create a list of column assignment clauses as tuples
     values: List[_CrudParamElement] = []
@@ -408,10 +392,7 @@ def _get_crud_params(
             )
     """
 
-    if (
-        _compile_state_isinsert(compile_state)
-        and compile_state._has_multi_parameters
-    ):
+    if _compile_state_isinsert(compile_state) and compile_state._has_multi_parameters:
         # is a multiparams, is not an insert from a select
         assert not stmt._select_names
         multi_extended_values = _extend_values_for_multiparams(
@@ -426,11 +407,7 @@ def _get_crud_params(
             kw,
         )
         return _CrudParams(values, multi_extended_values)
-    elif (
-        not values
-        and compiler.for_executemany
-        and compiler.dialect.supports_default_metavalue
-    ):
+    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