chdb 3.2.0__cp312-cp312-macosx_11_0_arm64.whl → 3.4.0__cp312-cp312-macosx_11_0_arm64.whl

chdb/__init__.py

@@ -19,7 +19,7 @@ _process_result_format_funs = {
 # UDF script path will be f"{g_udf_path}/{func_name}.py"
 g_udf_path = ""
 
-chdb_version = ('3', '2', '0')
+chdb_version = ('3', '4', '0')
 if sys.version_info[:2] >= (3, 7):
     # get the path of the current file
     current_path = os.path.dirname(os.path.abspath(__file__))

chdb/session/state.py

@@ -1,5 +1,3 @@
-import tempfile
-import shutil
 import warnings
 
 import chdb
@@ -51,11 +49,9 @@ class Session:
             )
             g_session.close()
             g_session_path = None
-        if path is None or ":memory:" in path:
-            self._cleanup = True
-            self._path = tempfile.mkdtemp()
+        if path is None:
+            self._path = ":memory:"
         else:
-            self._cleanup = False
             self._path = path
         if chdb.g_udf_path != "":
             self._udf_path = chdb.g_udf_path
@@ -84,8 +80,6 @@ class Session:
         self.close()
 
     def close(self):
-        if self._cleanup:
-            self.cleanup()
         if self._conn is not None:
             self._conn.close()
             self._conn = None
@@ -95,13 +89,7 @@ class Session:
 
     def cleanup(self):
         try:
-            if self._conn is not None:
-                self._conn.close()
-                self._conn = None
-            shutil.rmtree(self._path)
-            global g_session, g_session_path
-            g_session = None
-            g_session_path = None
+            self.close()
         except:  # noqa
             pass
 

{chdb-3.2.0.dist-info → chdb-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chdb
-Version: 3.2.0
+Version: 3.4.0
 Summary: chDB is an in-process SQL OLAP Engine powered by ClickHouse
 Home-page: https://github.com/chdb-io/chdb
 Author: auxten
@@ -54,11 +54,11 @@ Dynamic: requires-python
 
 
 > chDB is an in-process SQL OLAP Engine powered by ClickHouse  [^1]
-> For more details: [The birth of chDB](https://auxten.com/the-birth-of-chdb/) 
+> For more details: [The birth of chDB](https://auxten.com/the-birth-of-chdb/)
 
 
 ## Features
-     
+
 * In-process SQL OLAP Engine, powered by ClickHouse
 * No need to install ClickHouse
 * Minimized data copy from C++ to Python with [python memoryview](https://docs.python.org/3/c-api/memoryview.html)
@@ -149,7 +149,7 @@ res = chdb.query('select version()', 'Pretty'); print(res)
 # See more data type format in tests/format_output.py
 res = chdb.query('select * from file("data.parquet", Parquet)', 'JSON'); print(res)
 res = chdb.query('select * from file("data.csv", CSV)', 'CSV');  print(res)
-print(f"SQL read {res.rows_read()} rows, {res.bytes_read()} bytes, elapsed {res.elapsed()} seconds")
+print(f"SQL read {res.rows_read()} rows, {res.bytes_read()} bytes, storage read {res.storage_rows_read()} rows, {res.storage_bytes_read()} bytes, elapsed {res.elapsed()} seconds")
 ```
 
 ### Pandas dataframe output
@@ -174,6 +174,8 @@ ret_tbl = cdf.query(sql="select * from __tbl1__ t1 join __tbl2__ t2 on t1.a = t2
 print(ret_tbl)
 # Query on the DataFrame Table
 print(ret_tbl.query('select b, sum(a) from __table__ group by b'))
+# Pandas DataFrames are automatically registered as temporary tables in ClickHouse
+chdb.query("SELECT * FROM Python(df1) t1 JOIN Python(df2) t2 ON t1.a = t2.c").show()
 ```
 </details>
 
@@ -321,10 +323,19 @@ df = pd.DataFrame(
     {
         "a": [1, 2, 3, 4, 5, 6],
         "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
+        "dict_col": [
+            {'id': 1, 'tags': ['urgent', 'important'], 'metadata': {'created': '2024-01-01'}},
+            {'id': 2, 'tags': ['normal'], 'metadata': {'created': '2024-02-01'}},
+            {'id': 3, 'name': 'tom'},
+            {'id': 4, 'value': '100'},
+            {'id': 5, 'value': 101},
+            {'id': 6, 'value': 102},
+        ],
     }
 )
 
 chdb.query("SELECT b, sum(a) FROM Python(df) GROUP BY b ORDER BY b").show()
+chdb.query("SELECT dict_col.id FROM Python(df) WHERE dict_col.value='100'").show()
 ```
 
 ### Query on Arrow Table
@@ -336,12 +347,19 @@ arrow_table = pa.table(
     {
         "a": [1, 2, 3, 4, 5, 6],
         "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
+        "dict_col": [
+            {'id': 1, 'value': 'tom'},
+            {'id': 2, 'value': 'jerry'},
+            {'id': 3, 'value': 'auxten'},
+            {'id': 4, 'value': 'tom'},
+            {'id': 5, 'value': 'jerry'},
+            {'id': 6, 'value': 'auxten'},
+        ],
     }
 )
 
-chdb.query(
-    "SELECT b, sum(a) FROM Python(arrow_table) GROUP BY b ORDER BY b", "debug"
-).show()
+chdb.query("SELECT b, sum(a) FROM Python(arrow_table) GROUP BY b ORDER BY b").show()
+chdb.query("SELECT dict_col.id FROM Python(arrow_table) WHERE dict_col.value='tom'").show()
 ```
 
 ### Query on chdb.PyReader class instance
@@ -365,24 +383,79 @@ class myReader(chdb.PyReader):
     def read(self, col_names, count):
         print("Python func read", col_names, count, self.cursor)
         if self.cursor >= len(self.data["a"]):
+            self.cursor = 0
             return []
         block = [self.data[col] for col in col_names]
         self.cursor += len(block[0])
         return block
 
+    def get_schema(self):
+        return [
+            ("a", "int"),
+            ("b", "str"),
+            ("dict_col", "json")
+        ]
+
 reader = myReader(
     {
         "a": [1, 2, 3, 4, 5, 6],
         "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
+        "dict_col": [
+            {'id': 1, 'tags': ['urgent', 'important'], 'metadata': {'created': '2024-01-01'}},
+            {'id': 2, 'tags': ['normal'], 'metadata': {'created': '2024-02-01'}},
+            {'id': 3, 'name': 'tom'},
+            {'id': 4, 'value': '100'},
+            {'id': 5, 'value': 101},
+            {'id': 6, 'value': 102}
+        ],
     }
 )
 
-chdb.query(
-    "SELECT b, sum(a) FROM Python(reader) GROUP BY b ORDER BY b"
-).show()
+chdb.query("SELECT b, sum(a) FROM Python(reader) GROUP BY b ORDER BY b").show()
+chdb.query("SELECT dict_col.id FROM Python(reader) WHERE dict_col.value='100'").show()
 ```
 
-see also: [test_query_py.py](tests/test_query_py.py).
+see also: [test_query_py.py](tests/test_query_py.py) and [test_query_json.py](tests/test_query_json.py).
+
+### JSON Type Inference
+
+chDB automatically converts Python dictionary objects to ClickHouse JSON types from these sources:
+
+1. **Pandas DataFrame**
+    - Columns with `object` dtype are sampled (default 10,000 rows) to detect JSON structures.
+    - Control sampling via SQL settings:
+      ```sql
+      SET pandas_analyze_sample = 10000  -- Default sampling
+      SET pandas_analyze_sample = 0      -- Force String type
+      SET pandas_analyze_sample = -1     -- Force JSON type
+      ```
+    - Columns are converted to `String` if sampling finds non-dictionary values.
+
+2. **Arrow Table**
+    - `struct` type columns are automatically mapped to JSON columns.
+    - Nested structures preserve type information.
+
+3. **chdb.PyReader**
+    - Implement custom schema mapping in `get_schema()`:
+      ```python
+      def get_schema(self):
+          return [
+              ("c1", "JSON"),  # Explicit JSON mapping
+              ("c2", "String")
+          ]
+      ```
+    - Column types declared as "JSON" will bypass auto-detection.
+
+When converting Python dictionary objects to JSON columns:
+
+1. **Nested Structures**
+    - Recursively process nested dictionaries, lists, tuples and NumPy arrays.
+
+2. **Primitive Types**
+    - Automatic type recognition for basic types such as integers, floats, strings, and booleans, and more.
+
+3. **Complex Objects**
+    - Non-primitive types will be converted to strings.
 
 ### Limitations
 

{chdb-3.2.0.dist-info → chdb-3.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-chdb/__init__.py,sha256=yuWj0i3_5-uBRZCyZMBKIiBR1MmjEyAjcuxKTm076jI,3762
+chdb/__init__.py,sha256=pNYyLRqm2s5hG1rPhVLECZXvJQ60EGPt_OC88W90j0w,3762
 chdb/__main__.py,sha256=xNNtDY38d973YM5dlxiIazcqqKhXJSpNb7JflyyrXGE,1185
-chdb/_chdb.cpython-312-darwin.so,sha256=dW8SCyHWtJgofdkqdxyb2x1rSgzMY7gU0Ph2CA2o1U4,356206720
+chdb/_chdb.cpython-312-darwin.so,sha256=mb3p1w-m0THwqNf_PLIz-RMV-i-D0FXu8WPkeJaRVrc,383558832
 chdb/rwabc.py,sha256=tbiwCrXirfrfx46wCJxS64yvFe6pVWIPGdSuvrAL5Ys,2102
 chdb/dataframe/__init__.py,sha256=1_mrZZiJwqBTnH_P8_FCbbYXIWWY5sxnaFpe3-tDLF4,680
 chdb/dataframe/query.py,sha256=ggvE8A5vtabFg9gSTp99S7LCrnIEwbWtb-PtJVT8Ct0,12759
@@ -13,18 +13,16 @@ chdb/dbapi/times.py,sha256=_qXgDaYwsHntvpIKSKXp1rrYIgtq6Z9pLyLnO2XNoL0,360
 chdb/dbapi/constants/FIELD_TYPE.py,sha256=ytFzgAnGmb9hvdsBlnK68qdZv_a6jYFIXT6VSAb60z8,370
 chdb/dbapi/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chdb/session/__init__.py,sha256=fCUROZ5L1-92o2lcASiWJpFu-80-kDoSrNfouLEmLg8,50
-chdb/session/state.py,sha256=UtObxVuyNgeqFkTXVHtmOknR90Pe1dEzbOpKFDBYOkg,4845
+chdb/session/state.py,sha256=m7K9zZtoMQTlh-pfmSyJV38pAe6eHNTPtOvlHYrImhA,4436
 chdb/state/__init__.py,sha256=RVUIWDqDi7gte4Os7Mz1wPXFyFpdHT_p1klJC7QtluI,55
 chdb/state/sqlitelike.py,sha256=v0xh9jWirHzhDVq26C2213LxfaDbRulSAhSHaTiZ24c,12283
-chdb/state/test_sqlitelike.py,sha256=8Y7Up2Glkl6PpSgkMF_Rgz_3oGgx-6aLcyxaw2bzQR8,7586
-chdb/tests/test_dbapi.py,sha256=Z5KloM0ujhVFaLOES6V6slLIRWbTyg0lPyggl3m2ZqY,2765
 chdb/udf/__init__.py,sha256=qSMaPEre7w1pYz8uJ-iZtuu8wYOUNRcI_8UNuaOymGE,80
 chdb/udf/udf.py,sha256=z0A1RmyZrx55bykpvvS-LpVt1lMrQOexjvU5zxCdCSA,3935
 chdb/utils/__init__.py,sha256=tXRcwBRGW2YQNBZWV4Mitw5QlCu_qlSRCjllw15XHbs,171
 chdb/utils/trace.py,sha256=W-pvDoKlnzq6H_7FiWjr5_teN40UNE4E5--zbUrjOIc,2511
 chdb/utils/types.py,sha256=MGLFIjoDvu7Uc2Wy8EDY60jjue66HmMPxbhrujjrZxQ,7530
-chdb-3.2.0.dist-info/licenses/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
-chdb-3.2.0.dist-info/METADATA,sha256=n8no2boSiPOzbj8PtIT3nIQUtYGXQ1TEgq4QSOFzI4U,21585
-chdb-3.2.0.dist-info/WHEEL,sha256=IR6S_K8Km0Ji5Zl8vjPSo_uH9-UA1bb9Jsoca0AUJ14,109
-chdb-3.2.0.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
-chdb-3.2.0.dist-info/RECORD,,
+chdb-3.4.0.dist-info/licenses/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
+chdb-3.4.0.dist-info/METADATA,sha256=pwAsyrEzxFDBifcZoNLzRQHB7bCXd2B8y-31HX3APPE,24690
+chdb-3.4.0.dist-info/WHEEL,sha256=CltXN3lQvXbHxKDtiDwW0RNzF8s2WyBuPbOAX_ZeQlA,109
+chdb-3.4.0.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
+chdb-3.4.0.dist-info/RECORD,,

{chdb-3.2.0.dist-info → chdb-3.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-macosx_11_0_arm64
 

chdb/state/test_sqlitelike.py

@@ -1,236 +0,0 @@
-import unittest
-from datetime import datetime, date
-from chdb.state.sqlitelike import connect
-
-
-class TestCursor(unittest.TestCase):
-    def setUp(self):
-        self.conn = connect(":memory:")
-        self.cursor = self.conn.cursor()
-
-    def tearDown(self):
-        self.cursor.close()
-        self.conn.close()
-
-    def test_basic_types(self):
-        # Test basic types including NULL values
-        self.cursor.execute(
-            """
-            SELECT 
-                42 as int_val,
-                3.14 as float_val,
-                'hello' as str_val,
-                true as bool_val,
-                NULL as null_val
-        """
-        )
-        row = self.cursor.fetchone()
-        self.assertEqual(row, (42, 3.14, "hello", True, None))
-
-    def test_date_time_types(self):
-        # Test date and datetime types with various formats
-        self.cursor.execute(
-            """
-            SELECT 
-                toDateTime('2024-03-20 15:30:00') as datetime_str,
-                toDateTime64('2024-03-20 15:30:00.123456', 6) as datetime64_str,
-                toDate('2024-03-20') as date_str,
-                toDateTime(1710945000) as datetime_ts,  -- 2024-03-20 15:30:00
-                toDate(19437) as date_ts  -- 2024-03-20 (days since 1970-01-01)
-        """
-        )
-        row = self.cursor.fetchone()
-        self.assertEqual(len(row), 5)
-
-        # Test datetime string format
-        self.assertIsInstance(row[0], datetime)
-        self.assertEqual(row[0].strftime("%Y-%m-%d %H:%M:%S"), "2024-03-20 15:30:00")
-
-        # Test datetime64 with microseconds
-        self.assertIsInstance(row[1], datetime)
-        self.assertEqual(
-            row[1].strftime("%Y-%m-%d %H:%M:%S.%f"), "2024-03-20 15:30:00.123456"
-        )
-
-        # Test date string format
-        self.assertIsInstance(row[2], date)
-        self.assertEqual(row[2].isoformat(), "2024-03-20")
-
-        # Test datetime from timestamp
-        self.assertIsInstance(row[3], datetime)
-        self.assertEqual(row[3].strftime("%Y-%m-%d %H:%M:%S"), "2024-03-20 15:30:00")
-
-        # Test date from timestamp
-        self.assertIsInstance(row[4], date)
-        self.assertEqual(row[4].isoformat(), "2024-03-20")
-
-    def test_array_types(self):
-        # Test array types (should be converted to string)
-        self.cursor.execute(
-            """
-            SELECT 
-                [1, 2, 3] as int_array,
-                ['a', 'b', 'c'] as str_array
-        """
-        )
-        row = self.cursor.fetchone()
-        self.assertIsInstance(row[0], str)
-        self.assertIsInstance(row[1], str)
-
-    def test_complex_types(self):
-        # Test more complex ClickHouse types
-        self.cursor.execute(
-            """
-            SELECT 
-                toDecimal64(123.45, 2) as decimal_val,
-                toFixedString('test', 10) as fixed_str_val,
-                tuple(1, 'a') as tuple_val,
-                map('key', 'value') as map_val
-        """
-        )
-        row = self.cursor.fetchone()
-        # All complex types should be converted to strings
-        for val in row:
-            self.assertIsInstance(val, (str, type(None)))
-
-    def test_fetch_methods(self):
-        # Test different fetch methods
-        self.cursor.execute(
-            """
-            SELECT number 
-            FROM system.numbers 
-            LIMIT 5
-        """
-        )
-
-        # Test fetchone
-        self.assertEqual(self.cursor.fetchone(), (0,))
-
-        # Test fetchmany
-        self.assertEqual(self.cursor.fetchmany(2), ((1,), (2,)))
-
-        # Test fetchall
-        self.assertEqual(self.cursor.fetchall(), ((3,), (4,)))
-
-        # Test fetchone after end
-        self.assertIsNone(self.cursor.fetchone())
-
-    def test_empty_result(self):
-        # Test empty result handling
-        self.cursor.execute("SELECT 1 WHERE 1=0")
-        self.assertIsNone(self.cursor.fetchone())
-        self.assertEqual(self.cursor.fetchall(), ())
-
-    def test_iterator(self):
-        # Test cursor as iterator
-        self.cursor.execute(
-            """
-            SELECT number 
-            FROM system.numbers 
-            LIMIT 3
-        """
-        )
-        rows = [row for row in self.cursor]
-        self.assertEqual(rows, [(0,), (1,), (2,)])
-
-    def test_error_handling(self):
-        # Test invalid SQL
-        with self.assertRaises(Exception):
-            self.cursor.execute("SELECT invalid_column")
-
-    def test_large_result(self):
-        # Test handling of larger result sets
-        self.cursor.execute(
-            """
-            SELECT 
-                number,
-                toString(number) as str_val,
-                toDateTime('2024-03-20 15:30:00') + interval number second as time_val
-            FROM system.numbers
-            LIMIT 1000
-        """
-        )
-        rows = self.cursor.fetchall()
-        self.assertEqual(len(rows), 1000)
-        self.assertEqual(rows[0], (0, "0", datetime(2024, 3, 20, 15, 30, 0)))
-        self.assertEqual(rows[-1], (999, "999", datetime(2024, 3, 20, 15, 46, 39)))
-
-    def test_column_names(self):
-        # Test that column names are stored and accessible
-        self.cursor.execute(
-            """
-            SELECT 
-                42 as int_col,
-                'hello' as str_col,
-                now() as time_col
-        """
-        )
-
-        # Test the column names method
-        self.assertEqual(self.cursor.column_names(), ["int_col", "str_col", "time_col"])
-
-        # Test the column types method
-        self.assertEqual(len(self.cursor.column_types()), 3)
-
-        # Test the description property (DB-API 2.0)
-        description = self.cursor.description
-        self.assertEqual(len(description), 3)
-        self.assertEqual(description[0][0], "int_col")  # First column name
-        self.assertEqual(description[1][0], "str_col")  # Second column name
-
-        # Test fetchone
-        row = self.cursor.fetchone()
-        self.assertEqual(len(row), 3)
-
-        # Test that all data was properly converted
-        self.assertIsInstance(row[0], int)
-        self.assertIsInstance(row[1], str)
-        self.assertIsInstance(
-            row[2], (str, datetime)
-        )  # May be str or datetime depending on conversion
-
-    def test_uuid_type(self):
-        # Test UUID type handling
-        self.cursor.execute(
-            "SELECT '6bbd51ac-b0cc-43a2-8cb2-eab06ff7de7b'::UUID as uuid_val"
-        )
-        row = self.cursor.fetchone()
-        self.assertEqual(row[0], "6bbd51ac-b0cc-43a2-8cb2-eab06ff7de7b")
-
-        # Test UUID in a more complex query
-        self.cursor.execute(
-            """
-            SELECT 
-                '6bbd51ac-b0cc-43a2-8cb2-eab06ff7de7b'::UUID as uuid_val1,
-                NULL::UUID as uuid_val2
-        """
-        )
-        row = self.cursor.fetchone()
-        self.assertEqual(row[0], "6bbd51ac-b0cc-43a2-8cb2-eab06ff7de7b")
-        self.assertIsNone(row[1])
-
-    def test_null_handling(self):
-        # Test NULL handling
-        self.cursor.execute("SELECT NULL")
-        row = self.cursor.fetchone()
-        self.assertEqual(row, (None,))
-
-        # Test NULL with different types
-        self.cursor.execute(
-            """
-            SELECT 
-                NULL::Int32 as null_int,
-                NULL::String as null_str,
-                NULL::UUID as null_uuid,
-                NULL::DateTime as null_datetime,
-                NULL::Date as null_date
-        """
-        )
-        row = self.cursor.fetchone()
-        self.assertEqual(len(row), 5)
-        for val in row:
-            self.assertIsNone(val)
-
-
-if __name__ == "__main__":
-    unittest.main()

chdb/tests/test_dbapi.py

@@ -1,83 +0,0 @@
-import unittest
-from chdb.dbapi import connect
-
-
-class TestDBAPI(unittest.TestCase):
-    def setUp(self):
-        self.conn = connect()
-        self.cur = self.conn.cursor()
-
-    def tearDown(self):
-        self.cur.close()
-        self.conn.close()
-
-    def test_select_version(self):
-        """Test simple version query"""
-        self.cur.execute("select version()")  # ClickHouse version
-        row = self.cur.fetchone()
-        self.assertIsNotNone(row)
-        self.assertEqual(len(row), 1)
-        self.assertIsInstance(row[0], str)
-
-    def test_description(self):
-        """Test cursor description"""
-        # Test with multiple columns of different types
-        self.cur.execute(
-            """
-            SELECT 
-                1 as int_col,
-                'test' as str_col,
-                now() as time_col,
-                NULL as null_col,
-                '6bbd51ac-b0cc-43a2-8cb2-eab06ff7de7b'::UUID as uuid_col
-        """
-        )
-
-        # Check description format
-        self.assertIsNotNone(self.cur.description)
-        self.assertEqual(len(self.cur.description), 5)
-
-        # Check each column's metadata
-        int_col = self.cur.description[0]
-        str_col = self.cur.description[1]
-        time_col = self.cur.description[2]
-        null_col = self.cur.description[3]
-        uuid_col = self.cur.description[4]
-
-        # Check column names
-        self.assertEqual(int_col[0], "int_col")
-        self.assertEqual(str_col[0], "str_col")
-        self.assertEqual(time_col[0], "time_col")
-        self.assertEqual(null_col[0], "null_col")
-        self.assertEqual(uuid_col[0], "uuid_col")
-
-        # Check that type info is present
-        self.assertTrue(int_col[1].startswith("Int") or int_col[1].startswith("UInt"))
-        self.assertTrue(str_col[1] in ("String", "FixedString"))
-        self.assertTrue(time_col[1].startswith("DateTime"))
-        self.assertTrue(uuid_col[1] == "UUID")
-
-        # Check that other fields are None as per DB-API 2.0
-        for col in self.cur.description:
-            self.assertEqual(len(col), 7)  # DB-API 2.0 specifies 7 fields
-            self.assertTrue(
-                all(x is None for x in col[2:])
-            )  # All fields after name and type should be None
-
-    def test_rowcount(self):
-        """Test rowcount attribute"""
-        # Test with empty result
-        self.cur.execute("SELECT 1 WHERE 1=0")
-        self.assertEqual(self.cur.rowcount, 0)
-
-        # Test with single row
-        self.cur.execute("SELECT 1")
-        self.assertEqual(self.cur.rowcount, 1)
-
-        # Test with multiple rows
-        self.cur.execute("SELECT number FROM system.numbers LIMIT 10")
-        self.assertEqual(self.cur.rowcount, 10)
-
-
-if __name__ == "__main__":
-    unittest.main()