Merge branch 'main' into parthea-patch-3

Author: rahul2393

.github/.OwlBot.lock.yaml

@@ -13,5 +13,5 @@
 # limitations under the License.
 docker:
   image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest
-  digest: sha256:5581906b957284864632cde4e9c51d1cc66b0094990b27e689132fe5cd036046
-# created: 2025-03-05
+  digest: sha256:25de45b58e52021d3a24a6273964371a97a4efeefe6ad3845a64e697c63b6447
+# created: 2025-04-14T14:34:43.260858345Z

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "3.53.0"
+    ".": "3.54.0"
 }

CHANGELOG.md

@@ -4,6 +4,21 @@
 
 [1]: https://pypi.org/project/google-cloud-spanner/#history
 
+## [3.54.0](https://github.com/googleapis/python-spanner/compare/v3.53.0...v3.54.0) (2025-04-28)
+
+
+### Features
+
+* Add interval type support ([#1340](https://github.com/googleapis/python-spanner/issues/1340)) ([6ca9b43](https://github.com/googleapis/python-spanner/commit/6ca9b43c3038eca1317c7c9b7e3543b5f1bc68ad))
+* Add sample for pre-split feature ([#1333](https://github.com/googleapis/python-spanner/issues/1333)) ([ca76108](https://github.com/googleapis/python-spanner/commit/ca76108809174e4f3eea38d7ac2463d9b4c73304))
+* Add SQL statement for begin transaction isolation level ([#1331](https://github.com/googleapis/python-spanner/issues/1331)) ([3ac0f91](https://github.com/googleapis/python-spanner/commit/3ac0f9131b38e5cfb2b574d3d73b03736b871712))
+* Support transaction isolation level in dbapi ([#1327](https://github.com/googleapis/python-spanner/issues/1327)) ([03400c4](https://github.com/googleapis/python-spanner/commit/03400c40f1c1cc73e51733f2a28910a8dd78e7d9))
+
+
+### Bug Fixes
+
+* Improve client-side regex statement parser ([#1328](https://github.com/googleapis/python-spanner/issues/1328)) ([b3c259d](https://github.com/googleapis/python-spanner/commit/b3c259deec817812fd8e4940faacf4a927d0d69c))
+
 ## [3.53.0](https://github.com/googleapis/python-spanner/compare/v3.52.0...v3.53.0) (2025-03-12)
 
 

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_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_dbapi/batch_dml_executor.py

@@ -54,9 +54,12 @@ def execute_statement(self, parsed_statement: ParsedStatement):
         """
         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_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_dbapi/client_side_statement_parser.py

@@ -21,18 +21,21 @@
     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_dbapi/connection.py

@@ -20,16 +20,12 @@
 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 @@ def __init__(self, instance, database=None, read_only=False, **kwargs):
         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 @@ def transaction_tag(self, value):
         """
         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 @@ def transaction_checkout(self):
             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 @@ def close(self):
         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 @@ def begin(self):
                 "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 @@ def _reset_post_commit_or_rollback(self):
         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 @@ def set_autocommit_dml_mode(
         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_dbapi/cursor.py

@@ -404,9 +404,12 @@ def executemany(self, operation, seq_of_params):
             # 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: