crate 0.29.0__py2.py3-none-any.whl → 0.30.1__py2.py3-none-any.whl

crate/client/sqlalchemy/compiler.py

@@ -24,7 +24,7 @@ from collections import defaultdict
 
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql.base import PGCompiler
-from sqlalchemy.sql import compiler, crud, selectable
+from sqlalchemy.sql import compiler
 from .types import MutableDict, _Craty, Geopoint, Geoshape
 from .sa_version import SA_VERSION, SA_1_4
 
@@ -208,8 +208,6 @@ class CrateTypeCompiler(compiler.GenericTypeCompiler):
 
 class CrateCompiler(compiler.SQLCompiler):
 
-    prefetch = []
-
     def visit_getitem_binary(self, binary, operator, **kw):
         return "{0}['{1}']".format(
             self.process(binary.left, **kw),
@@ -223,486 +221,8 @@ class CrateCompiler(compiler.SQLCompiler):
             self.process(element.right, **kw)
         )
 
-    def returning_clause(self, stmt, returning_cols):
-        columns = [
-            self._label_select_column(None, c, True, False, {})
-            for c in sa.sql.expression._select_iterables(returning_cols)
-        ]
-        return "RETURNING " + ", ".join(columns)
-
-    def visit_update(self, update_stmt, **kw):
-        """
-        used to compile <sql.expression.Update> expressions
-        Parts are taken from the SQLCompiler base class.
-        """
-
-        if SA_VERSION >= SA_1_4:
-            return self.visit_update_14(update_stmt, **kw)
-
-        if not update_stmt.parameters and \
-                not hasattr(update_stmt, '_crate_specific'):
-            return super(CrateCompiler, self).visit_update(update_stmt, **kw)
-
-        self.isupdate = True
-
-        extra_froms = update_stmt._extra_froms
-
-        text = 'UPDATE '
-
-        if update_stmt._prefixes:
-            text += self._generate_prefixes(update_stmt,
-                                            update_stmt._prefixes, **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
-            )
-
-        # CrateDB patch.
-        crud_params = self._get_crud_params(update_stmt, **kw)
-
-        text += table_text
-
-        text += ' SET '
-
-        # CrateDB patch begin.
-        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
-            set_clauses.append(clause)
-
-        for k, v in update_stmt.parameters.items():
-            if isinstance(k, str) and '[' in k:
-                bindparam = sa.sql.bindparam(k, v)
-                set_clauses.append(k + ' = ' + self.process(bindparam))
-
-        text += ', '.join(set_clauses)
-        # 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)
-
-        if extra_froms:
-            extra_from_text = self.update_from_clause(
-                update_stmt,
-                update_stmt.table,
-                extra_froms,
-                dialect_hints,
-                **kw)
-            if extra_from_text:
-                text += " " + extra_from_text
-
-        if update_stmt._whereclause is not None:
-            t = self.process(update_stmt._whereclause)
-            if t:
-                text += " WHERE " + t
-
-        limit_clause = self.update_limit_clause(update_stmt)
-        if limit_clause:
-            text += " " + limit_clause
-
-        if self.returning and not self.returning_precedes_values:
-            text += " " + self.returning_clause(
-                update_stmt, self.returning)
-
-        return text
-
     def limit_clause(self, select, **kw):
         """
         Generate OFFSET / LIMIT clause, PostgreSQL-compatible.
         """
         return PGCompiler.limit_clause(self, select, **kw)
-
-    def _get_crud_params(compiler, stmt, **kw):
-        """ extract values from crud parameters
-        taken from SQLAlchemy's crud module (since 1.0.x) and
-        adapted for Crate dialect"""
-
-        compiler.postfetch = []
-        compiler.insert_prefetch = []
-        compiler.update_prefetch = []
-        compiler.returning = []
-
-        # no parameters in the statement, no parameters in the
-        # compiled params - return binds for all columns
-        if compiler.column_keys is None and stmt.parameters is None:
-            return [(c, crud._create_bind_param(compiler, c, None,
-                                                required=True))
-                    for c in stmt.table.columns]
-
-        if stmt._has_multi_parameters:
-            stmt_parameters = stmt.parameters[0]
-        else:
-            stmt_parameters = stmt.parameters
-
-        # getters - these are normally just column.key,
-        # but in the case of mysql multi-table update, the rules for
-        # .key must conditionally take tablename into account
-        _column_as_key, _getattr_col_key, _col_bind_name = \
-            crud._key_getters_for_crud_column(compiler, stmt)
-
-        # if we have statement parameters - set defaults in the
-        # compiled params
-        if compiler.column_keys is None:
-            parameters = {}
-        else:
-            parameters = dict((_column_as_key(key), crud.REQUIRED)
-                              for key in compiler.column_keys
-                              if not stmt_parameters or
-                              key not in stmt_parameters)
-
-        # create a list of column assignment clauses as tuples
-        values = []
-
-        if stmt_parameters is not None:
-            crud._get_stmt_parameters_params(
-                compiler,
-                parameters, stmt_parameters, _column_as_key, values, kw)
-
-        check_columns = {}
-
-        crud._scan_cols(compiler, stmt, parameters,
-                        _getattr_col_key, _column_as_key,
-                        _col_bind_name, check_columns, values, kw)
-
-        if stmt._has_multi_parameters:
-            values = crud._extend_values_for_multiparams(compiler, stmt,
-                                                         values, kw)
-
-        return values
-
-    def visit_update_14(self, update_stmt, **kw):
-
-        compile_state = update_stmt._compile_state_factory(
-            update_stmt, self, **kw
-        )
-        update_stmt = compile_state.statement
-
-        toplevel = not self.stack
-        if toplevel:
-            self.isupdate = True
-            if not self.compile_state:
-                self.compile_state = compile_state
-
-        extra_froms = compile_state._extra_froms
-        is_multitable = bool(extra_froms)
-
-        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
-            ]
-            correlate_froms = main_froms.union(extra_froms)
-        else:
-            render_extra_froms = []
-            correlate_froms = {update_stmt.table}
-
-        self.stack.append(
-            {
-                "correlate_froms": correlate_froms,
-                "asfrom_froms": correlate_froms,
-                "selectable": update_stmt,
-            }
-        )
-
-        text = "UPDATE "
-
-        if update_stmt._prefixes:
-            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
-        )
-
-        # CrateDB patch.
-        crud_params = _get_crud_params_14(
-            self, update_stmt, compile_state, **kw
-        )
-
-        if update_stmt._hints:
-            dialect_hints, table_text = self._setup_crud_hints(
-                update_stmt, table_text
-            )
-        else:
-            dialect_hints = None
-
-        if update_stmt._independent_ctes:
-            for cte in update_stmt._independent_ctes:
-                cte._compiler_dispatch(self, **kw)
-
-        text += table_text
-
-        text += " SET "
-
-        # CrateDB patch begin.
-        include_table = extra_froms and \
-            self.render_table_with_column_in_update_from
-
-        set_clauses = []
-
-        for c, expr, value in crud_params:
-            key = c._compiler_dispatch(self, include_table=include_table)
-            clause = key + ' = ' + value
-            set_clauses.append(clause)
-
-        for k, v in compile_state._dict_parameters.items():
-            if isinstance(k, str) and '[' in k:
-                bindparam = sa.sql.bindparam(k, v)
-                clause = k + ' = ' + self.process(bindparam)
-                set_clauses.append(clause)
-
-        text += ', '.join(set_clauses)
-        # CrateDB patch end.
-
-        if self.returning or update_stmt._returning:
-            if self.returning_precedes_values:
-                text += " " + self.returning_clause(
-                    update_stmt, self.returning or update_stmt._returning
-                )
-
-        if extra_froms:
-            extra_from_text = self.update_from_clause(
-                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
-            )
-            if t:
-                text += " WHERE " + t
-
-        limit_clause = self.update_limit_clause(update_stmt)
-        if limit_clause:
-            text += " " + limit_clause
-
-        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
-            )
-
-        if self.ctes:
-            nesting_level = len(self.stack) if not toplevel else None
-            text = self._render_cte_clause(nesting_level=nesting_level) + text
-
-        self.stack.pop(-1)
-
-        return text
-
-
-def _get_crud_params_14(compiler, stmt, compile_state, **kw):
-    """create a set of tuples representing column/string pairs for use
-    in an INSERT or UPDATE statement.
-
-    Also generates the Compiled object's postfetch, prefetch, and
-    returning column collections, used for default handling and ultimately
-    populating the CursorResult's prefetch_cols() and postfetch_cols()
-    collections.
-
-    """
-    from sqlalchemy.sql.crud import _key_getters_for_crud_column
-    from sqlalchemy.sql.crud import _create_bind_param
-    from sqlalchemy.sql.crud import REQUIRED
-    from sqlalchemy.sql.crud import _get_stmt_parameter_tuples_params
-    from sqlalchemy.sql.crud import _get_update_multitable_params
-    from sqlalchemy.sql.crud import _scan_insert_from_select_cols
-    from sqlalchemy.sql.crud import _scan_cols
-    from sqlalchemy import exc  # noqa: F401
-    from sqlalchemy.sql.crud import _extend_values_for_multiparams
-
-    compiler.postfetch = []
-    compiler.insert_prefetch = []
-    compiler.update_prefetch = []
-    compiler.returning = []
-
-    # getters - these are normally just column.key,
-    # but in the case of mysql multi-table update, the rules for
-    # .key must conditionally take tablename into account
-    (
-        _column_as_key,
-        _getattr_col_key,
-        _col_bind_name,
-    ) = getters = _key_getters_for_crud_column(compiler, stmt, compile_state)
-
-    compiler._key_getters_for_crud_column = getters
-
-    # no parameters in the statement, no parameters in the
-    # compiled params - return binds for all columns
-    if compiler.column_keys is None and compile_state._no_parameters:
-        return [
-            (
-                c,
-                compiler.preparer.format_column(c),
-                _create_bind_param(compiler, c, None, required=True),
-            )
-            for c in stmt.table.columns
-        ]
-
-    if compile_state._has_multi_parameters:
-        spd = compile_state._multi_parameters[0]
-        stmt_parameter_tuples = list(spd.items())
-    elif compile_state._ordered_values:
-        spd = compile_state._dict_parameters
-        stmt_parameter_tuples = compile_state._ordered_values
-    elif compile_state._dict_parameters:
-        spd = compile_state._dict_parameters
-        stmt_parameter_tuples = list(spd.items())
-    else:
-        stmt_parameter_tuples = spd = None
-
-    # if we have statement parameters - set defaults in the
-    # compiled params
-    if compiler.column_keys is None:
-        parameters = {}
-    elif stmt_parameter_tuples:
-        parameters = dict(
-            (_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
-        )
-
-    # create a list of column assignment clauses as tuples
-    values = []
-
-    if stmt_parameter_tuples is not None:
-        _get_stmt_parameter_tuples_params(
-            compiler,
-            compile_state,
-            parameters,
-            stmt_parameter_tuples,
-            _column_as_key,
-            values,
-            kw,
-        )
-
-    check_columns = {}
-
-    # special logic that only occurs for multi-table UPDATE
-    # statements
-    if compile_state.isupdate and compile_state.is_multitable:
-        _get_update_multitable_params(
-            compiler,
-            stmt,
-            compile_state,
-            stmt_parameter_tuples,
-            check_columns,
-            _col_bind_name,
-            _getattr_col_key,
-            values,
-            kw,
-        )
-
-    if compile_state.isinsert and stmt._select_names:
-        _scan_insert_from_select_cols(
-            compiler,
-            stmt,
-            compile_state,
-            parameters,
-            _getattr_col_key,
-            _column_as_key,
-            _col_bind_name,
-            check_columns,
-            values,
-            kw,
-        )
-    else:
-        _scan_cols(
-            compiler,
-            stmt,
-            compile_state,
-            parameters,
-            _getattr_col_key,
-            _column_as_key,
-            _col_bind_name,
-            check_columns,
-            values,
-            kw,
-        )
-
-    # CrateDB patch.
-    #
-    # This sanity check performed by SQLAlchemy currently needs to be
-    # deactivated in order to satisfy the rewriting logic of the CrateDB
-    # dialect in `rewrite_update` and `visit_update`.
-    #
-    # It can be quickly reproduced by activating this section and running the
-    # test cases::
-    #
-    #   ./bin/test -vvvv -t dict_test
-    #
-    # That croaks like::
-    #
-    #   sqlalchemy.exc.CompileError: Unconsumed column names: characters_name, data['nested']
-    #
-    # TODO: Investigate why this is actually happening and eventually mitigate
-    #       the root cause.
-    """
-    if parameters and stmt_parameter_tuples:
-        check = (
-            set(parameters)
-            .intersection(_column_as_key(k) for k, v in stmt_parameter_tuples)
-            .difference(check_columns)
-        )
-        if check:
-            raise exc.CompileError(
-                "Unconsumed column names: %s"
-                % (", ".join("%s" % (c,) for c in check))
-            )
-    """
-
-    if compile_state._has_multi_parameters:
-        values = _extend_values_for_multiparams(
-            compiler,
-            stmt,
-            compile_state,
-            values,
-            _column_as_key,
-            kw,
-        )
-    elif (
-        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
-        # into an in-place multi values.  This supports
-        # insert_executemany_returning mode :)
-        values = [
-            (
-                stmt.table.columns[0],
-                compiler.preparer.format_column(stmt.table.columns[0]),
-                "DEFAULT",
-            )
-        ]
-
-    return values

crate/client/sqlalchemy/dialect.py

@@ -28,11 +28,11 @@ from sqlalchemy.sql import functions
 from sqlalchemy.util import asbool, to_list
 
 from .compiler import (
-    CrateCompiler,
     CrateTypeCompiler,
     CrateDDLCompiler
 )
 from crate.client.exceptions import TimezoneUnawareException
+from .sa_version import SA_VERSION, SA_1_4, SA_2_0
 from .types import Object, ObjectArray
 
 TYPES_MAP = {
@@ -155,10 +155,21 @@ colspecs = {
 }
 
 
+if SA_VERSION >= SA_2_0:
+    from .compat.core20 import CrateCompilerSA20
+    statement_compiler = CrateCompilerSA20
+elif SA_VERSION >= SA_1_4:
+    from .compat.core14 import CrateCompilerSA14
+    statement_compiler = CrateCompilerSA14
+else:
+    from .compat.core10 import CrateCompilerSA10
+    statement_compiler = CrateCompilerSA10
+
+
 class CrateDialect(default.DefaultDialect):
     name = 'crate'
     driver = 'crate-python'
-    statement_compiler = CrateCompiler
+    statement_compiler = statement_compiler
     ddl_compiler = CrateDDLCompiler
     type_compiler = CrateTypeCompiler
     supports_native_boolean = True
@@ -208,19 +219,23 @@ class CrateDialect(default.DefaultDialect):
         return tuple(connection.connection.lowest_server_version.version)
 
     @classmethod
-    def dbapi(cls):
+    def import_dbapi(cls):
         from crate import client
         return client
 
-    def has_schema(self, connection, schema):
-        return schema in self.get_schema_names(connection)
+    @classmethod
+    def dbapi(cls):
+        return cls.import_dbapi()
+
+    def has_schema(self, connection, schema, **kw):
+        return schema in self.get_schema_names(connection, **kw)
 
-    def has_table(self, connection, table_name, schema=None):
-        return table_name in self.get_table_names(connection, schema=schema)
+    def has_table(self, connection, table_name, schema=None, **kw):
+        return table_name in self.get_table_names(connection, schema=schema, **kw)
 
     @reflection.cache
     def get_schema_names(self, connection, **kw):
-        cursor = connection.execute(
+        cursor = connection.exec_driver_sql(
             "select schema_name "
             "from information_schema.schemata "
             "order by schema_name asc"
@@ -229,21 +244,21 @@ class CrateDialect(default.DefaultDialect):
 
     @reflection.cache
     def get_table_names(self, connection, schema=None, **kw):
-        cursor = connection.execute(
+        cursor = connection.exec_driver_sql(
             "SELECT table_name FROM information_schema.tables "
             "WHERE {0} = ? "
             "AND table_type = 'BASE TABLE' "
             "ORDER BY table_name ASC, {0} ASC".format(self.schema_column),
-            [schema or self.default_schema_name]
+            (schema or self.default_schema_name, )
         )
         return [row[0] for row in cursor.fetchall()]
 
     @reflection.cache
     def get_view_names(self, connection, schema=None, **kw):
-        cursor = connection.execute(
+        cursor = connection.exec_driver_sql(
             "SELECT table_name FROM information_schema.views "
             "ORDER BY table_name ASC, {0} ASC".format(self.schema_column),
-            [schema or self.default_schema_name]
+            (schema or self.default_schema_name, )
         )
         return [row[0] for row in cursor.fetchall()]
 
@@ -254,11 +269,11 @@ class CrateDialect(default.DefaultDialect):
                 "WHERE table_name = ? AND {0} = ? " \
                 "AND column_name !~ ?" \
                 .format(self.schema_column)
-        cursor = connection.execute(
+        cursor = connection.exec_driver_sql(
             query,
-            [table_name,
+            (table_name,
              schema or self.default_schema_name,
-             r"(.*)\[\'(.*)\'\]"]  # regex to filter subscript
+             r"(.*)\[\'(.*)\'\]")  # regex to filter subscript
         )
         return [self._create_column_info(row) for row in cursor.fetchall()]
 
@@ -293,9 +308,9 @@ class CrateDialect(default.DefaultDialect):
                 rows = result.fetchone()
                 return set(rows[0] if rows else [])
 
-        pk_result = engine.execute(
+        pk_result = engine.exec_driver_sql(
             query,
-            [table_name, schema or self.default_schema_name]
+            (table_name, schema or self.default_schema_name)
         )
         pks = result_fun(pk_result)
         return {'constrained_columns': pks,

crate/client/sqlalchemy/sa_version.py

@@ -20,8 +20,9 @@
 # software solely pursuant to the terms of the relevant commercial agreement.
 
 import sqlalchemy as sa
-from distutils.version import StrictVersion as V
+from crate.client._pep440 import Version
 
-SA_VERSION = V(sa.__version__)
+SA_VERSION = Version(sa.__version__)
 
-SA_1_4 = V('1.4.0b1')
+SA_1_4 = Version('1.4.0b1')
+SA_2_0 = Version('2.0.0')

crate/client/sqlalchemy/tests/__init__.py

@@ -1,5 +1,14 @@
 # -*- coding: utf-8 -*-
 
+from ..compat.api13 import monkeypatch_amend_select_sa14, monkeypatch_add_connectionfairy_driver_connection
+from ..sa_version import SA_1_4, SA_VERSION
+
+# `sql.select()` of SQLAlchemy 1.3 uses old calling semantics,
+# but the test cases already need the modern ones.
+if SA_VERSION < SA_1_4:
+    monkeypatch_amend_select_sa14()
+    monkeypatch_add_connectionfairy_driver_connection()
+
 from unittest import TestSuite, makeSuite
 from .connection_test import SqlAlchemyConnectionTest
 from .dict_test import SqlAlchemyDictTypeTest
@@ -9,10 +18,11 @@ from .update_test import SqlAlchemyUpdateTest
 from .match_test import SqlAlchemyMatchTest
 from .bulk_test import SqlAlchemyBulkTest
 from .insert_from_select_test import SqlAlchemyInsertFromSelectTest
-from .create_table_test import CreateTableTest
+from .create_table_test import SqlAlchemyCreateTableTest
 from .array_test import SqlAlchemyArrayTypeTest
-from .dialect_test import DialectTest
-from .function_test import FunctionTest
+from .dialect_test import SqlAlchemyDialectTest
+from .function_test import SqlAlchemyFunctionTest
+from .warnings_test import SqlAlchemyWarningsTest
 
 
 def test_suite():
@@ -23,11 +33,12 @@ def test_suite():
     tests.addTest(makeSuite(SqlAlchemyCompilerTest))
     tests.addTest(makeSuite(SqlAlchemyUpdateTest))
     tests.addTest(makeSuite(SqlAlchemyMatchTest))
-    tests.addTest(makeSuite(CreateTableTest))
+    tests.addTest(makeSuite(SqlAlchemyCreateTableTest))
     tests.addTest(makeSuite(SqlAlchemyBulkTest))
     tests.addTest(makeSuite(SqlAlchemyInsertFromSelectTest))
     tests.addTest(makeSuite(SqlAlchemyInsertFromSelectTest))
-    tests.addTest(makeSuite(DialectTest))
-    tests.addTest(makeSuite(FunctionTest))
+    tests.addTest(makeSuite(SqlAlchemyDialectTest))
+    tests.addTest(makeSuite(SqlAlchemyFunctionTest))
     tests.addTest(makeSuite(SqlAlchemyArrayTypeTest))
+    tests.addTest(makeSuite(SqlAlchemyWarningsTest))
     return tests