feat(rowcount): support to rowcount, lastworid and total_changes

Author: danielebriggi

src/sqlitecloud/dbapi2.py

@@ -32,6 +32,7 @@
 from sqlitecloud.resultset import (
     SQLITECLOUD_RESULT_TYPE,
     SQLITECLOUD_VALUE_TYPE,
+    SQLiteCloudOperationResult,
     SQLiteCloudResult,
 )
 
@@ -199,6 +200,8 @@ def __init__(
 
         self.detect_types = detect_types
 
+        self.total_changes = 0
+
     @property
     def sqlcloud_connection(self) -> SQLiteCloudConnect:
         """
@@ -347,6 +350,7 @@ def __init__(self, connection: Connection) -> None:
         self._connection = connection
         self._iter_row: int = 0
         self._resultset: SQLiteCloudResult = None
+        self._result_operation: SQLiteCloudOperationResult = None
 
         self.row_factory: Optional[Callable[["Cursor", Tuple], object]] = None
 
@@ -402,21 +406,26 @@ def description(
     @property
     def rowcount(self) -> int:
         """
-        The number of rows that the last .execute*() produced (for DQL statements like SELECT)
-
-        The number of rows affected by DML statements like UPDATE or INSERT is not supported.
-
-        Returns:
-            int: The number of rows in the result set or -1 if no result set is available.
+        The number of rows that the last .execute*() returned for DQL statements like SELECT or
+        the number rows affected by DML statements like UPDATE, INSERT and DELETE.
         """
-        return self._resultset.nrows if self._is_result_rowset() else -1
+        if self._is_result_rowset():
+            return self._resultset.nrows
+        if self._is_result_operation():
+            return self._result_operation.changes
+        return -1
 
     @property
     def lastrowid(self) -> Optional[int]:
         """
-        Not implemented yet in the library.
+        Last rowid for DML operations (INSERT, UPDATE, DELETE).
+        In case of `executemany()` it returns the last rowid of the last operation.
         """
-        return None
+        return (
+            self._result_operation.rowid
+            if self._result_operation and self._result_operation.rowid > 0
+            else None
+        )
 
     def close(self) -> None:
         """
@@ -430,7 +439,7 @@ def close(self) -> None:
     def execute(
         self,
         sql: str,
-        parameters: Union[Tuple[any], Dict[Union[str, int], any]] = (),
+        parameters: Union[Tuple[Any], Dict[Union[str, int], Any]] = (),
     ) -> "Cursor":
         """
         Prepare and execute a SQL statement (either a query or command) to the SQLite Cloud database.
@@ -459,19 +468,26 @@ def execute(
 
         parameters = self._adapt_parameters(parameters)
 
-        prepared_statement = self._driver.prepare_statement(sql, parameters)
-        result = self._driver.execute(
-            prepared_statement, self.connection.sqlcloud_connection
+        # TODO: convert parameters from :name to `?` style
+        result = self._driver.execute_statement(
+            sql, parameters, self.connection.sqlcloud_connection
         )
 
-        self._resultset = result
+        self._resultset = None
+        self._result_operation = None
+
+        if isinstance(result, SQLiteCloudResult):
+            self._resultset = result
+        if isinstance(result, SQLiteCloudOperationResult):
+            self._result_operation = result
+            self._connection.total_changes = result.total_changes
 
         return self
 
     def executemany(
         self,
         sql: str,
-        seq_of_parameters: Iterable[Union[Tuple[any], Dict[Union[str, int], any]]],
+        seq_of_parameters: Iterable[Union[Tuple[Any], Dict[Union[str, int], Any]]],
     ) -> "Cursor":
         """
         Executes a SQL statement multiple times, each with a different set of parameters.
@@ -489,13 +505,16 @@ def executemany(
         self._ensure_connection()
 
         commands = ""
+        params = []
         for parameters in seq_of_parameters:
-            parameters = self._adapt_parameters(parameters)
+            params += list(parameters)
 
-            prepared_statement = self._driver.prepare_statement(sql, parameters)
-            commands += prepared_statement + ";"
+            if not sql.endswith(";"):
+                sql += ";"
 
-        self.execute(commands)
+            commands += sql
+
+        self.execute(commands, params)
 
         return self
 
@@ -578,6 +597,9 @@ def _is_result_rowset(self) -> bool:
             and self._resultset.tag == SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET
         )
 
+    def _is_result_operation(self) -> bool:
+        return self._result_operation is not None
+
     def _ensure_connection(self):
         """
         Ensure the cursor is usable or has been closed.
@@ -697,7 +719,8 @@ def __iter__(self) -> "Cursor":
 
     def __next__(self) -> Optional[Tuple[Any]]:
         if (
-            not self._resultset.is_result
+            self._resultset
+            and not self._resultset.is_result
             and self._resultset.data
             and self._iter_row < self._resultset.nrows
         ):

src/tests/integration/test_dbapi2.py

@@ -259,3 +259,191 @@ def test_row_object_for_factory_string_representation(
         row = cursor.fetchone()
 
         assert str(row) == "Bar: foo\nDoe: john"
+
+    def test_last_rowid_and_rowcount_with_select(self, sqlitecloud_dbapi2_connection):
+        connection = sqlitecloud_dbapi2_connection
+
+        cursor = connection.execute("SELECT * FROM genres LIMIT 3")
+
+        assert cursor.fetchone() is not None
+        assert cursor.lastrowid is None
+        assert cursor.rowcount == 3
+
+    def test_last_rowid_and_rowcount_with_execute_update(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name = "Jazz" + str(uuid.uuid4())
+        genreId = 2
+
+        cursor = connection.execute(
+            "UPDATE genres SET Name = ? WHERE GenreId = ?",
+            (new_name, genreId),
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid is None
+        assert cursor.rowcount == 1
+
+    def test_last_rowid_and_rowcount_with_execute_insert(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name = "Jazz" + str(uuid.uuid4())
+
+        cursor = connection.execute(
+            "INSERT INTO genres (Name) VALUES (?)",
+            (new_name,),
+        )
+
+        last_result = connection.execute(
+            "SELECT GenreId FROM genres WHERE Name = ?", (new_name,)
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid == last_result.fetchone()[0]
+        assert cursor.rowcount == 1
+
+    def test_last_rowid_and_rowcount_with_execute_delete(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name = "Jazz" + str(uuid.uuid4())
+
+        cursor_select = connection.execute(
+            "INSERT INTO genres (Name) VALUES (?)",
+            (new_name,),
+        )
+
+        cursor = connection.execute("DELETE FROM genres WHERE Name = ?", (new_name,))
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid == cursor_select.lastrowid
+        assert cursor.rowcount == 1
+
+    def test_last_rowid_and_rowcount_with_multiple_updates(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name = "Jazz" + str(uuid.uuid4())
+
+        cursor = connection.execute(
+            "UPDATE genres SET Name = ? WHERE GenreId = ? or GenreId = ?",
+            (new_name, 2, 3),
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid is None
+        assert cursor.rowcount == 2
+
+    def test_last_rowid_and_rowcount_with_multiple_deletes(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name1 = "Jazz" + str(uuid.uuid4())
+        new_name2 = "Jazz" + str(uuid.uuid4())
+
+        cursor = connection.executemany(
+            "INSERT INTO genres (Name) VALUES (?)",
+            [(new_name1,), (new_name2,)],
+        )
+
+        cursor = connection.execute(
+            "DELETE FROM genres WHERE Name = ? or Name = ?", (new_name1, new_name2)
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid > 0
+        assert cursor.rowcount == 2
+
+    def test_last_rowid_and_rowcount_with_executemany_updates(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name1 = "Jazz" + str(uuid.uuid4())
+        new_name2 = "Jazz" + str(uuid.uuid4())
+        genreId = 2
+
+        cursor = connection.executemany(
+            "UPDATE genres SET Name = ? WHERE GenreId = ?;",
+            [(new_name1, genreId), (new_name2, genreId)],
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid is None
+        assert cursor.rowcount == 1
+
+    def test_last_rowid_and_rowcount_with_executemany_inserts(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name1 = "Jazz" + str(uuid.uuid4())
+        new_name2 = "Jazz" + str(uuid.uuid4())
+
+        cursor = connection.executemany(
+            "INSERT INTO genres (Name) VALUES (?)",
+            [(new_name1,), (new_name2,)],
+        )
+
+        last_result = connection.execute(
+            "SELECT GenreId FROM genres WHERE Name = ?", (new_name2,)
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid == last_result.fetchone()[0]
+        assert cursor.rowcount == 1
+
+    def test_last_rowid_and_rowcount_with_executemany_deletes(
+        self, sqlitecloud_dbapi2_connection
+    ):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name1 = "Jazz" + str(uuid.uuid4())
+        new_name2 = "Jazz" + str(uuid.uuid4())
+
+        cursor_select = connection.executemany(
+            "INSERT INTO genres (Name) VALUES (?)",
+            [(new_name1,), (new_name2,)],
+        )
+
+        cursor = connection.executemany(
+            "DELETE FROM genres WHERE Name = ?", [(new_name1,), (new_name2,)]
+        )
+
+        assert cursor.fetchone() is None
+        assert cursor.lastrowid == cursor_select.lastrowid
+        assert cursor.rowcount == 1
+
+    def test_connection_total_changes(self, sqlitecloud_dbapi2_connection):
+        connection = sqlitecloud_dbapi2_connection
+
+        new_name1 = "Jazz" + str(uuid.uuid4())
+        new_name2 = "Jazz" + str(uuid.uuid4())
+        new_name3 = "Jazz" + str(uuid.uuid4())
+
+        connection.executemany(
+            "INSERT INTO genres (Name) VALUES (?)",
+            [(new_name1,), (new_name2,)],
+        )
+        assert connection.total_changes == 2
+
+        connection.execute("SELECT * FROM genres")
+        assert connection.total_changes == 2
+
+        connection.execute(
+            "UPDATE genres SET Name = ? WHERE Name = ?", (new_name3, new_name1)
+        )
+        assert connection.total_changes == 3
+
+        connection.execute(
+            "DELETE FROM genres WHERE Name in (?, ?, ?)",
+            (new_name1, new_name2, new_name3),
+        )
+        assert connection.total_changes == 5