sqlalchemy-spanner 1.6.2__tar.gz → 1.7.0__tar.gz

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/PKG-INFO

@@ -1,13 +1,19 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-spanner
-Version: 1.6.2
+Version: 1.7.0
 Summary: SQLAlchemy dialect integrated into Cloud Spanner database
 Home-page: https://github.com/cloudspannerecosystem/python-spanner-sqlalchemy
 Author: Google LLC
 Author-email: cloud-spanner-developers@googlegroups.com
 Classifier: Intended Audience :: Developers
-Provides-Extra: tracing
 License-File: LICENSE
+Requires-Dist: sqlalchemy>=1.1.13
+Requires-Dist: google-cloud-spanner>=3.12.0
+Requires-Dist: alembic
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.1.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk>=1.1.0; extra == "tracing"
+Requires-Dist: opentelemetry-instrumentation>=0.20b0; extra == "tracing"
 
 Spanner dialect for SQLAlchemy
 ==============================

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/google/cloud/sqlalchemy_spanner/_opentelemetry_tracing.py

@@ -14,6 +14,9 @@
 
 """Manages OpenTelemetry trace creation and handling"""
 
+import collections
+import os
+
 from contextlib import contextmanager
 
 from google.api_core.exceptions import GoogleAPICallError
@@ -46,6 +49,16 @@ def trace_call(name, extra_attributes=None):
     }
 
     if extra_attributes:
+        if os.environ.get("SQLALCHEMY_SPANNER_TRACE_HIDE_QUERY_PARAMETERS"):
+            extra_attributes.pop("db.params", None)
+
+        # Stringify "db.params" sequence values before sending to OpenTelemetry,
+        # otherwise OpenTelemetry may log a Warning if types differ.
+        if isinstance(extra_attributes, dict):
+            for k, v in extra_attributes.items():
+                if k == "db.params" and isinstance(v, collections.abc.Sequence):
+                    extra_attributes[k] = [str(e) for e in v]
+
         attributes.update(extra_attributes)
 
     with tracer.start_as_current_span(

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/google/cloud/sqlalchemy_spanner/requirements.py

@@ -81,7 +81,7 @@ class Requirements(SuiteRequirements):  # pragma: no cover
 
     @property
     def sequences(self):
-        return exclusions.closed()
+        return exclusions.open()
 
     @property
     def temporary_tables(self):

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/google/cloud/sqlalchemy_spanner/sqlalchemy_spanner.py

@@ -23,6 +23,7 @@ from alembic.ddl.base import (
     format_type,
 )
 from sqlalchemy.exc import NoSuchTableError
+from sqlalchemy.sql import elements
 from sqlalchemy import ForeignKeyConstraint, types
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.engine.default import DefaultDialect, DefaultExecutionContext
@@ -40,6 +41,7 @@ from sqlalchemy.sql.compiler import (
 )
 from sqlalchemy.sql.default_comparator import operator_lookup
 from sqlalchemy.sql.operators import json_getitem_op
+from sqlalchemy.sql import expression
 
 from google.cloud.spanner_v1.data_types import JsonObject
 from google.cloud import spanner_dbapi
@@ -173,6 +175,16 @@ class SpannerExecutionContext(DefaultExecutionContext):
         if priority is not None:
             self._dbapi_connection.connection.request_priority = priority
 
+    def fire_sequence(self, seq, type_):
+        """Builds a statement for fetching next value of the sequence."""
+        return self._execute_scalar(
+            (
+                "SELECT GET_NEXT_SEQUENCE_VALUE(SEQUENCE %s)"
+                % self.identifier_preparer.format_sequence(seq)
+            ),
+            type_,
+        )
+
 
 class SpannerIdentifierPreparer(IdentifierPreparer):
     """Identifiers compiler.
@@ -303,8 +315,14 @@ class SpannerSQLCompiler(SQLCompiler):
         in string. Override the method to add  additional escape before using it to
         generate a SQL statement.
         """
+        if value is None and not type_.should_evaluate_none:
+            # issue #10535 - handle NULL in the compiler without placing
+            # this onto each type, except for "evaluate None" types
+            # (e.g. JSON)
+            return self.process(elements.Null._instance())
+
         raw = ["\\", "'", '"', "\n", "\t", "\r"]
-        if type(value) == str and any(single in value for single in raw):
+        if isinstance(value, str) and any(single in value for single in raw):
             value = 'r"""{}"""'.format(value)
             return value
         else:
@@ -343,6 +361,20 @@ class SpannerSQLCompiler(SQLCompiler):
             text += " OFFSET " + self.process(select._offset_clause, **kw)
         return text
 
+    def returning_clause(self, stmt, returning_cols, **kw):
+        columns = [
+            self._label_select_column(None, c, True, False, {})
+            for c in expression._select_iterables(returning_cols)
+        ]
+
+        return "THEN RETURN " + ", ".join(columns)
+
+    def visit_sequence(self, seq, **kw):
+        """Builds a statement for fetching next value of the sequence."""
+        return " GET_NEXT_SEQUENCE_VALUE(SEQUENCE %s)" % self.preparer.format_sequence(
+            seq
+        )
+
 
 class SpannerDDLCompiler(DDLCompiler):
     """Spanner DDL statements compiler."""
@@ -406,7 +438,7 @@ class SpannerDDLCompiler(DDLCompiler):
         for index in drop_table.element.indexes:
             indexes += "DROP INDEX {};".format(self.preparer.quote(index.name))
 
-        return indexes + constrs + str(drop_table)
+        return indexes + constrs + super().visit_drop_table(drop_table)
 
     def visit_primary_key_constraint(self, constraint, **kw):
         """Build primary key definition.
@@ -457,6 +489,24 @@ class SpannerDDLCompiler(DDLCompiler):
 
         return post_cmds
 
+    def get_identity_options(self, identity_options):
+        text = ["sequence_kind = 'bit_reversed_positive'"]
+        if identity_options.start is not None:
+            text.append("start_with_counter = %d" % identity_options.start)
+        return ", ".join(text)
+
+    def visit_create_sequence(self, create, prefix=None, **kw):
+        """Builds a ``CREATE SEQUENCE`` statement for the sequence."""
+        text = "CREATE SEQUENCE %s" % self.preparer.format_sequence(create.element)
+        options = self.get_identity_options(create.element)
+        if options:
+            text += " OPTIONS (" + options + ")"
+        return text
+
+    def visit_drop_sequence(self, drop, **kw):
+        """Builds a ``DROP SEQUENCE`` statement for the sequence."""
+        return "DROP SEQUENCE %s" % self.preparer.format_sequence(drop.element)
+
 
 class SpannerTypeCompiler(GenericTypeCompiler):
     """Spanner types compiler.
@@ -531,7 +581,8 @@ class SpannerDialect(DefaultDialect):
     supports_sane_rowcount = False
     supports_sane_multi_rowcount = False
     supports_default_values = False
-    supports_sequences = False
+    supports_sequences = True
+    sequences_optional = False
     supports_native_enum = True
     supports_native_boolean = True
     supports_native_decimal = True
@@ -694,6 +745,36 @@ class SpannerDialect(DefaultDialect):
 
         return all_views
 
+    @engine_to_connection
+    def get_sequence_names(self, connection, schema=None, **kw):
+        """
+        Return a list of all sequence names available in the database.
+
+        The method is used by SQLAlchemy introspection systems.
+
+        Args:
+            connection (sqlalchemy.engine.base.Connection):
+                SQLAlchemy connection or engine object.
+            schema (str): Optional. Schema name
+
+        Returns:
+            list: List of sequence names.
+        """
+        sql = """
+            SELECT name
+            FROM information_schema.sequences
+            WHERE SCHEMA='{}'
+            """.format(
+            schema or ""
+        )
+        all_sequences = []
+        with connection.connection.database.snapshot() as snap:
+            rows = list(snap.execute_sql(sql))
+            for seq in rows:
+                all_sequences.append(seq[0])
+
+        return all_sequences
+
     @engine_to_connection
     def get_view_definition(self, connection, view_name, schema=None, **kw):
         """
@@ -765,7 +846,7 @@ class SpannerDialect(DefaultDialect):
                 col.spanner_type, col.is_nullable, col.generation_expression
             FROM information_schema.columns as col
             JOIN information_schema.tables AS t
-                ON col.table_name = t.table_name
+                USING (TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME)
             WHERE
                 {table_filter_query}
                 {table_type_query}
@@ -898,9 +979,14 @@ class SpannerDialect(DefaultDialect):
                ARRAY_AGG(ic.column_ordering)
             FROM information_schema.indexes as i
             JOIN information_schema.index_columns AS ic
-                ON ic.index_name = i.index_name AND ic.table_name = i.table_name
+                ON  ic.index_name = i.index_name
+                AND ic.table_catalog = i.table_catalog
+                AND ic.table_schema = i.table_schema
+                AND ic.table_name = i.table_name
             JOIN information_schema.tables AS t
-                ON i.table_name = t.table_name
+                ON  i.table_catalog = t.table_catalog
+                AND i.table_schema = t.table_schema
+                AND i.table_name = t.table_name
             WHERE
                 {table_filter_query}
                 {table_type_query}
@@ -995,9 +1081,11 @@ class SpannerDialect(DefaultDialect):
             SELECT tc.table_schema, tc.table_name, ccu.COLUMN_NAME
             FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS tc
             JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu
-                ON ccu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+                USING (TABLE_CATALOG, TABLE_SCHEMA, CONSTRAINT_NAME)
             JOIN information_schema.tables AS t
-                ON tc.table_name = t.table_name
+                ON  tc.TABLE_CATALOG = t.TABLE_CATALOG
+                AND tc.TABLE_SCHEMA = t.TABLE_SCHEMA
+                AND tc.TABLE_NAME = t.TABLE_NAME
             WHERE {table_filter_query} {table_type_query}
             {schema_filter_query} tc.CONSTRAINT_TYPE = "PRIMARY KEY"
         """.format(
@@ -1115,13 +1203,19 @@ class SpannerDialect(DefaultDialect):
             )
             FROM information_schema.table_constraints AS tc
             JOIN information_schema.constraint_column_usage AS ccu
-                ON ccu.constraint_name = tc.constraint_name
+                USING (table_catalog, table_schema, constraint_name)
             JOIN information_schema.constraint_table_usage AS ctu
-                ON ctu.constraint_name = tc.constraint_name
+                ON ctu.table_catalog = tc.table_catalog
+                and ctu.table_schema = tc.table_schema
+                and ctu.constraint_name = tc.constraint_name
             JOIN information_schema.key_column_usage AS kcu
-                ON kcu.constraint_name = tc.constraint_name
+                ON kcu.table_catalog = tc.table_catalog
+                and kcu.table_schema = tc.table_schema
+                and kcu.constraint_name = tc.constraint_name
             JOIN information_schema.tables AS t
-                ON tc.table_name = t.table_name
+                ON t.table_catalog = tc.table_catalog
+                and t.table_schema = tc.table_schema
+                and t.table_name = tc.table_name
             WHERE
                 {table_filter_query}
                 {table_type_query}
@@ -1242,15 +1336,14 @@ WHERE table_type = 'BASE TABLE' AND table_schema = '{schema}'
 SELECT ccu.CONSTRAINT_NAME, ccu.COLUMN_NAME
 FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS tc
 JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu
-    ON ccu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
-LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-    on tc.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+    USING (TABLE_CATALOG, TABLE_SCHEMA, CONSTRAINT_NAME)
 WHERE
     tc.TABLE_NAME="{table_name}"
+    AND tc.TABLE_SCHEMA="{table_schema}"
     AND tc.CONSTRAINT_TYPE = "UNIQUE"
-    AND rc.CONSTRAINT_NAME IS NOT NULL
+    AND tc.CONSTRAINT_NAME IS NOT NULL
 """.format(
-            table_name=table_name
+            table_schema=schema or "", table_name=table_name
         )
 
         cols = []
@@ -1282,10 +1375,37 @@ WHERE
                 """
 SELECT true
 FROM INFORMATION_SCHEMA.TABLES
-WHERE TABLE_NAME="{table_name}"
+WHERE TABLE_SCHEMA="{table_schema}" AND TABLE_NAME="{table_name}"
 LIMIT 1
 """.format(
-                    table_name=table_name
+                    table_schema=schema or "", table_name=table_name
+                )
+            )
+
+            for _ in rows:
+                return True
+
+        return False
+
+    @engine_to_connection
+    def has_sequence(self, connection, sequence_name, schema=None, **kw):
+        """Check the existence of a particular sequence in the database.
+
+        Given a :class:`_engine.Connection` object and a string
+        `sequence_name`, return True if the given sequence exists in
+        the database, False otherwise.
+        """
+
+        with connection.connection.database.snapshot() as snap:
+            rows = snap.execute_sql(
+                """
+                SELECT true
+                FROM INFORMATION_SCHEMA.SEQUENCES
+                WHERE NAME="{sequence_name}"
+                AND SCHEMA="{schema}"
+                LIMIT 1
+                """.format(
+                    sequence_name=sequence_name, schema=schema or ""
                 )
             )
 

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/sqlalchemy_spanner.egg-info/PKG-INFO

@@ -1,13 +1,19 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-spanner
-Version: 1.6.2
+Version: 1.7.0
 Summary: SQLAlchemy dialect integrated into Cloud Spanner database
 Home-page: https://github.com/cloudspannerecosystem/python-spanner-sqlalchemy
 Author: Google LLC
 Author-email: cloud-spanner-developers@googlegroups.com
 Classifier: Intended Audience :: Developers
-Provides-Extra: tracing
 License-File: LICENSE
+Requires-Dist: sqlalchemy>=1.1.13
+Requires-Dist: google-cloud-spanner>=3.12.0
+Requires-Dist: alembic
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.1.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk>=1.1.0; extra == "tracing"
+Requires-Dist: opentelemetry-instrumentation>=0.20b0; extra == "tracing"
 
 Spanner dialect for SQLAlchemy
 ==============================

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/test/test_suite_13.py

@@ -37,6 +37,7 @@ from sqlalchemy.schema import Computed
 from sqlalchemy.testing import config
 from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
+from sqlalchemy.testing import is_instance_of
 from sqlalchemy.testing import provide_metadata, emits_warning
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_true
@@ -73,7 +74,10 @@ from sqlalchemy.testing.suite.test_insert import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_reflection import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_results import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_select import *  # noqa: F401, F403
-from sqlalchemy.testing.suite.test_sequence import *  # noqa: F401, F403
+from sqlalchemy.testing.suite.test_sequence import (
+    SequenceTest as _SequenceTest,
+    HasSequenceTest as _HasSequenceTest,
+)  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_update_delete import *  # noqa: F401, F403
 
 from sqlalchemy.testing.suite.test_cte import CTETest as _CTETest
@@ -2059,3 +2063,124 @@ class CreateEngineWithoutDatabaseTest(fixtures.TestBase):
         engine = create_engine(get_db_url().split("/database")[0])
         with engine.connect() as connection:
             assert connection.connection.database is None
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class SequenceTest(_SequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "seq_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_opt_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq_opt", data_type=Integer, optional=True),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_no_returning",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("noret_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+            implicit_returning=False,
+        )
+
+    def test_insert_lastrowid(self, connection):
+        r = connection.execute(self.tables.seq_pk.insert(), dict(data="some data"))
+        assert len(r.inserted_primary_key) == 1
+        is_instance_of(r.inserted_primary_key[0], int)
+
+    def test_nextval_direct(self, connection):
+        r = connection.execute(self.tables.seq_pk.c.id.default)
+        is_instance_of(r, int)
+
+    def _assert_round_trip(self, table, conn):
+        row = conn.execute(table.select()).first()
+        id, name = row
+        is_instance_of(id, int)
+        eq_(name, "some data")
+
+    @testing.combinations((True,), (False,), argnames="implicit_returning")
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_insert_roundtrip_translate(self, connection, implicit_returning):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_nextval_direct_schema_translate(self, connection):
+        pass
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class HasSequenceTest(_HasSequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        sqlalchemy.Sequence("user_id_seq", metadata=metadata)
+        sqlalchemy.Sequence(
+            "other_seq", metadata=metadata, nomaxvalue=True, nominvalue=True
+        )
+        Table(
+            "user_id_table",
+            metadata,
+            Column("id", Integer, primary_key=True),
+        )
+
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_cache(self, connection, metadata):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_schemas_neg(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_default_not_in_remote(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_remote_not_in_default(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_get_sequence_names_no_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_get_sequence_names_sequences_schema(self, connection):
+        pass

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/test/test_suite_14.py

@@ -37,6 +37,7 @@ from sqlalchemy.schema import Computed
 from sqlalchemy.testing import config
 from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
+from sqlalchemy.testing import is_instance_of
 from sqlalchemy.testing import provide_metadata, emits_warning
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.provision import temp_table_keyword_args
@@ -76,7 +77,11 @@ from sqlalchemy.testing.suite.test_insert import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_reflection import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_results import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_select import *  # noqa: F401, F403
-from sqlalchemy.testing.suite.test_sequence import *  # noqa: F401, F403
+from sqlalchemy.testing.suite.test_sequence import (
+    SequenceTest as _SequenceTest,
+    HasSequenceTest as _HasSequenceTest,
+    HasSequenceTestEmpty as _HasSequenceTestEmpty,
+)  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_update_delete import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_cte import CTETest as _CTETest
 from sqlalchemy.testing.suite.test_ddl import TableDDLTest as _TableDDLTest
@@ -2392,3 +2397,128 @@ class CreateEngineWithoutDatabaseTest(fixtures.TestBase):
         engine = create_engine(get_db_url().split("/database")[0])
         with engine.connect() as connection:
             assert connection.connection.database is None
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class SequenceTest(_SequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "seq_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_opt_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq_opt", data_type=Integer, optional=True),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_no_returning",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("noret_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+            implicit_returning=False,
+        )
+
+    def test_insert_lastrowid(self, connection):
+        r = connection.execute(self.tables.seq_pk.insert(), dict(data="some data"))
+        assert len(r.inserted_primary_key) == 1
+        is_instance_of(r.inserted_primary_key[0], int)
+
+    def test_nextval_direct(self, connection):
+        r = connection.execute(self.tables.seq_pk.c.id.default)
+        is_instance_of(r, int)
+
+    def _assert_round_trip(self, table, conn):
+        row = conn.execute(table.select()).first()
+        id, name = row
+        is_instance_of(id, int)
+        eq_(name, "some data")
+
+    @testing.combinations((True,), (False,), argnames="implicit_returning")
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_insert_roundtrip_translate(self, connection, implicit_returning):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_nextval_direct_schema_translate(self, connection):
+        pass
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class HasSequenceTest(_HasSequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        sqlalchemy.Sequence("user_id_seq", metadata=metadata)
+        sqlalchemy.Sequence(
+            "other_seq", metadata=metadata, nomaxvalue=True, nominvalue=True
+        )
+        Table(
+            "user_id_table",
+            metadata,
+            Column("id", Integer, primary_key=True),
+        )
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_has_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_has_sequence_schemas_neg(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_has_sequence_default_not_in_remote(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_has_sequence_remote_not_in_default(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_get_sequence_names_no_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Spanner doesn't support user defined schemas")
+    def test_get_sequence_names_sequences_schema(self, connection):
+        pass
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class HasSequenceTestEmpty(_HasSequenceTestEmpty):
+    def test_get_sequence_names_no_sequence(self, connection):
+        super().test_get_sequence_names_no_sequence(connection)

{sqlalchemy-spanner-1.6.2 → sqlalchemy_spanner-1.7.0}/test/test_suite_20.py

@@ -39,6 +39,7 @@ from sqlalchemy.schema import Computed
 from sqlalchemy.testing import config
 from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
+from sqlalchemy.testing import is_instance_of
 from sqlalchemy.testing import provide_metadata, emits_warning
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.provision import temp_table_keyword_args
@@ -80,7 +81,11 @@ from sqlalchemy.testing.suite.test_reflection import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_deprecations import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_results import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_select import *  # noqa: F401, F403
-from sqlalchemy.testing.suite.test_sequence import *  # noqa: F401, F403
+from sqlalchemy.testing.suite.test_sequence import (
+    SequenceTest as _SequenceTest,
+    HasSequenceTest as _HasSequenceTest,
+    HasSequenceTestEmpty as _HasSequenceTestEmpty,
+)  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_unicode_ddl import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_update_delete import *  # noqa: F401, F403
 from sqlalchemy.testing.suite.test_cte import CTETest as _CTETest
@@ -144,7 +149,10 @@ from sqlalchemy.testing.suite.test_types import (  # noqa: F401, F403
     UnicodeTextTest as _UnicodeTextTest,
     _UnicodeFixture as __UnicodeFixture,
 )  # noqa: F401, F403
-from test._helpers import get_db_url, get_project
+from test._helpers import (
+    get_db_url,
+    get_project,
+)
 
 config.test_schema = ""
 
@@ -157,7 +165,7 @@ class BooleanTest(_BooleanTest):
     def test_render_literal_bool(self):
         pass
 
-    def test_render_literal_bool_true(self, literal_round_trip):
+    def test_render_literal_bool_true(self, literal_round_trip_spanner):
         """
         SPANNER OVERRIDE:
 
@@ -166,9 +174,9 @@ class BooleanTest(_BooleanTest):
         following insertions will fail with `Row [] already exists".
         Overriding the test to avoid the same failure.
         """
-        literal_round_trip(Boolean(), [True], [True])
+        literal_round_trip_spanner(Boolean(), [True], [True])
 
-    def test_render_literal_bool_false(self, literal_round_trip):
+    def test_render_literal_bool_false(self, literal_round_trip_spanner):
         """
         SPANNER OVERRIDE:
 
@@ -177,7 +185,7 @@ class BooleanTest(_BooleanTest):
         following insertions will fail with `Row [] already exists".
         Overriding the test to avoid the same failure.
         """
-        literal_round_trip(Boolean(), [False], [False])
+        literal_round_trip_spanner(Boolean(), [False], [False])
 
     @pytest.mark.skip("Not supported by Cloud Spanner")
     def test_whereclause(self):
@@ -1998,6 +2006,9 @@ class IntegerTest(_IntegerTest):
             intvalue,
         )
 
+    def test_literal(self, literal_round_trip_spanner):
+        literal_round_trip_spanner(Integer, [5], [5])
+
 
 class _UnicodeFixture(__UnicodeFixture):
     @classmethod
@@ -2111,6 +2122,10 @@ class InsertBehaviorTest(_InsertBehaviorTest):
     def test_insert_from_select_autoinc(self):
         pass
 
+    @pytest.mark.skip("Spanner does not support auto increment")
+    def test_no_results_for_non_returning_insert(self, connection, style, executemany):
+        pass
+
     def test_autoclose_on_insert(self):
         """
         SPANNER OVERRIDE:
@@ -2180,6 +2195,19 @@ class StringTest(_StringTest):
                 args[1],
             )
 
+    def test_literal(self, literal_round_trip_spanner):
+        # note that in Python 3, this invokes the Unicode
+        # datatype for the literal part because all strings are unicode
+        literal_round_trip_spanner(String(40), ["some text"], ["some text"])
+
+    def test_literal_quoting(self, literal_round_trip_spanner):
+        data = """some 'text' hey "hi there" that's text"""
+        literal_round_trip_spanner(String(40), [data], [data])
+
+    def test_literal_backslashes(self, literal_round_trip_spanner):
+        data = r"backslash one \ backslash two \\ end"
+        literal_round_trip_spanner(String(40), [data], [data])
+
 
 class TextTest(_TextTest):
     @classmethod
@@ -2215,6 +2243,21 @@ class TextTest(_TextTest):
     def test_text_null_strings(self, connection):
         pass
 
+    def test_literal(self, literal_round_trip_spanner):
+        literal_round_trip_spanner(Text, ["some text"], ["some text"])
+
+    def test_literal_quoting(self, literal_round_trip_spanner):
+        data = """some 'text' hey "hi there" that's text"""
+        literal_round_trip_spanner(Text, [data], [data])
+
+    def test_literal_backslashes(self, literal_round_trip_spanner):
+        data = r"backslash one \ backslash two \\ end"
+        literal_round_trip_spanner(Text, [data], [data])
+
+    def test_literal_percentsigns(self, literal_round_trip_spanner):
+        data = r"percent % signs %% percent"
+        literal_round_trip_spanner(Text, [data], [data])
+
 
 class NumericTest(_NumericTest):
     @testing.fixture
@@ -2245,7 +2288,7 @@ class NumericTest(_NumericTest):
         return run
 
     @emits_warning(r".*does \*not\* support Decimal objects natively")
-    def test_render_literal_numeric(self, literal_round_trip):
+    def test_render_literal_numeric(self, literal_round_trip_spanner):
         """
         SPANNER OVERRIDE:
 
@@ -2254,14 +2297,14 @@ class NumericTest(_NumericTest):
         following insertions will fail with `Row [] already exists".
         Overriding the test to avoid the same failure.
         """
-        literal_round_trip(
+        literal_round_trip_spanner(
             Numeric(precision=8, scale=4),
             [decimal.Decimal("15.7563")],
             [decimal.Decimal("15.7563")],
         )
 
     @emits_warning(r".*does \*not\* support Decimal objects natively")
-    def test_render_literal_numeric_asfloat(self, literal_round_trip):
+    def test_render_literal_numeric_asfloat(self, literal_round_trip_spanner):
         """
         SPANNER OVERRIDE:
 
@@ -2270,13 +2313,13 @@ class NumericTest(_NumericTest):
         following insertions will fail with `Row [] already exists".
         Overriding the test to avoid the same failure.
         """
-        literal_round_trip(
+        literal_round_trip_spanner(
             Numeric(precision=8, scale=4, asdecimal=False),
             [decimal.Decimal("15.7563")],
             [15.7563],
         )
 
-    def test_render_literal_float(self, literal_round_trip):
+    def test_render_literal_float(self, literal_round_trip_spanner):
         """
         SPANNER OVERRIDE:
 
@@ -2285,7 +2328,7 @@ class NumericTest(_NumericTest):
         following insertions will fail with `Row [] already exists".
         Overriding the test to avoid the same failure.
         """
-        literal_round_trip(
+        literal_round_trip_spanner(
             Float(4),
             [decimal.Decimal("15.7563")],
             [15.7563],
@@ -2495,6 +2538,17 @@ class IsOrIsNotDistinctFromTest(_IsOrIsNotDistinctFromTest):
     pass
 
 
+@pytest.mark.skip("Spanner doesn't bizarre characters in foreign key names")
+class BizarroCharacterFKResolutionTest(fixtures.TestBase):
+    pass
+
+
+class IsolationLevelTest(fixtures.TestBase):
+    @pytest.mark.skip("Cloud Spanner does not support different isolation levels")
+    def test_dialect_user_setting_is_restored(self, testing_engine):
+        pass
+
+
 class OrderByLabelTest(_OrderByLabelTest):
     @pytest.mark.skip(
         "Spanner requires an alias for the GROUP BY list when specifying derived "
@@ -3041,3 +3095,132 @@ class CreateEngineWithoutDatabaseTest(fixtures.TestBase):
         engine = create_engine(get_db_url().split("/database")[0])
         with engine.connect() as connection:
             assert connection.connection.database is None
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class SequenceTest(_SequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "seq_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_opt_pk",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("tab_id_seq_opt", data_type=Integer, optional=True),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+        )
+
+        Table(
+            "seq_no_returning",
+            metadata,
+            Column(
+                "id",
+                Integer,
+                sqlalchemy.Sequence("noret_id_seq"),
+                primary_key=True,
+            ),
+            Column("data", String(50)),
+            implicit_returning=False,
+        )
+
+    def test_insert_lastrowid(self, connection):
+        r = connection.execute(self.tables.seq_pk.insert(), dict(data="some data"))
+        assert len(r.inserted_primary_key) == 1
+        is_instance_of(r.inserted_primary_key[0], int)
+
+    def test_nextval_direct(self, connection):
+        r = connection.execute(self.tables.seq_pk.c.id.default)
+        is_instance_of(r, int)
+
+    def _assert_round_trip(self, table, conn):
+        row = conn.execute(table.select()).first()
+        id, name = row
+        is_instance_of(id, int)
+        eq_(name, "some data")
+
+    @testing.combinations((True,), (False,), argnames="implicit_returning")
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_insert_roundtrip_translate(self, connection, implicit_returning):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_nextval_direct_schema_translate(self, connection):
+        pass
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class HasSequenceTest(_HasSequenceTest):
+    @classmethod
+    def define_tables(cls, metadata):
+        sqlalchemy.Sequence("user_id_seq", metadata=metadata)
+        sqlalchemy.Sequence(
+            "other_seq", metadata=metadata, nomaxvalue=True, nominvalue=True
+        )
+        Table(
+            "user_id_table",
+            metadata,
+            Column("id", Integer, primary_key=True),
+        )
+
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_cache(self, connection, metadata):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_schemas_neg(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_default_not_in_remote(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_has_sequence_remote_not_in_default(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_get_sequence_names_no_sequence_schema(self, connection):
+        pass
+
+    @testing.requires.schemas
+    @pytest.mark.skip("Not supported by Cloud Spanner")
+    def test_get_sequence_names_sequences_schema(self, connection):
+        pass
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("SPANNER_EMULATOR_HOST")), reason="Skipped on emulator"
+)
+class HasSequenceTestEmpty(_HasSequenceTestEmpty):
+    def test_get_sequence_names_no_sequence(self, connection):
+        super().test_get_sequence_names_no_sequence(connection)