fix(types): respect types from SCSP

Rowset values are sent by the SCSP protocol with their sqlite3 detected type: values now respect this data type instead of the decltype

Fixed several tests

Author: danielebriggi

src/sqlitecloud/datatypes.py

@@ -5,6 +5,10 @@
 
 from .resultset import SQLiteCloudResultSet
 
+# SQLite supported data types
+SQLiteDataTypes = Union[str, int, float, bytes, None]
+
+
 # Basic types supported by SQLite Cloud APIs
 SQLiteCloudDataTypes = Union[str, int, bool, Dict[Union[str, int], Any], bytes, None]
 
@@ -249,6 +253,6 @@ class SQLiteCloudValue:
     """
 
     def __init__(self) -> None:
-        self.value: Optional[str] = None
+        self.value: Optional[SQLiteCloudDataTypes] = None
         self.len: int = 0
         self.cellsize: int = 0

src/sqlitecloud/dbapi2.py

@@ -23,7 +23,6 @@
     SQLiteCloudAccount,
     SQLiteCloudConfig,
     SQLiteCloudConnect,
-    SQLiteCloudDataTypes,
     SQLiteCloudException,
 )
 from sqlitecloud.driver import Driver
@@ -145,7 +144,7 @@ def register_adapter(
 
 class Connection:
     """
-    Represents a DB-APi 2.0 connection to the SQLite Cloud database.
+    Represents a DB-API 2.0 connection to the SQLite Cloud database.
 
     Args:
         SQLiteCloud_connection (SQLiteCloudConnect): The SQLite Cloud connection object.
@@ -155,13 +154,15 @@ class Connection:
         SQLiteCloud_connection (SQLiteCloudConnect): The SQLite Cloud connection object.
     """
 
-    row_factory: Optional[Callable[["Cursor", Tuple], object]] = None
-    text_factory: Union[Type[Union[str, bytes]], Callable[[bytes], object]] = str
-
     def __init__(self, sqlitecloud_connection: SQLiteCloudConnect) -> None:
         self._driver = Driver()
-        self.row_factory = None
         self.sqlitecloud_connection = sqlitecloud_connection
+
+        self.row_factory: Optional[Callable[["Cursor", Tuple], object]] = None
+        self.text_factory: Union[
+            Type[Union[str, bytes]], Callable[[bytes], object]
+        ] = str
+
         self.detect_types = 0
 
     @property
@@ -177,17 +178,15 @@ def sqlcloud_connection(self) -> SQLiteCloudConnect:
     def execute(
         self,
         sql: str,
-        parameters: Union[
-            Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]
-        ] = (),
+        parameters: Union[Tuple[any], Dict[Union[str, int], any]] = (),
     ) -> "Cursor":
         """
         Shortcut for cursor.execute().
         See the docstring of Cursor.execute() for more information.
 
         Args:
             sql (str): The SQL query to execute.
-            parameters (Union[Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]]):
+            parameters (Union[Tuple[any], Dict[Union[str, int], any]]):
                 The parameters to be used in the query. It can be a tuple or a dictionary. (Default ())
             conn (SQLiteCloudConnect): The connection object to use for executing the query.
 
@@ -200,19 +199,15 @@ def execute(
     def executemany(
         self,
         sql: str,
-        seq_of_parameters: Iterable[
-            Union[
-                Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]
-            ]
-        ],
+        seq_of_parameters: Iterable[Union[Tuple[any], Dict[Union[str, int], any]]],
     ) -> "Cursor":
         """
         Shortcut for cursor.executemany().
         See the docstring of Cursor.executemany() for more information.
 
         Args:
             sql (str): The SQL statement to execute.
-            seq_of_parameters (Iterable[Union[Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]]]):
+            seq_of_parameters (Iterable[Union[Tuple[any], Dict[Union[str, int], any]]]):
                 The sequence of parameter sets to bind to the SQL statement.
 
         Returns:
@@ -385,9 +380,7 @@ def close(self) -> None:
     def execute(
         self,
         sql: str,
-        parameters: Union[
-            Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]
-        ] = (),
+        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.
@@ -405,7 +398,7 @@ def execute(
 
         Args:
             sql (str): The SQL query to execute.
-            parameters (Union[Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]]):
+            parameters (Union[Tuple[any], Dict[Union[str, int], any]]):
                 The parameters to be used in the query. It can be a tuple or a dictionary. (Default ())
             conn (SQLiteCloudConnect): The connection object to use for executing the query.
 
@@ -428,11 +421,7 @@ def execute(
     def executemany(
         self,
         sql: str,
-        seq_of_parameters: Iterable[
-            Union[
-                Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]
-            ]
-        ],
+        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.
@@ -441,7 +430,7 @@ def executemany(
 
         Args:
             sql (str): The SQL statement to execute.
-            seq_of_parameters (Iterable[Union[Tuple[SQLiteCloudDataTypes], Dict[Union[str, int], SQLiteCloudDataTypes]]]):
+            seq_of_parameters (Iterable[Union[Tuple[any], Dict[Union[str, int], any]]]):
                 The sequence of parameter sets to bind to the SQL statement.
 
         Returns:
@@ -564,10 +553,11 @@ def _get_value(self, row: int, col: int) -> Optional[Any]:
 
             if self._connection.text_factory is bytes:
                 return value.encode("utf-8")
-            if self._connection.text_factory is str:
-                return value
-            # callable
-            return self._connection.text_factory(value.encode("utf-8"))
+            if self._connection.text_factory is not str and callable(
+                self._connection.text_factory
+            ):
+                return self._connection.text_factory(value.encode("utf-8"))
+            return value
 
         return self._resultset.get_value(row, col)
 

src/sqlitecloud/driver.py

@@ -862,6 +862,7 @@ def _internal_parse_value(self, buffer: bytes, index: int = 0) -> SQLiteCloudVal
             if cellsize is not None:
                 cellsize = 2
 
+            sqlitecloud_value.value = None
             sqlitecloud_value.len = len
             sqlitecloud_value.cellsize = cellsize
 
@@ -877,7 +878,11 @@ def _internal_parse_value(self, buffer: bytes, index: int = 0) -> SQLiteCloudVal
             len = nlen - 2
             cellsize = nlen
 
-            sqlitecloud_value.value = (buffer[index + 1 : index + 1 + len]).decode()
+            value = (buffer[index + 1 : index + 1 + len]).decode()
+
+            sqlitecloud_value.value = (
+                int(value) if c == SQLITECLOUD_CMD.INT.value else float(value)
+            )
             sqlitecloud_value.len
             sqlitecloud_value.cellsize = cellsize
 
@@ -886,7 +891,12 @@ def _internal_parse_value(self, buffer: bytes, index: int = 0) -> SQLiteCloudVal
         len = blen - 1 if c == SQLITECLOUD_CMD.ZEROSTRING.value else blen
         cellsize = blen + cstart - index
 
-        sqlitecloud_value.value = (buffer[cstart : cstart + len]).decode()
+        value = buffer[cstart : cstart + len]
+
+        if c == SQLITECLOUD_CMD.STRING.value or c == SQLITECLOUD_CMD.ZEROSTRING.value:
+            value = value.decode()
+
+        sqlitecloud_value.value = value
         sqlitecloud_value.len = len
         sqlitecloud_value.cellsize = cellsize
 

src/tests/integration/test_client.py

@@ -295,8 +295,8 @@ def test_array(self, sqlitecloud_connection):
         assert isinstance(result_array, list)
         assert len(result_array) == 5
         assert result_array[0] == "Hello World"
-        assert result_array[1] == "123456"
-        assert result_array[2] == "3.1415"
+        assert result_array[1] == 123456
+        assert result_array[2] == 3.1415
         assert result_array[3] is None
 
     def test_rowset(self, sqlitecloud_connection):
@@ -310,6 +310,19 @@ def test_rowset(self, sqlitecloud_connection):
         assert result.get_name(0) == "key"
         assert result.get_name(1) == "value"
 
+    def test_rowset_data_types(self, sqlitecloud_connection):
+        connection, client = sqlitecloud_connection
+
+        bindings = ("hello world", 15175, 3.14, b"bytes world", None)
+        result = client.exec_statement("SELECT ?, ?, ?, ?, ?", bindings, connection)
+
+        assert SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET == result.tag
+        assert result.get_value(0, 0) == "hello world"
+        assert result.get_value(0, 1) == 15175
+        assert result.get_value(0, 2) == 3.14
+        assert result.get_value(0, 3) == b"bytes world"
+        assert result.get_value(0, 4) is None
+
     def test_max_rows_option(self):
         account = SQLiteCloudAccount()
         account.hostname = os.getenv("SQLITE_HOST")
@@ -419,7 +432,7 @@ def test_serialized_operations(self, sqlitecloud_connection):
             assert 2 == rowset.ncols
             assert "count" == rowset.get_name(0)
             assert "string" == rowset.get_name(1)
-            assert str(i) == rowset.get_value(0, 0)
+            assert i == rowset.get_value(0, 0)
             assert rowset.version in [1, 2]
 
     def test_query_timeout(self):
@@ -504,7 +517,7 @@ def test_select_results_with_no_column_name(self, sqlitecloud_connection):
         assert rowset.ncols == 2
         assert rowset.get_name(0) == "42"
         assert rowset.get_name(1) == "'hello'"
-        assert rowset.get_value(0, 0) == "42"
+        assert rowset.get_value(0, 0) == 42
         assert rowset.get_value(0, 1) == "hello"
 
     def test_select_long_formatted_string(self, sqlitecloud_connection):

src/tests/integration/test_sqlite3_parity.py

@@ -266,7 +266,7 @@ def test_autocommit_mode_enabled_by_default(
 
         connections = [
             (sqlitecloud_dbapi2_connection, next(get_sqlitecloud_dbapi2_connection())),
-            (sqlite3_connection, next(self.get_sqlite3_connection())),
+            (sqlite3_connection, next(get_sqlite3_connection())),
         ]
 
         for (connection, control_connection) in connections:
@@ -289,7 +289,7 @@ def test_explicit_transaction_to_commit(
 
         connections = [
             (sqlitecloud_dbapi2_connection, next(get_sqlitecloud_dbapi2_connection())),
-            (sqlite3_connection, next(self.get_sqlite3_connection())),
+            (sqlite3_connection, next(get_sqlite3_connection())),
         ]
 
         for (connection, control_connection) in connections:
@@ -333,8 +333,7 @@ def test_text_factory_with_default_string(
         self, sqlitecloud_dbapi2_connection, sqlite3_connection
     ):
         for connection in [sqlitecloud_dbapi2_connection, sqlite3_connection]:
-            # by default is string
-            # connection.text_factory = str
+            # by default is string: connection.text_factory = str
 
             austria = "\xd6sterreich"
 

src/tests/unit/test_dbapi2.py

@@ -105,9 +105,14 @@ def test_rowcount_with_no_resultset(self, mocker):
         assert cursor.rowcount == -1
 
     def test_execute_escaped(self, mocker: MockerFixture):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        apply_adapter_mock = mocker.patch.object(connection, "_apply_adapter")
+        apply_adapter_mock.return_value = "John's"
+
         execute_mock = mocker.patch.object(Driver, "execute")
 
+        cursor = Cursor(connection)
+
         sql = "SELECT * FROM users WHERE name = ?"
         parameters = ("John's",)
 
@@ -157,7 +162,10 @@ def test_fetchone_with_result(self, mocker):
         assert cursor.fetchone() is None
 
     def test_fetchone_with_rowset(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -195,7 +203,10 @@ def test_fetchmany_with_result(self, mocker):
         assert cursor.fetchmany() == []
 
     def test_fetchmany_with_rowset_and_default_size(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -207,7 +218,10 @@ def test_fetchmany_with_rowset_and_default_size(self, mocker):
         assert cursor.fetchmany(None) == [("myname1",)]
 
     def test_fetchmany_twice_to_retrieve_whole_rowset(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -220,7 +234,10 @@ def test_fetchmany_twice_to_retrieve_whole_rowset(self, mocker):
         assert cursor.fetchmany() == []
 
     def test_fetchmany_with_size_higher_than_rowcount(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -245,7 +262,10 @@ def test_fetchall_with_result(self, mocker):
         assert cursor.fetchall() == []
 
     def test_fetchall_with_rowset(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -257,7 +277,10 @@ def test_fetchall_with_rowset(self, mocker):
         assert cursor.fetchall() == [("myname1",), ("myname2",), ("myname3",)]
 
     def test_fetchall_twice_and_expect_empty_list(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -270,7 +293,10 @@ def test_fetchall_twice_and_expect_empty_list(self, mocker):
         assert cursor.fetchall() == []
 
     def test_fetchall_to_return_remaining_rows(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1
@@ -283,7 +309,10 @@ def test_fetchall_to_return_remaining_rows(self, mocker):
         assert cursor.fetchall() == [("myname2",)]
 
     def test_iterator(self, mocker):
-        cursor = Cursor(mocker.patch("sqlitecloud.Connection"))
+        connection = mocker.patch("sqlitecloud.Connection")
+        connection.text_factory = str
+
+        cursor = Cursor(connection)
 
         result = SQLiteCloudResult(SQLITECLOUD_RESULT_TYPE.RESULT_ROWSET)
         result.ncols = 1