feat: Implementing client side statements in dbapi (starting with commit)

google/cloud/spanner_dbapi/client_side_statement_executor.py

@@ -0,0 +1,29 @@
+# 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 google.cloud.spanner_dbapi.parsed_statement import (
+ ParsedStatement,
+ ClientSideStatementType,
+)
+
+
+def execute(connection, 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 parsed_statement: ParsedStatement
+ :param parsed_statement: parsed_statement based on the sql query
+ """
+ if parsed_statement.client_side_statement_type == ClientSideStatementType.COMMIT:
+ return connection.commit()

google/cloud/spanner_dbapi/client_side_statement_parser.py

@@ -0,0 +1,42 @@
+# 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,
+)
+
+RE_COMMIT = re.compile(r"^\s*(COMMIT)(TRANSACTION)?", 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.
+ """
+ if RE_COMMIT.match(query):
+ return ParsedStatement(
+ StatementType.CLIENT_SIDE, query, ClientSideStatementType.COMMIT
+ )
+ return None

google/cloud/spanner_dbapi/cursor.py

@@ -32,13 +32,14 @@
 from google.cloud.spanner_dbapi.exceptions import OperationalError
 from google.cloud.spanner_dbapi.exceptions import ProgrammingError
 
-from google.cloud.spanner_dbapi import _helpers
+from google.cloud.spanner_dbapi import _helpers, client_side_statement_executor
 from google.cloud.spanner_dbapi._helpers import ColumnInfo
 from google.cloud.spanner_dbapi._helpers import CODE_TO_DISPLAY_SIZE
 
 from google.cloud.spanner_dbapi import parse_utils
 from google.cloud.spanner_dbapi.parse_utils import get_param_types
 from google.cloud.spanner_dbapi.parse_utils import sql_pyformat_args_to_spanner
+from google.cloud.spanner_dbapi.parsed_statement import StatementType
 from google.cloud.spanner_dbapi.utils import PeekIterator
 from google.cloud.spanner_dbapi.utils import StreamedManyResultSets
 
@@ -210,7 +211,10 @@ def _batch_DDLs(self, sql):
  for ddl in sqlparse.split(sql):
  if ddl:
  ddl = ddl.rstrip(";")
- if parse_utils.classify_stmt(ddl) != parse_utils.STMT_DDL:
+ if (
+ parse_utils.classify_statement(ddl).statement_type
+ != StatementType.DDL
+ ):
  raise ValueError("Only DDL statements may be batched.")
 
  statements.append(ddl)
@@ -239,8 +243,12 @@ def execute(self, sql, args=None):
  self._handle_DQL(sql, args or None)
  return
 
- class_ = parse_utils.classify_stmt(sql)
- if class_ == parse_utils.STMT_DDL:
+ parsed_statement = parse_utils.classify_statement(sql)
+ if parsed_statement.statement_type == StatementType.CLIENT_SIDE:
+ return client_side_statement_executor.execute(
+ self.connection, parsed_statement
+ )
+ if parsed_statement.statement_type == StatementType.DDL:
  self._batch_DDLs(sql)
  if self.connection.autocommit:
  self.connection.run_prior_DDL_statements()
@@ -251,7 +259,7 @@ def execute(self, sql, args=None):
  # self._run_prior_DDL_statements()
  self.connection.run_prior_DDL_statements()
 
- if class_ == parse_utils.STMT_UPDATING:
+ if parsed_statement.statement_type == StatementType.UPDATE:
  sql = parse_utils.ensure_where_clause(sql)
 
  sql, args = sql_pyformat_args_to_spanner(sql, args or None)
@@ -276,7 +284,7 @@ def execute(self, sql, args=None):
  self.connection.retry_transaction()
  return
 
- if class_ == parse_utils.STMT_NON_UPDATING:
+ if parsed_statement.statement_type == StatementType.QUERY:
  self._handle_DQL(sql, args or None)
  else:
  self.connection.database.run_in_transaction(
@@ -309,19 +317,29 @@ def executemany(self, operation, seq_of_params):
  self._result_set = None
  self._row_count = _UNSET_COUNT
 
-class_ = parse_utils.classify_stmt(operation)
- if class_ == parse_utils.STMT_DDL:
+parsed_statement = parse_utils.classify_statement(operation)
+ if parsed_statement.statement_type == StatementType.DDL:
  raise ProgrammingError(
  "Executing DDL statements with executemany() method is not allowed."
  )
 
+ if parsed_statement.statement_type == StatementType.CLIENT_SIDE:
+ raise ProgrammingError(
+ "Executing the following operation: "
+ + operation
+ + ", with executemany() method is not allowed."
+ )
+
  # For every operation, we've got to ensure that any prior DDL
  # statements were run.
  self.connection.run_prior_DDL_statements()
 
  many_result_set = StreamedManyResultSets()
 
- if class_ in (parse_utils.STMT_INSERT, parse_utils.STMT_UPDATING):
+ if parsed_statement.statement_type in (
+ StatementType.INSERT,
+ StatementType.UPDATE,
+ ):
  statements = []
 
  for params in seq_of_params:

google/cloud/spanner_dbapi/parse_utils.py

@@ -21,8 +21,11 @@
 import sqlparse
 from google.cloud import spanner_v1 as spanner
 from google.cloud.spanner_v1 import JsonObject
+from . import client_side_statement_parser
+from deprecated import deprecated
 
 from .exceptions import Error
+from .parsed_statement import ParsedStatement, StatementType
 from .types import DateStr, TimestampStr
 from .utils import sanitize_literals_for_upload
 
@@ -174,12 +177,11 @@
 RE_PYFORMAT = re.compile(r"(%s|%\([^\(\)]+\)s)+", re.DOTALL)
 
 
+@deprecated(reason="This method is deprecated. Use _classify_stmt method")
 def classify_stmt(query):
  """Determine SQL query type.
-
  :type query: str
  :param query: A SQL query.
-
  :rtype: str
  :returns: The query type name.
  """
@@ -203,6 +205,39 @@ def classify_stmt(query):
  return STMT_UPDATING
 
 
+def classify_statement(query):
+ """Determine SQL query type.
+
+ It is an internal method that can make backwards-incompatible changes.
+
+ :type query: str
+ :param query: A SQL query.
+
+ :rtype: ParsedStatement
+ :returns: parsed statement attributes.
+ """
+ # sqlparse will strip Cloud Spanner comments,
+ # still, special commenting styles, like
+ # PostgreSQL dollar quoted comments are not
+ # supported and will not be stripped.
+ query = sqlparse.format(query, strip_comments=True).strip()
+ parsed_statement = client_side_statement_parser.parse_stmt(query)
+ if parsed_statement is not None:
+ return parsed_statement
+ if RE_DDL.match(query):
+ return ParsedStatement(StatementType.DDL, query)
+
+ if RE_IS_INSERT.match(query):
+ return ParsedStatement(StatementType.INSERT, query)
+
+ if RE_NON_UPDATE.match(query) or RE_WITH.match(query):
+ # As of 13-March-2020, Cloud Spanner only supports WITH for DQL
+ # statements and doesn't yet support WITH for DML statements.
+ return ParsedStatement(StatementType.QUERY, query)
+
+ return ParsedStatement(StatementType.UPDATE, query)
+
+
 def sql_pyformat_args_to_spanner(sql, params):
  """
  Transform pyformat set SQL to named arguments for Cloud Spanner.

google/cloud/spanner_dbapi/parsed_statement.py

@@ -0,0 +1,36 @@
+# Copyright 20203 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 dataclasses import dataclass
+from enum import Enum
+
+
+class StatementType(Enum):
+ CLIENT_SIDE = 1
+ DDL = 2
+ QUERY = 3
+ UPDATE = 4
+ INSERT = 5
+
+
+class ClientSideStatementType(Enum):
+ COMMIT = 1
+ BEGIN = 2
+
+
+@dataclass
+class ParsedStatement:
+ statement_type: StatementType
+ query: str
+ client_side_statement_type: ClientSideStatementType = None

setup.py

@@ -42,6 +42,7 @@
  "proto-plus >= 1.22.0, <2.0.0dev",
  "sqlparse >= 0.4.4",
  "protobuf>=3.19.5,<5.0.0dev,!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5",
+ "deprecated >= 1.2.14",
 ]
 extras = {
  "tracing": [

tests/system/test_dbapi.py

@@ -20,6 +20,8 @@
 
 from google.cloud import spanner_v1
 from google.cloud._helpers import UTC
+
+from google.cloud.spanner_dbapi import Cursor
 from google.cloud.spanner_dbapi.connection import connect
 from google.cloud.spanner_dbapi.connection import Connection
 from google.cloud.spanner_dbapi.exceptions import ProgrammingError
@@ -72,37 +74,11 @@ def dbapi_database(raw_database):
 
 def test_commit(shared_instance, dbapi_database):
  """Test committing a transaction with several statements."""
- want_row = (
- 1,
- "updated-first-name",
- "last-name",
- "test.email_updated@domen.ru",
- )
  # connect to the test database
  conn = Connection(shared_instance, dbapi_database)
  cursor = conn.cursor()
 
- # execute several DML statements within one transaction
- cursor.execute(
- """
-INSERT INTO contacts (contact_id, first_name, last_name, email)
-VALUES (1, 'first-name', 'last-name', 'test.email@domen.ru')
- """
- )
- cursor.execute(
- """
-UPDATE contacts
-SET first_name = 'updated-first-name'
-WHERE first_name = 'first-name'
-"""
- )
- cursor.execute(
- """
-UPDATE contacts
-SET email = 'test.email_updated@domen.ru'
-WHERE email = 'test.email@domen.ru'
-"""
- )
+ want_row = _execute_common_precommit_statements(cursor)
  conn.commit()
 
  # read the resulting data from the database
@@ -116,6 +92,25 @@ def test_commit(shared_instance, dbapi_database):
  conn.close()
 
 
+def test_commit_client_side(shared_instance, dbapi_database):
+ """Test committing a transaction with several statements."""
+ # connect to the test database
+ conn = Connection(shared_instance, dbapi_database)
+ cursor = conn.cursor()
+
+ want_row = _execute_common_precommit_statements(cursor)
+ cursor.execute("""COMMIT""")
+
+ # read the resulting data from the database
+ cursor.execute("SELECT * FROM contacts")
+ got_rows = cursor.fetchall()
+ conn.commit()
+ cursor.close()
+ conn.close()
+
+ assert got_rows == [want_row]
+
+
 def test_rollback(shared_instance, dbapi_database):
  """Test rollbacking a transaction with several statements."""
  want_row = (2, "first-name", "last-name", "test.email@domen.ru")
@@ -810,3 +805,33 @@ def test_dml_returning_delete(shared_instance, dbapi_database, autocommit):
  assert cur.fetchone() == (1, "first-name")
  assert cur.rowcount == 1
  conn.commit()
+
+
+def _execute_common_precommit_statements(cursor: Cursor):
+ # execute several DML statements within one transaction
+ cursor.execute(
+ """
+ INSERT INTO contacts (contact_id, first_name, last_name, email)
+ VALUES (1, 'first-name', 'last-name', 'test.email@domen.ru')
+ """
+ )
+ cursor.execute(
+ """
+ UPDATE contacts
+ SET first_name = 'updated-first-name'
+ WHERE first_name = 'first-name'
+ """
+ )
+ cursor.execute(
+ """
+ UPDATE contacts
+ SET email = 'test.email_updated@domen.ru'
+ WHERE email = 'test.email@domen.ru'
+ """
+ )
+ return (
+ 1,
+ "updated-first-name",
+ "last-name",
+ "test.email_updated@domen.ru",
+ )