chdb 3.0.1__cp310-cp310-macosx_11_0_arm64.whl → 3.1.1__cp310-cp310-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', '0', '1')
+chdb_version = ('3', '1', '1')
 if sys.version_info[:2] >= (3, 7):
     # get the path of the current file
     current_path = os.path.dirname(os.path.abspath(__file__))

chdb/dbapi/connections.py

@@ -57,7 +57,7 @@ class Connection(object):
             return Cursor(self)
         return Cursor(self)
 
-    def query(self, sql, fmt="ArrowStream"):
+    def query(self, sql, fmt="CSV"):
         """Execute a query and return the raw result."""
         if self._closed:
             raise err.InterfaceError("Connection closed")

chdb/dbapi/cursors.py

@@ -5,10 +5,11 @@ import re
 # executemany only supports simple bulk insert.
 # You can use it to load large dataset.
 RE_INSERT_VALUES = re.compile(
-    r"\s*((?:INSERT|REPLACE)\b.+\bVALUES?\s*)" +
-    r"(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))" +
-    r"(\s*(?:ON DUPLICATE.*)?);?\s*\Z",
-    re.IGNORECASE | re.DOTALL)
+    r"\s*((?:INSERT|REPLACE)\b.+\bVALUES?\s*)"
+    + r"(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))"
+    + r"(\s*(?:ON DUPLICATE.*)?);?\s*\Z",
+    re.IGNORECASE | re.DOTALL,
+)
 
 
 class Cursor(object):
@@ -131,13 +132,17 @@ class Cursor(object):
 
         self._cursor.execute(query)
 
-        # Get description from Arrow schema
-        if self._cursor._current_table is not None:
+        # Get description from column names and types
+        if hasattr(self._cursor, "_column_names") and self._cursor._column_names:
             self.description = [
-                (field.name, field.type.to_pandas_dtype(), None, None, None, None, None)
-                for field in self._cursor._current_table.schema
+                (name, type_info, None, None, None, None, None)
+                for name, type_info in zip(
+                    self._cursor._column_names, self._cursor._column_types
+                )
             ]
-            self.rowcount = self._cursor._current_table.num_rows
+            self.rowcount = (
+                len(self._cursor._current_table) if self._cursor._current_table else -1
+            )
         else:
             self.description = None
             self.rowcount = -1
@@ -164,16 +169,23 @@ class Cursor(object):
         if m:
             q_prefix = m.group(1) % ()
             q_values = m.group(2).rstrip()
-            q_postfix = m.group(3) or ''
-            assert q_values[0] == '(' and q_values[-1] == ')'
-            return self._do_execute_many(q_prefix, q_values, q_postfix, args,
-                                         self.max_stmt_length,
-                                         self._get_db().encoding)
+            q_postfix = m.group(3) or ""
+            assert q_values[0] == "(" and q_values[-1] == ")"
+            return self._do_execute_many(
+                q_prefix,
+                q_values,
+                q_postfix,
+                args,
+                self.max_stmt_length,
+                self._get_db().encoding,
+            )
 
         self.rowcount = sum(self.execute(query, arg) for arg in args)
         return self.rowcount
 
-    def _do_execute_many(self, prefix, values, postfix, args, max_stmt_length, encoding):
+    def _do_execute_many(
+        self, prefix, values, postfix, args, max_stmt_length, encoding
+    ):
         conn = self._get_db()
         escape = self._escape_args
         if isinstance(prefix, str):
@@ -184,18 +196,18 @@ class Cursor(object):
         args = iter(args)
         v = values % escape(next(args), conn)
         if isinstance(v, str):
-            v = v.encode(encoding, 'surrogateescape')
+            v = v.encode(encoding, "surrogateescape")
         sql += v
         rows = 0
         for arg in args:
             v = values % escape(arg, conn)
             if isinstance(v, str):
-                v = v.encode(encoding, 'surrogateescape')
+                v = v.encode(encoding, "surrogateescape")
             if len(sql) + len(v) + len(postfix) + 1 > max_stmt_length:
                 rows += self.execute(sql + postfix)
                 sql = prefix
             else:
-                sql += ','.encode(encoding)
+                sql += ",".encode(encoding)
             sql += v
         rows += self.execute(sql + postfix)
         self.rowcount = rows

chdb/state/sqlitelike.py

@@ -1,4 +1,3 @@
-import io
 from typing import Optional, Any
 from chdb import _chdb
 
@@ -11,6 +10,36 @@ except ImportError as e:
     raise ImportError("Failed to import pyarrow") from None
 
 
+_arrow_format = set({"dataframe", "arrowtable"})
+_process_result_format_funs = {
+    "dataframe": lambda x: to_df(x),
+    "arrowtable": lambda x: to_arrowTable(x),
+}
+
+
+# return pyarrow table
+def to_arrowTable(res):
+    """convert res to arrow table"""
+    # try import pyarrow and pandas, if failed, raise ImportError with suggestion
+    try:
+        import pyarrow as pa  # noqa
+        import pandas as pd  # noqa
+    except ImportError as e:
+        print(f"ImportError: {e}")
+        print('Please install pyarrow and pandas via "pip install pyarrow pandas"')
+        raise ImportError("Failed to import pyarrow or pandas") from None
+    if len(res) == 0:
+        return pa.Table.from_batches([], schema=pa.schema([]))
+    return pa.RecordBatchFileReader(res.bytes()).read_all()
+
+
+# return pandas dataframe
+def to_df(r):
+    """convert arrow table to Dataframe"""
+    t = to_arrowTable(r)
+    return t.to_pandas(use_threads=True)
+
+
 class Connection:
     def __init__(self, connection_string: str):
         # print("Connection", connection_string)
@@ -22,7 +51,13 @@ class Connection:
         return self._cursor
 
     def query(self, query: str, format: str = "CSV") -> Any:
-        return self._conn.query(query, format)
+        lower_output_format = format.lower()
+        result_func = _process_result_format_funs.get(lower_output_format, lambda x: x)
+        if lower_output_format in _arrow_format:
+            format = "Arrow"
+
+        result = self._conn.query(query, format)
+        return result_func(result)
 
     def close(self) -> None:
         # print("close")
@@ -41,17 +76,103 @@ class Cursor:
     def execute(self, query: str) -> None:
         self._cursor.execute(query)
         result_mv = self._cursor.get_memview()
-        # print("get_result", result_mv)
         if self._cursor.has_error():
             raise Exception(self._cursor.error_message())
         if self._cursor.data_size() == 0:
             self._current_table = None
             self._current_row = 0
+            self._column_names = []
+            self._column_types = []
             return
-        arrow_data = result_mv.tobytes()
-        reader = pa.ipc.open_stream(io.BytesIO(arrow_data))
-        self._current_table = reader.read_all()
-        self._current_row = 0
+
+        # Parse JSON data
+        json_data = result_mv.tobytes().decode("utf-8")
+        import json
+
+        try:
+            # First line contains column names
+            # Second line contains column types
+            # Following lines contain data
+            lines = json_data.strip().split("\n")
+            if len(lines) < 2:
+                self._current_table = None
+                self._current_row = 0
+                self._column_names = []
+                self._column_types = []
+                return
+
+            self._column_names = json.loads(lines[0])
+            self._column_types = json.loads(lines[1])
+
+            # Convert data rows
+            rows = []
+            for line in lines[2:]:
+                if not line.strip():
+                    continue
+                row_data = json.loads(line)
+                converted_row = []
+                for val, type_info in zip(row_data, self._column_types):
+                    # Handle NULL values first
+                    if val is None:
+                        converted_row.append(None)
+                        continue
+
+                    # Basic type conversion
+                    try:
+                        if type_info.startswith("Int") or type_info.startswith("UInt"):
+                            converted_row.append(int(val))
+                        elif type_info.startswith("Float"):
+                            converted_row.append(float(val))
+                        elif type_info == "Bool":
+                            converted_row.append(bool(val))
+                        elif type_info == "String" or type_info == "FixedString":
+                            converted_row.append(str(val))
+                        elif type_info.startswith("DateTime"):
+                            from datetime import datetime
+
+                            # Check if the value is numeric (timestamp)
+                            val_str = str(val)
+                            if val_str.replace(".", "").isdigit():
+                                converted_row.append(datetime.fromtimestamp(float(val)))
+                            else:
+                                # Handle datetime string formats
+                                if "." in val_str:  # Has microseconds
+                                    converted_row.append(
+                                        datetime.strptime(
+                                            val_str, "%Y-%m-%d %H:%M:%S.%f"
+                                        )
+                                    )
+                                else:  # No microseconds
+                                    converted_row.append(
+                                        datetime.strptime(val_str, "%Y-%m-%d %H:%M:%S")
+                                    )
+                        elif type_info.startswith("Date"):
+                            from datetime import date, datetime
+
+                            # Check if the value is numeric (days since epoch)
+                            val_str = str(val)
+                            if val_str.isdigit():
+                                converted_row.append(
+                                    date.fromtimestamp(float(val) * 86400)
+                                )
+                            else:
+                                # Handle date string format
+                                converted_row.append(
+                                    datetime.strptime(val_str, "%Y-%m-%d").date()
+                                )
+                        else:
+                            # For unsupported types, keep as string
+                            converted_row.append(str(val))
+                    except (ValueError, TypeError):
+                        # If conversion fails, keep original value as string
+                        converted_row.append(str(val))
+                rows.append(tuple(converted_row))
+
+            self._current_table = rows
+            self._current_row = 0
+
+        except json.JSONDecodeError as e:
+            raise Exception(f"Failed to parse JSON data: {e}")
 
     def commit(self) -> None:
         self._cursor.commit()
@@ -60,12 +181,10 @@ class Cursor:
         if not self._current_table or self._current_row >= len(self._current_table):
             return None
 
-        row_dict = {
-            col: self._current_table.column(col)[self._current_row].as_py()
-            for col in self._current_table.column_names
-        }
+        # Now self._current_table is a list of row tuples
+        row = self._current_table[self._current_row]
         self._current_row += 1
-        return tuple(row_dict.values())
+        return row
 
     def fetchmany(self, size: int = 1) -> tuple:
         if not self._current_table:
@@ -99,6 +218,30 @@ class Cursor:
             raise StopIteration
         return row
 
+    def column_names(self) -> list:
+        """Return a list of column names from the last executed query"""
+        return self._column_names if hasattr(self, "_column_names") else []
+
+    def column_types(self) -> list:
+        """Return a list of column types from the last executed query"""
+        return self._column_types if hasattr(self, "_column_types") else []
+
+    @property
+    def description(self) -> list:
+        """
+        Return a description of the columns as per DB-API 2.0
+        Returns a list of 7-item tuples, each containing:
+        (name, type_code, display_size, internal_size, precision, scale, null_ok)
+        where only name and type_code are provided
+        """
+        if not hasattr(self, "_column_names") or not self._column_names:
+            return []
+
+        return [
+            (name, type_info, None, None, None, None, None)
+            for name, type_info in zip(self._column_names, self._column_types)
+        ]
+
 
 def connect(connection_string: str = ":memory:") -> Connection:
     """

chdb/state/test_sqlitelike.py

@@ -0,0 +1,236 @@
+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

@@ -0,0 +1,83 @@
+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()

{chdb-3.0.1.dist-info → chdb-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: chdb
-Version: 3.0.1
+Version: 3.1.1
 Summary: chDB is an in-process SQL OLAP Engine powered by ClickHouse
 Home-page: https://github.com/chdb-io/chdb
 Author: auxten

{chdb-3.0.1.dist-info → chdb-3.1.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
-chdb/__init__.py,sha256=6nRIwbUg4kHRY8E8EQzDv2wT-IyR0-tsr3Mu3n_Mi9Q,3762
+chdb/__init__.py,sha256=dhg9VbRbDft2hubgDzR-pUHN11SER5HucmhhaGwb9Ek,3762
 chdb/__main__.py,sha256=xNNtDY38d973YM5dlxiIazcqqKhXJSpNb7JflyyrXGE,1185
-chdb/_chdb.cpython-310-darwin.so,sha256=p9hAzDJX7bYPFXX68AF1RtRfI2v39VDNtarPwHTTzYA,356175280
+chdb/_chdb.cpython-310-darwin.so,sha256=Tihzqs_5OtRHhCR85fvgUS2uAeJI3N_l2xVT9AESgPw,356175264
 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
 chdb/dbapi/__init__.py,sha256=aaNhxXNBC1ZkFr260cbGR8msOinTp0VoNTT_j8AXGUc,2205
-chdb/dbapi/connections.py,sha256=4RBO0h-B149xEicE8cXSSJl9wpXa4FQMY_4SghgEvCw,2762
+chdb/dbapi/connections.py,sha256=RW0EcusyKueMGp7VmSaCO-ukyzY7l2ps_ibA9-pXDvo,2754
 chdb/dbapi/converters.py,sha256=0SDqgixUTCz0LtWke_HHzgF1lFJhpsQrR_-ky3b-JRY,7447
-chdb/dbapi/cursors.py,sha256=OXF36raoyI3MIC5SCQ5IvnCtbOnppga4Q1IKOt2EIsk,7920
+chdb/dbapi/cursors.py,sha256=3ufVB1zt3x7SzCYowVbwAOsuzkMxYPO74q9XW6ctkKo,8120
 chdb/dbapi/err.py,sha256=kUI9-A8LNqBoMoo4jh2NFsLCOLoPEwh9YIuz_qMoLoM,2017
 chdb/dbapi/times.py,sha256=_qXgDaYwsHntvpIKSKXp1rrYIgtq6Z9pLyLnO2XNoL0,360
 chdb/dbapi/constants/FIELD_TYPE.py,sha256=ytFzgAnGmb9hvdsBlnK68qdZv_a6jYFIXT6VSAb60z8,370
@@ -15,14 +15,16 @@ chdb/dbapi/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 chdb/session/__init__.py,sha256=fCUROZ5L1-92o2lcASiWJpFu-80-kDoSrNfouLEmLg8,50
 chdb/session/state.py,sha256=nx9KlqZyPTHAflToXCJVRBUSMjJFvyh6x2akP7Gc7h0,4360
 chdb/state/__init__.py,sha256=RVUIWDqDi7gte4Os7Mz1wPXFyFpdHT_p1klJC7QtluI,55
-chdb/state/sqlitelike.py,sha256=-2bQRs6WDREr90pe8UtaYbQK-BWSkko1Ma8cLSzLUf4,4511
+chdb/state/sqlitelike.py,sha256=6Y57vnf7LnA0KnpByKQq7PkEkEEOKK-ExaHQLb1bedQ,10498
+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.0.1.dist-info/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
-chdb-3.0.1.dist-info/METADATA,sha256=k9gmduudI-PNBH5QCOle-dKL6ascC9StyUnX4vz6gFs,19490
-chdb-3.0.1.dist-info/WHEEL,sha256=ezfKMaDztqf77C8lvQ0NCnZxkTaOaKLprqJ8q932MhU,109
-chdb-3.0.1.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
-chdb-3.0.1.dist-info/RECORD,,
+chdb-3.1.1.dist-info/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
+chdb-3.1.1.dist-info/METADATA,sha256=zzMgz3TT8nQ8oEpbgcBTuirfhG8jZnib0UxcE-jOOZI,19490
+chdb-3.1.1.dist-info/WHEEL,sha256=JfQxSOU9VKHuLKwxXKYyEL4fjz5E2wgq58CSrCo1-34,109
+chdb-3.1.1.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
+chdb-3.1.1.dist-info/RECORD,,

{chdb-3.0.1.dist-info → chdb-3.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_11_0_arm64