google-cloud-spanner 3.55.0__py3-none-any.whl

google/cloud/spanner_dbapi/__init__.py

@@ -0,0 +1,93 @@
+# Copyright 2020 Google LLC All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+"""Connection-based DB API for Cloud Spanner."""
+
+from google.cloud.spanner_dbapi.connection import Connection
+from google.cloud.spanner_dbapi.connection import connect
+
+from google.cloud.spanner_dbapi.cursor import Cursor
+
+from google.cloud.spanner_dbapi.exceptions import DatabaseError
+from google.cloud.spanner_dbapi.exceptions import DataError
+from google.cloud.spanner_dbapi.exceptions import Error
+from google.cloud.spanner_dbapi.exceptions import IntegrityError
+from google.cloud.spanner_dbapi.exceptions import InterfaceError
+from google.cloud.spanner_dbapi.exceptions import InternalError
+from google.cloud.spanner_dbapi.exceptions import NotSupportedError
+from google.cloud.spanner_dbapi.exceptions import OperationalError
+from google.cloud.spanner_dbapi.exceptions import ProgrammingError
+from google.cloud.spanner_dbapi.exceptions import Warning
+
+from google.cloud.spanner_dbapi.parse_utils import get_param_types
+
+from google.cloud.spanner_dbapi.types import BINARY
+from google.cloud.spanner_dbapi.types import DATETIME
+from google.cloud.spanner_dbapi.types import NUMBER
+from google.cloud.spanner_dbapi.types import ROWID
+from google.cloud.spanner_dbapi.types import STRING
+from google.cloud.spanner_dbapi.types import Binary
+from google.cloud.spanner_dbapi.types import Date
+from google.cloud.spanner_dbapi.types import DateFromTicks
+from google.cloud.spanner_dbapi.types import Time
+from google.cloud.spanner_dbapi.types import TimeFromTicks
+from google.cloud.spanner_dbapi.types import Timestamp
+from google.cloud.spanner_dbapi.types import TimestampStr
+from google.cloud.spanner_dbapi.types import TimestampFromTicks
+
+from google.cloud.spanner_dbapi.version import DEFAULT_USER_AGENT
+
+apilevel = "2.0"  # supports DP-API 2.0 level.
+paramstyle = "format"  # ANSI C printf format codes, e.g. ...WHERE name=%s.
+
+# Threads may share the module, but not connections. This is a paranoid threadsafety
+# level, but it is necessary for starters to use when debugging failures.
+# Eventually once transactions are working properly, we'll update the
+# threadsafety level.
+threadsafety = 1
+
+
+__all__ = [
+    "Connection",
+    "connect",
+    "Cursor",
+    "DatabaseError",
+    "DataError",
+    "Error",
+    "IntegrityError",
+    "InterfaceError",
+    "InternalError",
+    "NotSupportedError",
+    "OperationalError",
+    "ProgrammingError",
+    "Warning",
+    "DEFAULT_USER_AGENT",
+    "apilevel",
+    "paramstyle",
+    "threadsafety",
+    "get_param_types",
+    "Binary",
+    "Date",
+    "DateFromTicks",
+    "Time",
+    "TimeFromTicks",
+    "Timestamp",
+    "TimestampFromTicks",
+    "BINARY",
+    "STRING",
+    "NUMBER",
+    "DATETIME",
+    "ROWID",
+    "TimestampStr",
+]

google/cloud/spanner_dbapi/_helpers.py

@@ -0,0 +1,113 @@
+# Copyright 2020 Google LLC All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 google.cloud.spanner_v1 import param_types
+
+
+SQL_LIST_TABLES = """
+SELECT table_name
+FROM information_schema.tables
+WHERE table_catalog = ''
+AND table_schema = @table_schema
+AND table_type = 'BASE TABLE'
+"""
+
+SQL_LIST_TABLES_AND_VIEWS = """
+SELECT table_name
+FROM information_schema.tables
+WHERE table_catalog = '' AND table_schema = @table_schema
+"""
+
+SQL_GET_TABLE_COLUMN_SCHEMA = """
+SELECT COLUMN_NAME, IS_NULLABLE, SPANNER_TYPE
+FROM INFORMATION_SCHEMA.COLUMNS
+WHERE TABLE_SCHEMA = @schema_name AND TABLE_NAME = @table_name
+"""
+
+# This table maps spanner_types to Spanner's data type sizes as per
+#   https://cloud.google.com/spanner/docs/data-types#allowable-types
+# It is used to map `display_size` to a known type for Cursor.description
+# after a row fetch.
+# Since ResultMetadata
+#   https://cloud.google.com/spanner/docs/reference/rest/v1/ResultSetMetadata
+# does not send back the actual size, we have to lookup the respective size.
+# Some fields' sizes are dependent upon the dynamic data hence aren't sent back
+# by Cloud Spanner.
+CODE_TO_DISPLAY_SIZE = {
+    param_types.BOOL.code: 1,
+    param_types.DATE.code: 4,
+    param_types.FLOAT64.code: 8,
+    param_types.FLOAT32.code: 4,
+    param_types.INT64.code: 8,
+    param_types.TIMESTAMP.code: 12,
+}
+
+
+class ColumnInfo:
+    """Row column description object."""
+
+    def __init__(
+        self,
+        name,
+        type_code,
+        display_size=None,
+        internal_size=None,
+        precision=None,
+        scale=None,
+        null_ok=False,
+    ):
+        self.name = name
+        self.type_code = type_code
+        self.display_size = display_size
+        self.internal_size = internal_size
+        self.precision = precision
+        self.scale = scale
+        self.null_ok = null_ok
+
+        self.fields = (
+            self.name,
+            self.type_code,
+            self.display_size,
+            self.internal_size,
+            self.precision,
+            self.scale,
+            self.null_ok,
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __getitem__(self, index):
+        return self.fields[index]
+
+    def __str__(self):
+        str_repr = ", ".join(
+            filter(
+                lambda part: part is not None,
+                [
+                    "name='%s'" % self.name,
+                    "type_code=%d" % self.type_code,
+                    "display_size=%d" % self.display_size
+                    if self.display_size
+                    else None,
+                    "internal_size=%d" % self.internal_size
+                    if self.internal_size
+                    else None,
+                    "precision='%s'" % self.precision if self.precision else None,
+                    "scale='%s'" % self.scale if self.scale else None,
+                    "null_ok='%s'" % self.null_ok if self.null_ok else None,
+                ],
+            )
+        )
+        return "ColumnInfo(%s)" % str_repr

google/cloud/spanner_dbapi/batch_dml_executor.py

@@ -0,0 +1,135 @@
+# Copyright 2023 Google LLC All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, List
+from google.cloud.spanner_dbapi.parsed_statement import (
+    ParsedStatement,
+    StatementType,
+    Statement,
+)
+from google.rpc.code_pb2 import ABORTED, OK
+from google.api_core.exceptions import Aborted
+
+from google.cloud.spanner_dbapi.utils import StreamedManyResultSets
+
+if TYPE_CHECKING:
+    from google.cloud.spanner_dbapi.cursor import Cursor
+
+
+class BatchDmlExecutor:
+    """Executor that is used when a DML batch is started. These batches only
+    accept DML statements. All DML statements are buffered locally and sent to
+    Spanner when runBatch() is called.
+
+    :type "Cursor": :class:`~google.cloud.spanner_dbapi.cursor.Cursor`
+    :param cursor:
+    """
+
+    def __init__(self, cursor: "Cursor"):
+        self._cursor = cursor
+        self._connection = cursor.connection
+        self._statements: List[Statement] = []
+
+    def execute_statement(self, parsed_statement: ParsedStatement):
+        """Executes the statement when dml batch is active by buffering the
+        statement in-memory.
+
+        :type parsed_statement: ParsedStatement
+        :param parsed_statement: parsed statement containing sql query and query
+         params
+        """
+        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)
+
+    def run_batch_dml(self):
+        """Executes all the buffered statements on the active dml batch by
+        making a call to Spanner.
+        """
+        return run_batch_dml(self._cursor, self._statements)
+
+
+def run_batch_dml(cursor: "Cursor", statements: List[Statement]):
+    """Executes all the dml statements by making a batch call to Spanner.
+
+    :type cursor: Cursor
+    :param cursor: Database Cursor object
+
+    :type statements: List[Statement]
+    :param statements: list of statements to execute in batch
+    """
+    from google.cloud.spanner_dbapi import OperationalError
+
+    many_result_set = StreamedManyResultSets()
+    if not statements:
+        return many_result_set
+    connection = cursor.connection
+    statements_tuple = []
+    for statement in statements:
+        statements_tuple.append(statement.get_tuple())
+    if not connection._client_transaction_started:
+        res = connection.database.run_in_transaction(
+            _do_batch_update_autocommit, statements_tuple
+        )
+        many_result_set.add_iter(res)
+        cursor._row_count = sum([max(val, 0) for val in res])
+    else:
+        while True:
+            try:
+                transaction = connection.transaction_checkout()
+                status, res = transaction.batch_update(statements_tuple)
+                if status.code == ABORTED:
+                    connection._transaction = None
+                    raise Aborted(status.message)
+                elif status.code != OK:
+                    raise OperationalError(status.message)
+
+                cursor._batch_dml_rows_count = res
+                many_result_set.add_iter(res)
+                cursor._row_count = sum([max(val, 0) for val in res])
+                return many_result_set
+            except Aborted:
+                # We are raising it so it could be handled in transaction_helper.py and is retried
+                if cursor._in_retry_mode:
+                    raise
+                else:
+                    connection._transaction_helper.retry_transaction()
+
+
+def _do_batch_update_autocommit(transaction, statements):
+    from google.cloud.spanner_dbapi import OperationalError
+
+    status, res = transaction.batch_update(statements, last_statement=True)
+    if status.code == ABORTED:
+        raise Aborted(status.message)
+    elif status.code != OK:
+        raise OperationalError(status.message)
+    return res
+
+
+class BatchMode(Enum):
+    DML = 1
+    DDL = 2
+    NONE = 3

google/cloud/spanner_dbapi/checksum.py

@@ -0,0 +1,80 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+"""API to calculate checksums of SQL statements results."""
+
+import hashlib
+import pickle
+
+from google.cloud.spanner_dbapi.exceptions import RetryAborted
+
+
+class ResultsChecksum:
+    """Cumulative checksum.
+
+    Used to calculate a total checksum of all the results
+    returned by operations executed within transaction.
+    Includes methods for checksums comparison.
+    These checksums are used while retrying an aborted
+    transaction to check if the results of a retried transaction
+    are equal to the results of the original transaction.
+    """
+
+    def __init__(self):
+        self.checksum = hashlib.sha256()
+        self.count = 0  # counter of consumed results
+
+    def __len__(self):
+        """Return the number of consumed results.
+
+        :rtype: :class:`int`
+        :returns: The number of results.
+        """
+        return self.count
+
+    def __eq__(self, other):
+        """Check if checksums are equal.
+
+        :type other: :class:`google.cloud.spanner_dbapi.checksum.ResultsChecksum`
+        :param other: Another checksum to compare with this one.
+        """
+        return self.checksum.digest() == other.checksum.digest()
+
+    def consume_result(self, result):
+        """Add the given result into the checksum.
+
+        :type result: Union[int, list]
+        :param result: Streamed row or row count from an UPDATE operation.
+        """
+        self.checksum.update(pickle.dumps(result))
+        self.count += 1
+
+
+def _compare_checksums(original, retried):
+    from google.cloud.spanner_dbapi.transaction_helper import RETRY_ABORTED_ERROR
+
+    """Compare the given checksums.
+
+    Raise an error if the given checksums are not equal.
+
+    :type original: :class:`~google.cloud.spanner_dbapi.checksum.ResultsChecksum`
+    :param original: results checksum of the original transaction.
+
+    :type retried: :class:`~google.cloud.spanner_dbapi.checksum.ResultsChecksum`
+    :param retried: results checksum of the retried transaction.
+
+    :raises: :exc:`google.cloud.spanner_dbapi.exceptions.RetryAborted` in case if checksums are not equal.
+    """
+    if retried != original:
+        raise RetryAborted(RETRY_ABORTED_ERROR)

google/cloud/spanner_dbapi/client_side_statement_executor.py

@@ -0,0 +1,140 @@
+# Copyright 2023 Google LLC All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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, Union
+from google.cloud.spanner_v1 import TransactionOptions
+
+if TYPE_CHECKING:
+    from google.cloud.spanner_dbapi.cursor import Cursor
+    from google.cloud.spanner_dbapi import ProgrammingError
+
+from google.cloud.spanner_dbapi.parsed_statement import (
+    ParsedStatement,
+    ClientSideStatementType,
+)
+from google.cloud.spanner_v1 import (
+    Type,
+    StructType,
+    TypeCode,
+    ResultSetMetadata,
+    PartialResultSet,
+)
+
+from google.cloud.spanner_v1._helpers import _make_value_pb
+from google.cloud.spanner_v1.streamed import StreamedResultSet
+
+CONNECTION_CLOSED_ERROR = "This connection is closed"
+TRANSACTION_NOT_STARTED_WARNING = (
+    "This method is non-operational as a transaction has not been started."
+)
+
+
+def execute(cursor: "Cursor", parsed_statement: ParsedStatement):
+    """Executes the client side statements by calling the relevant method.
+
+    It is an internal method that can make backwards-incompatible changes.
+
+    :type cursor: Cursor
+    :param cursor: Cursor object of the dbApi
+
+    :type parsed_statement: ParsedStatement
+    :param parsed_statement: parsed_statement based on the sql query
+    """
+    connection = cursor.connection
+    column_values = []
+    if connection.is_closed:
+        raise ProgrammingError(CONNECTION_CLOSED_ERROR)
+    statement_type = parsed_statement.client_side_statement_type
+    if statement_type == ClientSideStatementType.COMMIT:
+        connection.commit()
+        return None
+    if statement_type == ClientSideStatementType.BEGIN:
+        connection.begin(isolation_level=_get_isolation_level(parsed_statement))
+        return None
+    if statement_type == ClientSideStatementType.ROLLBACK:
+        connection.rollback()
+        return None
+    if statement_type == ClientSideStatementType.SHOW_COMMIT_TIMESTAMP:
+        if (
+            connection._transaction is not None
+            and connection._transaction.committed is not None
+        ):
+            column_values.append(connection._transaction.committed)
+        return _get_streamed_result_set(
+            ClientSideStatementType.SHOW_COMMIT_TIMESTAMP.name,
+            TypeCode.TIMESTAMP,
+            column_values,
+        )
+    if statement_type == ClientSideStatementType.SHOW_READ_TIMESTAMP:
+        if (
+            connection._snapshot is not None
+            and connection._snapshot._transaction_read_timestamp is not None
+        ):
+            column_values.append(connection._snapshot._transaction_read_timestamp)
+        return _get_streamed_result_set(
+            ClientSideStatementType.SHOW_READ_TIMESTAMP.name,
+            TypeCode.TIMESTAMP,
+            column_values,
+        )
+    if statement_type == ClientSideStatementType.START_BATCH_DML:
+        connection.start_batch_dml(cursor)
+        return None
+    if statement_type == ClientSideStatementType.RUN_BATCH:
+        return connection.run_batch()
+    if statement_type == ClientSideStatementType.ABORT_BATCH:
+        return connection.abort_batch()
+    if statement_type == ClientSideStatementType.PARTITION_QUERY:
+        partition_ids = connection.partition_query(parsed_statement)
+        return _get_streamed_result_set(
+            "PARTITION",
+            TypeCode.STRING,
+            partition_ids,
+        )
+    if statement_type == ClientSideStatementType.RUN_PARTITION:
+        return connection.run_partition(
+            parsed_statement.client_side_statement_params[0]
+        )
+    if statement_type == ClientSideStatementType.RUN_PARTITIONED_QUERY:
+        return connection.run_partitioned_query(parsed_statement)
+    if statement_type == ClientSideStatementType.SET_AUTOCOMMIT_DML_MODE:
+        return connection._set_autocommit_dml_mode(parsed_statement)
+
+
+def _get_streamed_result_set(column_name, type_code, column_values):
+    struct_type_pb = StructType(
+        fields=[StructType.Field(name=column_name, type_=Type(code=type_code))]
+    )
+
+    result_set = PartialResultSet(metadata=ResultSetMetadata(row_type=struct_type_pb))
+    if len(column_values) > 0:
+        column_values_pb = []
+        for column_value in 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

@@ -0,0 +1,106 @@
+# Copyright 2023 Google LLC All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import re
+
+from google.cloud.spanner_dbapi.parsed_statement import (
+    ParsedStatement,
+    StatementType,
+    ClientSideStatementType,
+    Statement,
+)
+
+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)\s*$", re.IGNORECASE
+)
+RE_SHOW_READ_TIMESTAMP = re.compile(
+    r"^\s*(SHOW)\s+(VARIABLE)\s+(READ_TIMESTAMP)\s*$", 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(
+    r"^\s*(RUN)\s+(PARTITIONED)\s+(QUERY)\s+(.+)", re.IGNORECASE
+)
+RE_SET_AUTOCOMMIT_DML_MODE = re.compile(
+    r"^\s*(SET)\s+(AUTOCOMMIT_DML_MODE)\s+(=)\s+(.+)", re.IGNORECASE
+)
+
+
+def parse_stmt(query):
+    """Parses the sql query to check if it matches with any of the client side
+        statement regex.
+
+    It is an internal method that can make backwards-incompatible changes.
+
+    :type query: str
+    :param query: sql query
+
+    :rtype: ParsedStatement
+    :returns: ParsedStatement object.
+    """
+    client_side_statement_type = None
+    client_side_statement_params = []
+    if RE_COMMIT.match(query):
+        client_side_statement_type = ClientSideStatementType.COMMIT
+    elif RE_ROLLBACK.match(query):
+        client_side_statement_type = ClientSideStatementType.ROLLBACK
+    elif RE_SHOW_COMMIT_TIMESTAMP.match(query):
+        client_side_statement_type = ClientSideStatementType.SHOW_COMMIT_TIMESTAMP
+    elif RE_SHOW_READ_TIMESTAMP.match(query):
+        client_side_statement_type = ClientSideStatementType.SHOW_READ_TIMESTAMP
+    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
+    elif RE_ABORT_BATCH.match(query):
+        client_side_statement_type = ClientSideStatementType.ABORT_BATCH
+    elif RE_RUN_PARTITIONED_QUERY.match(query):
+        match = re.search(RE_RUN_PARTITIONED_QUERY, query)
+        client_side_statement_params.append(match.group(4))
+        client_side_statement_type = ClientSideStatementType.RUN_PARTITIONED_QUERY
+    elif RE_PARTITION_QUERY.match(query):
+        match = re.search(RE_PARTITION_QUERY, query)
+        client_side_statement_params.append(match.group(2))
+        client_side_statement_type = ClientSideStatementType.PARTITION_QUERY
+    elif RE_RUN_PARTITION.match(query):
+        match = re.search(RE_RUN_PARTITION, query)
+        client_side_statement_params.append(match.group(3))
+        client_side_statement_type = ClientSideStatementType.RUN_PARTITION
+    elif RE_SET_AUTOCOMMIT_DML_MODE.match(query):
+        match = re.search(RE_SET_AUTOCOMMIT_DML_MODE, query)
+        client_side_statement_params.append(match.group(4))
+        client_side_statement_type = ClientSideStatementType.SET_AUTOCOMMIT_DML_MODE
+    if client_side_statement_type is not None:
+        return ParsedStatement(
+            StatementType.CLIENT_SIDE,
+            Statement(query),
+            client_side_statement_type,
+            client_side_statement_params,
+        )
+    return None