feat(dbapi): commit and rollback

Author: danielebriggi

.gitignore

@@ -15,3 +15,6 @@ main.dSYM/
 SqliteCloud.egg-info
 
 playground.ipynb
+
+src/tests/assets/*-shm
+src/tests/assets/*-wal

src/sqlitecloud/dbapi2.py

@@ -3,6 +3,7 @@
 # PEP 249 – Python Database API Specification v2.0
 # https://peps.python.org/pep-0249/
 #
+import logging
 from typing import (
     Any,
     Callable,
@@ -123,10 +124,10 @@ class Connection:
 
     row_factory: Optional[Callable[["Cursor", Tuple], object]] = None
 
-    def __init__(self, SQLiteCloud_connection: SQLiteCloudConnect) -> None:
+    def __init__(self, sqlitecloud_connection: SQLiteCloudConnect) -> None:
         self._driver = Driver()
         self.row_factory = None
-        self.SQLiteCloud_connection = SQLiteCloud_connection
+        self.sqlitecloud_connection = sqlitecloud_connection
 
     @property
     def sqlcloud_connection(self) -> SQLiteCloudConnect:
@@ -136,7 +137,7 @@ def sqlcloud_connection(self) -> SQLiteCloudConnect:
         Returns:
             SQLiteCloudConnect: The SQLite Cloud connection object.
         """
-        return self.SQLiteCloud_connection
+        return self.sqlitecloud_connection
 
     def execute(
         self,
@@ -194,17 +195,42 @@ def close(self):
             DB-API 2.0 interface does not manage the Sqlite Cloud PubSub feature.
             Therefore, only the main socket is closed.
         """
-        self._driver.disconnect(self.SQLiteCloud_connection, True)
+        self._driver.disconnect(self.sqlitecloud_connection, True)
 
     def commit(self):
         """
-        Not implementied yet.
+        Commit any pending transactions on database.
         """
+        try:
+            self._driver.execute("COMMIT;", self.sqlitecloud_connection)
+        except SQLiteCloudException as e:
+            if (
+                e.errcode == 1
+                and e.xerrcode == 1
+                and "no transaction is active" in e.errmsg
+            ):
+                # compliance to sqlite3
+                logging.warning(e)
 
     def rollback(self):
         """
-        Not implemented yet.
-        """
+        Causes the database to roll back to the start of any pending transaction.
+        A transaction will also rool back if the database is closed or if an error occurs
+        and the roll back conflict resolution algorithm is specified.
+
+        See the documentation on the `ON CONFLICT <https://docs.sqlitecloud.io/docs/sqlite/lang_conflict>`
+        clause for additional information about the ROLLBACK conflict resolution algorithm.
+        """
+        try:
+            self._driver.execute("ROLLBACK;", self.sqlitecloud_connection)
+        except SQLiteCloudException as e:
+            if (
+                e.errcode == 1
+                and e.xerrcode == 1
+                and "no transaction is active" in e.errmsg
+            ):
+                # compliance to sqlite3
+                logging.warning(e)
 
     def cursor(self):
         """

src/tests/conftest.py

@@ -35,6 +35,16 @@ def sqlitecloud_connection():
 
 @pytest.fixture()
 def sqlitecloud_dbapi2_connection():
+    # fixture and declaration are split to be able
+    # to create multiple instances of the connection
+    # when calling the getter function directly from
+    # the test.
+    # Fixtures are both cached and cannot be called
+    # directly whithin the test.
+    yield next(get_sqlitecloud_dbapi2_connection())
+
+
+def get_sqlitecloud_dbapi2_connection():
     account = SQLiteCloudAccount()
     account.username = os.getenv("SQLITE_USER")
     account.password = os.getenv("SQLITE_PASSWORD")

src/tests/integration/test_dbapi2.py

@@ -246,3 +246,21 @@ def test_row_factory(self, sqlitecloud_dbapi2_connection):
         assert row["AlbumId"] == 1
         assert row["Title"] == "For Those About To Rock We Salute You"
         assert row["ArtistId"] == 1
+
+    def test_commit_without_any_transaction_does_not_raise_exception(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        connection.commit()
+
+        assert True
+
+    def test_rollback_without_any_transaction_does_not_raise_exception(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        connection.rollback()
+
+        assert True

src/tests/integration/test_sqlite3_parity.py

@@ -1,16 +1,25 @@
 import os
 import sqlite3
+import time
 
 import pytest
 
+import sqlitecloud
 from sqlitecloud.datatypes import SQLiteCloudException
+from tests.conftest import get_sqlitecloud_dbapi2_connection
 
 
 class TestSQLite3FeatureParity:
     @pytest.fixture()
     def sqlite3_connection(self):
+        yield next(self.get_sqlite3_connection())
+
+    def get_sqlite3_connection(self):
+        # set isolation_level=None to enable autocommit
+        # and to be aligned with the behavior of SQLite Cloud
         connection = sqlite3.connect(
-            os.path.join(os.path.dirname(__file__), "../assets/chinook.sqlite")
+            os.path.join(os.path.dirname(__file__), "../assets/chinook.sqlite"),
+            isolation_level=None,
         )
         yield connection
         connection.close()
@@ -243,3 +252,73 @@ def test_fetchall(self, sqlitecloud_dbapi2_connection, sqlite3_connection):
         assert sqlitecloud_results == sqlite3_results
         assert len(sqlitecloud_results) == 0
         assert len(sqlite3_results) == 0
+
+    def test_autocommit_mode_enabled_by_default(
+        self, sqlitecloud_dbapi2_connection, sqlite3_connection
+    ):
+        seed = str(int(time.time()))
+
+        connections = [
+            (sqlitecloud_dbapi2_connection, next(get_sqlitecloud_dbapi2_connection())),
+            (sqlite3_connection, next(self.get_sqlite3_connection())),
+        ]
+
+        for (connection, control_connection) in connections:
+            connection.execute(
+                "INSERT INTO albums (Title, ArtistId) VALUES (? , 1);",
+                (f"Test {seed}",),
+            )
+
+            cursor2 = control_connection.execute(
+                "SELECT * FROM albums WHERE Title = ?", (f"Test {seed}",)
+            )
+            assert cursor2.fetchone() is not None
+
+    def test_explicit_transaction_to_commit(
+        self,
+        sqlitecloud_dbapi2_connection: sqlitecloud.Connection,
+        sqlite3_connection: sqlite3.Connection,
+    ):
+        seed = str(int(time.time()))
+
+        connections = [
+            (sqlitecloud_dbapi2_connection, next(get_sqlitecloud_dbapi2_connection())),
+            (sqlite3_connection, next(self.get_sqlite3_connection())),
+        ]
+
+        for (connection, control_connection) in connections:
+            cursor1 = connection.execute("BEGIN;")
+            cursor1.execute(
+                "INSERT INTO albums (Title, ArtistId) VALUES (?, 1);", (f"Test {seed}",)
+            )
+
+            cursor2 = control_connection.execute(
+                "SELECT * FROM albums WHERE Title = ?", (f"Test {seed}",)
+            )
+            assert cursor2.fetchone() is None
+
+            connection.commit()
+
+            cursor2.execute("SELECT * FROM albums WHERE Title = ?", (f"Test {seed}",))
+            assert cursor2.fetchone() is not None
+
+    def test_explicit_transaction_to_rollback(
+        self,
+        sqlitecloud_dbapi2_connection: sqlitecloud.Connection,
+        sqlite3_connection: sqlite3.Connection,
+    ):
+        seed = str(int(time.time()))
+
+        for connection in [sqlitecloud_dbapi2_connection, sqlite3_connection]:
+            cursor1 = connection.execute("BEGIN;")
+            cursor1.execute(
+                "INSERT INTO albums (Title, ArtistId) VALUES (?, 1);", (f"Test {seed}",)
+            )
+
+            cursor1.execute("SELECT * FROM albums WHERE Title = ?", (f"Test {seed}",))
+            assert cursor1.fetchone() is not None
+
+            connection.rollback()
+
+            cursor1.execute("SELECT * FROM albums WHERE Title = ?", (f"Test {seed}",))
+            assert cursor1.fetchone() is None