google-cloud-spanner 3.53.0__tar.gz → 3.54.0__tar.gz

{google_cloud_spanner-3.53.0/google_cloud_spanner.egg-info → google_cloud_spanner-3.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-spanner
-Version: 3.53.0
+Version: 3.54.0
 Summary: Google Cloud Spanner API client library
 Home-page: https://github.com/googleapis/python-spanner
 Author: Google LLC

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_admin_database_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.53.0"  # {x-release-please-version}
+__version__ = "3.54.0"  # {x-release-please-version}

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_admin_instance_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.53.0"  # {x-release-please-version}
+__version__ = "3.54.0"  # {x-release-please-version}

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/batch_dml_executor.py

@@ -54,9 +54,12 @@ class BatchDmlExecutor:
         """
         from google.cloud.spanner_dbapi import ProgrammingError
 
+        # Note: Let the server handle it if the client-side parser did not
+        # recognize the type of statement.
         if (
             parsed_statement.statement_type != StatementType.UPDATE
             and parsed_statement.statement_type != StatementType.INSERT
+            and parsed_statement.statement_type != StatementType.UNKNOWN
         ):
             raise ProgrammingError("Only DML statements are allowed in batch DML mode.")
         self._statements.append(parsed_statement.statement)

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/client_side_statement_executor.py

@@ -11,7 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
+from google.cloud.spanner_v1 import TransactionOptions
 
 if TYPE_CHECKING:
     from google.cloud.spanner_dbapi.cursor import Cursor
@@ -58,7 +59,7 @@ def execute(cursor: "Cursor", parsed_statement: ParsedStatement):
         connection.commit()
         return None
     if statement_type == ClientSideStatementType.BEGIN:
-        connection.begin()
+        connection.begin(isolation_level=_get_isolation_level(parsed_statement))
         return None
     if statement_type == ClientSideStatementType.ROLLBACK:
         connection.rollback()
@@ -121,3 +122,19 @@ def _get_streamed_result_set(column_name, type_code, column_values):
             column_values_pb.append(_make_value_pb(column_value))
         result_set.values.extend(column_values_pb)
     return StreamedResultSet(iter([result_set]))
+
+
+def _get_isolation_level(
+    statement: ParsedStatement,
+) -> Union[TransactionOptions.IsolationLevel, None]:
+    if (
+        statement.client_side_statement_params is None
+        or len(statement.client_side_statement_params) == 0
+    ):
+        return None
+    level = statement.client_side_statement_params[0]
+    if not isinstance(level, str) or level == "":
+        return None
+    # Replace (duplicate) whitespaces in the string with an underscore.
+    level = "_".join(level.split()).upper()
+    return TransactionOptions.IsolationLevel[level]

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/client_side_statement_parser.py

@@ -21,18 +21,21 @@ from google.cloud.spanner_dbapi.parsed_statement import (
     Statement,
 )
 
-RE_BEGIN = re.compile(r"^\s*(BEGIN|START)(TRANSACTION)?", re.IGNORECASE)
-RE_COMMIT = re.compile(r"^\s*(COMMIT)(TRANSACTION)?", re.IGNORECASE)
-RE_ROLLBACK = re.compile(r"^\s*(ROLLBACK)(TRANSACTION)?", re.IGNORECASE)
+RE_BEGIN = re.compile(
+    r"^\s*(?:BEGIN|START)(?:\s+TRANSACTION)?(?:\s+ISOLATION\s+LEVEL\s+(REPEATABLE\s+READ|SERIALIZABLE))?\s*$",
+    re.IGNORECASE,
+)
+RE_COMMIT = re.compile(r"^\s*(COMMIT)(\s+TRANSACTION)?\s*$", re.IGNORECASE)
+RE_ROLLBACK = re.compile(r"^\s*(ROLLBACK)(\s+TRANSACTION)?\s*$", re.IGNORECASE)
 RE_SHOW_COMMIT_TIMESTAMP = re.compile(
-    r"^\s*(SHOW)\s+(VARIABLE)\s+(COMMIT_TIMESTAMP)", re.IGNORECASE
+    r"^\s*(SHOW)\s+(VARIABLE)\s+(COMMIT_TIMESTAMP)\s*$", re.IGNORECASE
 )
 RE_SHOW_READ_TIMESTAMP = re.compile(
-    r"^\s*(SHOW)\s+(VARIABLE)\s+(READ_TIMESTAMP)", re.IGNORECASE
+    r"^\s*(SHOW)\s+(VARIABLE)\s+(READ_TIMESTAMP)\s*$", re.IGNORECASE
 )
-RE_START_BATCH_DML = re.compile(r"^\s*(START)\s+(BATCH)\s+(DML)", re.IGNORECASE)
-RE_RUN_BATCH = re.compile(r"^\s*(RUN)\s+(BATCH)", re.IGNORECASE)
-RE_ABORT_BATCH = re.compile(r"^\s*(ABORT)\s+(BATCH)", re.IGNORECASE)
+RE_START_BATCH_DML = re.compile(r"^\s*(START)\s+(BATCH)\s+(DML)\s*$", re.IGNORECASE)
+RE_RUN_BATCH = re.compile(r"^\s*(RUN)\s+(BATCH)\s*$", re.IGNORECASE)
+RE_ABORT_BATCH = re.compile(r"^\s*(ABORT)\s+(BATCH)\s*$", re.IGNORECASE)
 RE_PARTITION_QUERY = re.compile(r"^\s*(PARTITION)\s+(.+)", re.IGNORECASE)
 RE_RUN_PARTITION = re.compile(r"^\s*(RUN)\s+(PARTITION)\s+(.+)", re.IGNORECASE)
 RE_RUN_PARTITIONED_QUERY = re.compile(
@@ -68,6 +71,10 @@ def parse_stmt(query):
     elif RE_START_BATCH_DML.match(query):
         client_side_statement_type = ClientSideStatementType.START_BATCH_DML
     elif RE_BEGIN.match(query):
+        match = re.search(RE_BEGIN, query)
+        isolation_level = match.group(1)
+        if isolation_level is not None:
+            client_side_statement_params.append(isolation_level)
         client_side_statement_type = ClientSideStatementType.BEGIN
     elif RE_RUN_BATCH.match(query):
         client_side_statement_type = ClientSideStatementType.RUN_BATCH

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/connection.py

@@ -20,16 +20,12 @@ from google.api_core.gapic_v1.client_info import ClientInfo
 from google.cloud import spanner_v1 as spanner
 from google.cloud.spanner_dbapi import partition_helper
 from google.cloud.spanner_dbapi.batch_dml_executor import BatchMode, BatchDmlExecutor
-from google.cloud.spanner_dbapi.parse_utils import _get_statement_type
-from google.cloud.spanner_dbapi.parsed_statement import (
-    StatementType,
-    AutocommitDmlMode,
-)
+from google.cloud.spanner_dbapi.parsed_statement import AutocommitDmlMode
 from google.cloud.spanner_dbapi.partition_helper import PartitionId
 from google.cloud.spanner_dbapi.parsed_statement import ParsedStatement, Statement
 from google.cloud.spanner_dbapi.transaction_helper import TransactionRetryHelper
 from google.cloud.spanner_dbapi.cursor import Cursor
-from google.cloud.spanner_v1 import RequestOptions
+from google.cloud.spanner_v1 import RequestOptions, TransactionOptions
 from google.cloud.spanner_v1.snapshot import Snapshot
 
 from google.cloud.spanner_dbapi.exceptions import (
@@ -112,6 +108,7 @@ class Connection:
         self._staleness = None
         self.request_priority = None
         self._transaction_begin_marked = False
+        self._transaction_isolation_level = None
         # whether transaction started at Spanner. This means that we had
         # made at least one call to Spanner.
         self._spanner_transaction_started = False
@@ -283,6 +280,33 @@ class Connection:
         """
         self._connection_variables["transaction_tag"] = value
 
+    @property
+    def isolation_level(self):
+        """The default isolation level that is used for all read/write
+        transactions on this `Connection`.
+
+        Returns:
+            google.cloud.spanner_v1.types.TransactionOptions.IsolationLevel:
+            The isolation level that is used for read/write transactions on
+            this `Connection`.
+        """
+        return self._connection_variables.get(
+            "isolation_level",
+            TransactionOptions.IsolationLevel.ISOLATION_LEVEL_UNSPECIFIED,
+        )
+
+    @isolation_level.setter
+    def isolation_level(self, value: TransactionOptions.IsolationLevel):
+        """Sets the isolation level that is used for all read/write
+        transactions on this `Connection`.
+
+        Args:
+            value (google.cloud.spanner_v1.types.TransactionOptions.IsolationLevel):
+            The isolation level for all read/write transactions on this
+            `Connection`.
+        """
+        self._connection_variables["isolation_level"] = value
+
     @property
     def staleness(self):
         """Current read staleness option value of this `Connection`.
@@ -363,6 +387,12 @@ class Connection:
             if not self._spanner_transaction_started:
                 self._transaction = self._session_checkout().transaction()
                 self._transaction.transaction_tag = self.transaction_tag
+                if self._transaction_isolation_level:
+                    self._transaction.isolation_level = (
+                        self._transaction_isolation_level
+                    )
+                else:
+                    self._transaction.isolation_level = self.isolation_level
                 self.transaction_tag = None
                 self._snapshot = None
                 self._spanner_transaction_started = True
@@ -405,7 +435,7 @@ class Connection:
         self.is_closed = True
 
     @check_not_closed
-    def begin(self):
+    def begin(self, isolation_level=None):
         """
         Marks the transaction as started.
 
@@ -421,6 +451,7 @@ class Connection:
                 "is already running"
             )
         self._transaction_begin_marked = True
+        self._transaction_isolation_level = isolation_level
 
     def commit(self):
         """Commits any pending transaction to the database.
@@ -465,6 +496,7 @@ class Connection:
         self._release_session()
         self._transaction_helper.reset()
         self._transaction_begin_marked = False
+        self._transaction_isolation_level = None
         self._spanner_transaction_started = False
 
     @check_not_closed
@@ -666,10 +698,6 @@ class Connection:
         self._autocommit_dml_mode = autocommit_dml_mode
 
     def _partitioned_query_validation(self, partitioned_query, statement):
-        if _get_statement_type(Statement(partitioned_query)) is not StatementType.QUERY:
-            raise ProgrammingError(
-                "Only queries can be partitioned. Invalid statement: " + statement.sql
-            )
         if self.read_only is not True and self._client_transaction_started is True:
             raise ProgrammingError(
                 "Partitioned query is not supported, because the connection is in a read/write transaction."

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/cursor.py

@@ -404,9 +404,12 @@ class Cursor(object):
             # For every operation, we've got to ensure that any prior DDL
             # statements were run.
             self.connection.run_prior_DDL_statements()
+            # Treat UNKNOWN statements as if they are DML and let the server
+            # determine what is wrong with it.
             if self._parsed_statement.statement_type in (
                 StatementType.INSERT,
                 StatementType.UPDATE,
+                StatementType.UNKNOWN,
             ):
                 statements = []
                 for params in seq_of_params:

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/parse_utils.py

@@ -155,6 +155,7 @@ STMT_UPDATING = "UPDATING"
 STMT_INSERT = "INSERT"
 
 # Heuristic for identifying statements that don't need to be run as updates.
+# TODO: This and the other regexes do not match statements that start with a hint.
 RE_NON_UPDATE = re.compile(r"^\W*(SELECT|GRAPH|FROM)", re.IGNORECASE)
 
 RE_WITH = re.compile(r"^\s*(WITH)", re.IGNORECASE)
@@ -162,18 +163,22 @@ RE_WITH = re.compile(r"^\s*(WITH)", re.IGNORECASE)
 # DDL statements follow
 # https://cloud.google.com/spanner/docs/data-definition-language
 RE_DDL = re.compile(
-    r"^\s*(CREATE|ALTER|DROP|GRANT|REVOKE|RENAME)", re.IGNORECASE | re.DOTALL
+    r"^\s*(CREATE|ALTER|DROP|GRANT|REVOKE|RENAME|ANALYZE)", re.IGNORECASE | re.DOTALL
 )
 
-RE_IS_INSERT = re.compile(r"^\s*(INSERT)", re.IGNORECASE | re.DOTALL)
+# TODO: These do not match statements that start with a hint.
+RE_IS_INSERT = re.compile(r"^\s*(INSERT\s+)", re.IGNORECASE | re.DOTALL)
+RE_IS_UPDATE = re.compile(r"^\s*(UPDATE\s+)", re.IGNORECASE | re.DOTALL)
+RE_IS_DELETE = re.compile(r"^\s*(DELETE\s+)", re.IGNORECASE | re.DOTALL)
 
 RE_INSERT = re.compile(
     # Only match the `INSERT INTO <table_name> (columns...)
     # otherwise the rest of the statement could be a complex
     # operation.
-    r"^\s*INSERT INTO (?P<table_name>[^\s\(\)]+)\s*\((?P<columns>[^\(\)]+)\)",
+    r"^\s*INSERT(?:\s+INTO)?\s+(?P<table_name>[^\s\(\)]+)\s*\((?P<columns>[^\(\)]+)\)",
     re.IGNORECASE | re.DOTALL,
 )
+"""Deprecated: Use the RE_IS_INSERT, RE_IS_UPDATE, and RE_IS_DELETE regexes"""
 
 RE_VALUES_TILL_END = re.compile(r"VALUES\s*\(.+$", re.IGNORECASE | re.DOTALL)
 
@@ -259,8 +264,13 @@ def _get_statement_type(statement):
         # statements and doesn't yet support WITH for DML statements.
         return StatementType.QUERY
 
-    statement.sql = ensure_where_clause(query)
-    return StatementType.UPDATE
+    if RE_IS_UPDATE.match(query) or RE_IS_DELETE.match(query):
+        # TODO: Remove this? It makes more sense to have this in SQLAlchemy and
+        #       Django than here.
+        statement.sql = ensure_where_clause(query)
+        return StatementType.UPDATE
+
+    return StatementType.UNKNOWN
 
 
 def sql_pyformat_args_to_spanner(sql, params):
@@ -355,7 +365,7 @@ def get_param_types(params):
 def ensure_where_clause(sql):
     """
     Cloud Spanner requires a WHERE clause on UPDATE and DELETE statements.
-    Add a dummy WHERE clause if non detected.
+    Add a dummy WHERE clause if not detected.
 
     :type sql: str
     :param sql: SQL code to check.

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_dbapi/parsed_statement.py

@@ -17,6 +17,7 @@ from typing import Any, List
 
 
 class StatementType(Enum):
+    UNKNOWN = 0
     CLIENT_SIDE = 1
     DDL = 2
     QUERY = 3

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/__init__.py

@@ -63,7 +63,7 @@ from .types.type import StructType
 from .types.type import Type
 from .types.type import TypeAnnotationCode
 from .types.type import TypeCode
-from .data_types import JsonObject
+from .data_types import JsonObject, Interval
 from .transaction import BatchTransactionId, DefaultTransactionOptions
 
 from google.cloud.spanner_v1 import param_types
@@ -145,6 +145,7 @@ __all__ = (
     "TypeCode",
     # Custom spanner related data types
     "JsonObject",
+    "Interval",
     # google.cloud.spanner_v1.services
     "SpannerClient",
     "SpannerAsyncClient",

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/_helpers.py

@@ -31,7 +31,7 @@ from google.api_core.exceptions import Aborted
 from google.cloud._helpers import _date_from_iso8601_date
 from google.cloud.spanner_v1 import TypeCode
 from google.cloud.spanner_v1 import ExecuteSqlRequest
-from google.cloud.spanner_v1 import JsonObject
+from google.cloud.spanner_v1 import JsonObject, Interval
 from google.cloud.spanner_v1 import TransactionOptions
 from google.cloud.spanner_v1.request_id_header import with_request_id
 from google.rpc.error_details_pb2 import RetryInfo
@@ -251,6 +251,8 @@ def _make_value_pb(value):
             return Value(null_value="NULL_VALUE")
         else:
             return Value(string_value=base64.b64encode(value))
+    if isinstance(value, Interval):
+        return Value(string_value=str(value))
 
     raise ValueError("Unknown type: %s" % (value,))
 
@@ -367,6 +369,8 @@ def _get_type_decoder(field_type, field_name, column_info=None):
             for item_field in field_type.struct_type.fields
         ]
         return lambda value_pb: _parse_struct(value_pb, element_decoders)
+    elif type_code == TypeCode.INTERVAL:
+        return _parse_interval
     else:
         raise ValueError("Unknown type: %s" % (field_type,))
 
@@ -473,6 +477,13 @@ def _parse_nullable(value_pb, decoder):
         return decoder(value_pb)
 
 
+def _parse_interval(value_pb):
+    """Parse a Value protobuf containing an interval."""
+    if hasattr(value_pb, "string_value"):
+        return Interval.from_str(value_pb.string_value)
+    return Interval.from_str(value_pb)
+
+
 class _SessionWrapper(object):
     """Base class for objects wrapping a session.
 

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/data_types.py

@@ -16,7 +16,8 @@
 
 import json
 import types
-
+import re
+from dataclasses import dataclass
 from google.protobuf.message import Message
 from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
 
@@ -97,6 +98,152 @@ class JsonObject(dict):
         return json.dumps(self, sort_keys=True, separators=(",", ":"))
 
 
+@dataclass
+class Interval:
+    """Represents a Spanner INTERVAL type.
+
+    An interval is a combination of months, days and nanoseconds.
+    Internally, Spanner supports Interval value with the following range of individual fields:
+    months: [-120000, 120000]
+    days: [-3660000, 3660000]
+    nanoseconds: [-316224000000000000000, 316224000000000000000]
+    """
+
+    months: int = 0
+    days: int = 0
+    nanos: int = 0
+
+    def __str__(self) -> str:
+        """Returns the ISO8601 duration format string representation."""
+        result = ["P"]
+
+        # Handle years and months
+        if self.months:
+            is_negative = self.months < 0
+            abs_months = abs(self.months)
+            years, months = divmod(abs_months, 12)
+            if years:
+                result.append(f"{'-' if is_negative else ''}{years}Y")
+            if months:
+                result.append(f"{'-' if is_negative else ''}{months}M")
+
+        # Handle days
+        if self.days:
+            result.append(f"{self.days}D")
+
+        # Handle time components
+        if self.nanos:
+            result.append("T")
+            nanos = abs(self.nanos)
+            is_negative = self.nanos < 0
+
+            # Convert to hours, minutes, seconds
+            nanos_per_hour = 3600000000000
+            hours, nanos = divmod(nanos, nanos_per_hour)
+            if hours:
+                if is_negative:
+                    result.append("-")
+                result.append(f"{hours}H")
+
+            nanos_per_minute = 60000000000
+            minutes, nanos = divmod(nanos, nanos_per_minute)
+            if minutes:
+                if is_negative:
+                    result.append("-")
+                result.append(f"{minutes}M")
+
+            nanos_per_second = 1000000000
+            seconds, nanos_fraction = divmod(nanos, nanos_per_second)
+
+            if seconds or nanos_fraction:
+                if is_negative:
+                    result.append("-")
+                if seconds:
+                    result.append(str(seconds))
+                elif nanos_fraction:
+                    result.append("0")
+
+                if nanos_fraction:
+                    nano_str = f"{nanos_fraction:09d}"
+                    trimmed = nano_str.rstrip("0")
+                    if len(trimmed) <= 3:
+                        while len(trimmed) < 3:
+                            trimmed += "0"
+                    elif len(trimmed) <= 6:
+                        while len(trimmed) < 6:
+                            trimmed += "0"
+                    else:
+                        while len(trimmed) < 9:
+                            trimmed += "0"
+                    result.append(f".{trimmed}")
+                result.append("S")
+
+        if len(result) == 1:
+            result.append("0Y")  # Special case for zero interval
+
+        return "".join(result)
+
+    @classmethod
+    def from_str(cls, s: str) -> "Interval":
+        """Parse an ISO8601 duration format string into an Interval."""
+        pattern = r"^P(-?\d+Y)?(-?\d+M)?(-?\d+D)?(T(-?\d+H)?(-?\d+M)?(-?((\d+([.,]\d{1,9})?)|([.,]\d{1,9}))S)?)?$"
+        match = re.match(pattern, s)
+        if not match or len(s) == 1:
+            raise ValueError(f"Invalid interval format: {s}")
+
+        parts = match.groups()
+        if not any(parts[:3]) and not parts[3]:
+            raise ValueError(
+                f"Invalid interval format: at least one component (Y/M/D/H/M/S) is required: {s}"
+            )
+
+        if parts[3] == "T" and not any(parts[4:7]):
+            raise ValueError(
+                f"Invalid interval format: time designator 'T' present but no time components specified: {s}"
+            )
+
+        def parse_num(s: str, suffix: str) -> int:
+            if not s:
+                return 0
+            return int(s.rstrip(suffix))
+
+        years = parse_num(parts[0], "Y")
+        months = parse_num(parts[1], "M")
+        total_months = years * 12 + months
+
+        days = parse_num(parts[2], "D")
+
+        nanos = 0
+        if parts[3]:  # Has time component
+            # Convert hours to nanoseconds
+            hours = parse_num(parts[4], "H")
+            nanos += hours * 3600000000000
+
+            # Convert minutes to nanoseconds
+            minutes = parse_num(parts[5], "M")
+            nanos += minutes * 60000000000
+
+            # Handle seconds and fractional seconds
+            if parts[6]:
+                seconds = parts[6].rstrip("S")
+                if "," in seconds:
+                    seconds = seconds.replace(",", ".")
+
+                if "." in seconds:
+                    sec_parts = seconds.split(".")
+                    whole_seconds = sec_parts[0] if sec_parts[0] else "0"
+                    nanos += int(whole_seconds) * 1000000000
+                    frac = sec_parts[1][:9].ljust(9, "0")
+                    frac_nanos = int(frac)
+                    if seconds.startswith("-"):
+                        frac_nanos = -frac_nanos
+                    nanos += frac_nanos
+                else:
+                    nanos += int(seconds) * 1000000000
+
+        return cls(months=total_months, days=days, nanos=nanos)
+
+
 def _proto_message(bytes_val, proto_message_object):
     """Helper for :func:`get_proto_message`.
     parses serialized protocol buffer bytes data into proto message.

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.53.0"  # {x-release-please-version}
+__version__ = "3.54.0"  # {x-release-please-version}

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/param_types.py

@@ -36,6 +36,7 @@ JSON = Type(code=TypeCode.JSON)
 PG_NUMERIC = Type(code=TypeCode.NUMERIC, type_annotation=TypeAnnotationCode.PG_NUMERIC)
 PG_JSONB = Type(code=TypeCode.JSON, type_annotation=TypeAnnotationCode.PG_JSONB)
 PG_OID = Type(code=TypeCode.INT64, type_annotation=TypeAnnotationCode.PG_OID)
+INTERVAL = Type(code=TypeCode.INTERVAL)
 
 
 def Array(element_type):

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google/cloud/spanner_v1/streamed.py

@@ -391,6 +391,7 @@ _MERGE_BY_TYPE = {
     TypeCode.NUMERIC: _merge_string,
     TypeCode.JSON: _merge_string,
     TypeCode.PROTO: _merge_string,
+    TypeCode.INTERVAL: _merge_string,
     TypeCode.ENUM: _merge_string,
 }
 

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0/google_cloud_spanner.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-spanner
-Version: 3.53.0
+Version: 3.54.0
 Summary: Google Cloud Spanner API client library
 Home-page: https://github.com/googleapis/python-spanner
 Author: Google LLC

{google_cloud_spanner-3.53.0 → google_cloud_spanner-3.54.0}/google_cloud_spanner.egg-info/SOURCES.txt

@@ -129,6 +129,7 @@ tests/mockserver_tests/mock_server_test_base.py
 tests/mockserver_tests/test_aborted_transaction.py
 tests/mockserver_tests/test_basics.py
 tests/mockserver_tests/test_dbapi_autocommit.py
+tests/mockserver_tests/test_dbapi_isolation_level.py
 tests/mockserver_tests/test_tags.py
 tests/system/__init__.py
 tests/system/_helpers.py
@@ -189,6 +190,7 @@ tests/unit/spanner_dbapi/__init__.py
 tests/unit/spanner_dbapi/test__helpers.py
 tests/unit/spanner_dbapi/test_batch_dml_executor.py
 tests/unit/spanner_dbapi/test_checksum.py
+tests/unit/spanner_dbapi/test_client_side_statement_executor.py
 tests/unit/spanner_dbapi/test_connect.py
 tests/unit/spanner_dbapi/test_connection.py
 tests/unit/spanner_dbapi/test_cursor.py