chdb 2.1.1__cp39-cp39-macosx_11_0_arm64.whl → 2.2.0b1__cp39-cp39-macosx_11_0_arm64.whl

chdb/__init__.py

@@ -18,7 +18,7 @@ _process_result_format_funs = {
 # UDF script path will be f"{g_udf_path}/{func_name}.py"
 g_udf_path = ""
 
-chdb_version = ('2', '1', '1')
+chdb_version = ('2', '2', '0b1')
 if sys.version_info[:2] >= (3, 7):
     # get the path of the current file
     current_path = os.path.dirname(os.path.abspath(__file__))
@@ -85,8 +85,10 @@ sql = query
 PyReader = _chdb.PyReader
 
 from . import dbapi, session, udf, utils  # noqa: E402
+from .state import connect  # noqa: E402
 
 __all__ = [
+    "_chdb",
     "PyReader",
     "ChdbError",
     "query",
@@ -99,4 +101,5 @@ __all__ = [
     "session",
     "udf",
     "utils",
+    "connect",
 ]

chdb/dbapi/connections.py

@@ -1,7 +1,7 @@
-import json
 from . import err
 from .cursors import Cursor
 from . import converters
+from ..state import sqlitelike as chdb_stateful
 
 DEBUG = False
 VERBOSE = False
@@ -10,56 +10,29 @@ VERBOSE = False
 class Connection(object):
     """
     Representation of a connection with chdb.
-
-    The proper way to get an instance of this class is to call
-    connect().
-
-    Accepts several arguments:
-
-    :param cursorclass: Custom cursor class to use.
-    :param path: Optional folder path to store database files on disk.
-
-    See `Connection <https://www.python.org/dev/peps/pep-0249/#connection-objects>`_ in the
-    specification.
     """
 
-    _closed = False
-    _session = None
-
-    def __init__(self, cursorclass=Cursor, path=None):
-
-        self._resp = None
-
-        # 1. pre-process params in init
-        self.encoding = 'utf8'
-
-        self.cursorclass = cursorclass
-
-        self._result = None
+    def __init__(self, path=None):
+        self._closed = False
+        self.encoding = "utf8"
         self._affected_rows = 0
+        self._resp = None
 
-        self.connect(path)
+        # Initialize sqlitelike connection
+        connection_string = ":memory:" if path is None else f"file:{path}"
+        self._conn = chdb_stateful.Connection(connection_string)
 
-    def connect(self, path=None):
-        from chdb import session as chs
-        self._session = chs.Session(path)
-        self._closed = False
-        self._execute_command("select 1;")
-        self._read_query_result()
+        # Test connection with a simple query
+        cursor = self._conn.cursor()
+        cursor.execute("SELECT 1")
+        cursor.close()
 
     def close(self):
-        """
-        Send the quit message and close the socket.
-
-        See `Connection.close() <https://www.python.org/dev/peps/pep-0249/#Connection.close>`_
-        in the specification.
-
-        :raise Error: If the connection is already closed.
-        """
+        """Send the quit message and close the socket."""
         if self._closed:
             raise err.Error("Already closed")
         self._closed = True
-        self._session = None
+        self._conn.close()
 
     @property
     def open(self):
@@ -67,81 +40,41 @@ class Connection(object):
         return not self._closed
 
     def commit(self):
-        """
-        Commit changes to stable storage.
-
-        See `Connection.commit() <https://www.python.org/dev/peps/pep-0249/#commit>`_
-        in the specification.
-        """
-        return
+        """Commit changes to stable storage."""
+        # No-op for ClickHouse
+        pass
 
     def rollback(self):
-        """
-        Roll back the current transaction.
-
-        See `Connection.rollback() <https://www.python.org/dev/peps/pep-0249/#rollback>`_
-        in the specification.
-        """
-        return
+        """Roll back the current transaction."""
+        # No-op for ClickHouse
+        pass
 
     def cursor(self, cursor=None):
-        """
-        Create a new cursor to execute queries with.
-
-        :param cursor: The type of cursor to create; current only :py:class:`Cursor`
-            None means use Cursor.
-        """
+        """Create a new cursor to execute queries with."""
+        if self._closed:
+            raise err.Error("Connection closed")
         if cursor:
-            return cursor(self)
-        return self.cursorclass(self)
+            return Cursor(self)
+        return Cursor(self)
 
-    # The following methods are INTERNAL USE ONLY (called from Cursor)
-    def query(self, sql):
-        if isinstance(sql, str):
-            sql = sql.encode(self.encoding, 'surrogateescape')
-        self._execute_command(sql)
-        self._affected_rows = self._read_query_result()
-        return self._affected_rows
-
-    def _execute_command(self, sql):
-        """
-        :raise InterfaceError: If the connection is closed.
-        :raise ValueError: If no username was specified.
-        """
+    def query(self, sql, fmt="ArrowStream"):
+        """Execute a query and return the raw result."""
         if self._closed:
             raise err.InterfaceError("Connection closed")
 
         if isinstance(sql, str):
-            sql = sql.encode(self.encoding)
+            sql = sql.encode(self.encoding, "surrogateescape")
 
-        if isinstance(sql, bytearray):
-            sql = bytes(sql)
-
-        # drop last command return
-        if self._resp is not None:
-            self._resp = None
-
-        if DEBUG:
-            print("DEBUG: query:", sql)
         try:
-            res = self._session.query(sql, fmt="JSON")
-            if res.has_error():
-                raise err.DatabaseError(res.error_message())
-            self._resp = res.data()
+            result = self._conn.query(sql.decode(), fmt)
+            self._resp = result
+            return result
         except Exception as error:
-            raise err.InterfaceError("query err: %s" % error)
+            raise err.InterfaceError(f"Query error: {error}")
 
     def escape(self, obj, mapping=None):
-        """Escape whatever value you pass to it.
-
-        Non-standard, for internal use; do not use this in your applications.
-        """
-        if isinstance(obj, str):
-            return "'" + self.escape_string(obj) + "'"
-        if isinstance(obj, (bytes, bytearray)):
-            ret = self._quote_bytes(obj)
-            return ret
-        return converters.escape_item(obj, mapping=mapping)
+        """Escape whatever value you pass to it."""
+        return converters.escape_item(obj, mapping)
 
     def escape_string(self, s):
         return converters.escape_string(s)
@@ -149,13 +82,6 @@ class Connection(object):
     def _quote_bytes(self, s):
         return converters.escape_bytes(s)
 
-    def _read_query_result(self):
-        self._result = None
-        result = CHDBResult(self)
-        result.read()
-        self._result = result
-        return result.affected_rows
-
     def __enter__(self):
         """Context manager that returns a Cursor"""
         return self.cursor()
@@ -166,52 +92,9 @@ class Connection(object):
             self.rollback()
         else:
             self.commit()
+        self.close()
 
     @property
     def resp(self):
+        """Return the last query response"""
         return self._resp
-
-
-class CHDBResult(object):
-    def __init__(self, connection):
-        """
-        :type connection: Connection
-        """
-        self.connection = connection
-        self.affected_rows = 0
-        self.insert_id = None
-        self.warning_count = 0
-        self.message = None
-        self.field_count = 0
-        self.description = None
-        self.rows = None
-        self.has_next = None
-
-    def read(self):
-        # Handle empty responses (for instance from CREATE TABLE)
-        if self.connection.resp is None:
-            return
-
-        try:
-            data = json.loads(self.connection.resp)
-        except Exception as error:
-            raise err.InterfaceError("Unsupported response format:" % error)
-
-        try:
-            self.field_count = len(data["meta"])
-            description = []
-            for meta in data["meta"]:
-                fields = [meta["name"], meta["type"]]
-                description.append(tuple(fields))
-            self.description = tuple(description)
-
-            rows = []
-            for line in data["data"]:
-                row = []
-                for i in range(self.field_count):
-                    column_data = converters.convert_column_data(self.description[i][1], line[self.description[i][0]])
-                    row.append(column_data)
-                rows.append(tuple(row))
-            self.rows = tuple(rows)
-        except Exception as error:
-            raise err.InterfaceError("Read return data err:" % error)

chdb/dbapi/cursors.py

@@ -29,13 +29,11 @@ class Cursor(object):
 
     def __init__(self, connection):
         self.connection = connection
+        self._cursor = connection._conn.cursor()
         self.description = None
         self.rowcount = -1
-        self.rownumber = 0
         self.arraysize = 1
         self.lastrowid = None
-        self._result = None
-        self._rows = None
         self._executed = None
 
     def __enter__(self):
@@ -83,14 +81,7 @@ class Cursor(object):
         """
         Closing a cursor just exhausts all remaining data.
         """
-        conn = self.connection
-        if conn is None:
-            return
-        try:
-            while self.nextset():
-                pass
-        finally:
-            self.connection = None
+        self._cursor.close()
 
     def _get_db(self):
         if not self.connection:
@@ -121,33 +112,6 @@ class Cursor(object):
 
         return query
 
-    def _clear_result(self):
-        self.rownumber = 0
-        self._result = None
-
-        self.rowcount = 0
-        self.description = None
-        self.lastrowid = None
-        self._rows = None
-
-    def _do_get_result(self):
-        conn = self._get_db()
-
-        self._result = result = conn._result
-
-        self.rowcount = result.affected_rows
-        self.description = result.description
-        self.lastrowid = result.insert_id
-        self._rows = result.rows
-
-    def _query(self, q):
-        conn = self._get_db()
-        self._last_executed = q
-        self._clear_result()
-        conn.query(q)
-        self._do_get_result()
-        return self.rowcount
-
     def execute(self, query, args=None):
         """Execute a query
 
@@ -162,14 +126,24 @@ class Cursor(object):
         If args is a list or tuple, %s can be used as a placeholder in the query.
         If args is a dict, %(name)s can be used as a placeholder in the query.
         """
-        while self.nextset():
-            pass
+        if args is not None:
+            query = query % self._escape_args(args, self.connection)
+
+        self._cursor.execute(query)
 
-        query = self.mogrify(query, args)
+        # Get description from Arrow schema
+        if self._cursor._current_table is not None:
+            self.description = [
+                (field.name, field.type.to_pandas_dtype(), None, None, None, None, None)
+                for field in self._cursor._current_table.schema
+            ]
+            self.rowcount = self._cursor._current_table.num_rows
+        else:
+            self.description = None
+            self.rowcount = -1
 
-        result = self._query(query)
         self._executed = query
-        return result
+        return self.rowcount
 
     def executemany(self, query, args):
         # type: (str, list) -> int
@@ -233,34 +207,21 @@ class Cursor(object):
 
     def fetchone(self):
         """Fetch the next row"""
-        self._check_executed()
-        if self._rows is None or self.rownumber >= len(self._rows):
-            return None
-        result = self._rows[self.rownumber]
-        self.rownumber += 1
-        return result
-
-    def fetchmany(self, size=None):
+        if not self._executed:
+            raise err.ProgrammingError("execute() first")
+        return self._cursor.fetchone()
+
+    def fetchmany(self, size=1):
         """Fetch several rows"""
-        self._check_executed()
-        if self._rows is None:
-            return ()
-        end = self.rownumber + (size or self.arraysize)
-        result = self._rows[self.rownumber:end]
-        self.rownumber = min(end, len(self._rows))
-        return result
+        if not self._executed:
+            raise err.ProgrammingError("execute() first")
+        return self._cursor.fetchmany(size)
 
     def fetchall(self):
         """Fetch all the rows"""
-        self._check_executed()
-        if self._rows is None:
-            return ()
-        if self.rownumber:
-            result = self._rows[self.rownumber:]
-        else:
-            result = self._rows
-        self.rownumber = len(self._rows)
-        return result
+        if not self._executed:
+            raise err.ProgrammingError("execute() first")
+        return self._cursor.fetchall()
 
     def nextset(self):
         """Get the next query set"""
@@ -272,26 +233,3 @@ class Cursor(object):
 
     def setoutputsizes(self, *args):
         """Does nothing, required by DB API."""
-
-
-class DictCursor(Cursor):
-    """A cursor which returns results as a dictionary"""
-    # You can override this to use OrderedDict or other dict-like types.
-    dict_type = dict
-
-    def _do_get_result(self):
-        super()._do_get_result()
-        fields = []
-        if self.description:
-            for f in self.description:
-                name = f[0]
-                fields.append(name)
-            self._fields = fields
-
-        if fields and self._rows:
-            self._rows = [self._conv_row(r) for r in self._rows]
-
-    def _conv_row(self, row):
-        if row is None:
-            return None
-        return self.dict_type(zip(self._fields, row))

chdb/state/__init__.py

@@ -0,0 +1,3 @@
+from .sqlitelike import connect
+
+__all__ = ["connect"]

chdb/state/sqlitelike.py

@@ -0,0 +1,132 @@
+import io
+from typing import Optional, Any
+from chdb import _chdb
+
+# try import pyarrow if failed, raise ImportError with suggestion
+try:
+    import pyarrow as pa  # noqa
+except ImportError as e:
+    print(f"ImportError: {e}")
+    print('Please install pyarrow via "pip install pyarrow"')
+    raise ImportError("Failed to import pyarrow") from None
+
+
+class Connection:
+    def __init__(self, connection_string: str):
+        # print("Connection", connection_string)
+        self._cursor: Optional[Cursor] = None
+        self._conn = _chdb.connect(connection_string)
+
+    def cursor(self) -> "Cursor":
+        self._cursor = Cursor(self._conn)
+        return self._cursor
+
+    def query(self, query: str, format: str = "ArrowStream") -> Any:
+        return self._conn.query(query, format)
+
+    def close(self) -> None:
+        # print("close")
+        if self._cursor:
+            self._cursor.close()
+        self._conn.close()
+
+
+class Cursor:
+    def __init__(self, connection):
+        self._conn = connection
+        self._cursor = self._conn.cursor()
+        self._current_table: Optional[pa.Table] = None
+        self._current_row: int = 0
+
+    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
+            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
+
+    def commit(self) -> None:
+        self._cursor.commit()
+
+    def fetchone(self) -> Optional[tuple]:
+        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
+        }
+        self._current_row += 1
+        return tuple(row_dict.values())
+
+    def fetchmany(self, size: int = 1) -> tuple:
+        if not self._current_table:
+            return tuple()
+
+        rows = []
+        for _ in range(size):
+            if (row := self.fetchone()) is None:
+                break
+            rows.append(row)
+        return tuple(rows)
+
+    def fetchall(self) -> tuple:
+        if not self._current_table:
+            return tuple()
+
+        remaining_rows = []
+        while (row := self.fetchone()) is not None:
+            remaining_rows.append(row)
+        return tuple(remaining_rows)
+
+    def close(self) -> None:
+        self._cursor.close()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> tuple:
+        row = self.fetchone()
+        if row is None:
+            raise StopIteration
+        return row
+
+
+def connect(connection_string: str = ":memory:") -> Connection:
+    """
+    Create a connection to chDB backgroud server.
+    Only one open connection is allowed per process. Use `close` to close the connection.
+    If called with the same connection string, the same connection object will be returned.
+    You can use the connection object to create cursor object. `cursor` method will return a cursor object.
+
+    Args:
+        connection_string (str, optional): Connection string. Defaults to ":memory:".
+        Aslo support file path like:
+          - ":memory:" (for in-memory database)
+          - "test.db" (for relative path)
+          - "file:test.db" (same as above)
+          - "/path/to/test.db" (for absolute path)
+          - "file:/path/to/test.db" (same as above)
+          - "file:test.db?param1=value1&param2=value2" (for relative path with query params)
+          - "///path/to/test.db?param1=value1&param2=value2" (for absolute path)
+
+        Connection string args handling:
+          Connection string can contain query params like "file:test.db?param1=value1&param2=value2"
+          "param1=value1" will be passed to ClickHouse engine as start up args.
+
+          For more details, see `clickhouse local --help --verbose`
+          Some special args handling:
+            - "mode=ro" would be "--readonly=1" for clickhouse (read-only mode)
+
+    Returns:
+        Connection: Connection object
+    """
+    return Connection(connection_string)

chdb/utils/__init__.py

@@ -5,4 +5,5 @@ __all__ = [  # noqa: F405
     "convert_to_columnar",
     "infer_data_type",
     "infer_data_types",
+    "trace",
 ]

chdb/utils/trace.py

@@ -0,0 +1,74 @@
+import functools
+import inspect
+import sys
+import linecache
+from datetime import datetime
+
+enable_print = False
+
+
+def print_lines(func):
+    if not enable_print:
+        return func
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Get function name and determine if it's a method
+        is_method = inspect.ismethod(func) or (
+            len(args) > 0 and hasattr(args[0].__class__, func.__name__)
+        )
+        class_name = args[0].__class__.__name__ if is_method else None  # type: ignore
+
+        # Get the source code of the function
+        try:
+            source_lines, start_line = inspect.getsourcelines(func)
+        except OSError:
+            # Handle cases where source might not be available
+            print(f"Warning: Could not get source for {func.__name__}")
+            return func(*args, **kwargs)
+
+        def trace(frame, event, arg):
+            if event == "line":
+                # Get the current line number and code
+                line_no = frame.f_lineno
+                line = linecache.getline(frame.f_code.co_filename, line_no).strip()
+
+                # Don't print decorator lines or empty lines
+                if line and not line.startswith("@"):
+                    # Get local variables
+                    local_vars = frame.f_locals.copy()
+                    if is_method:
+                        # Remove 'self' from local variables for clarity
+                        local_vars.pop("self", None)
+
+                    # Format timestamp
+                    timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+                    # Create context string (class.method or function)
+                    context = (
+                        f"{class_name}.{func.__name__}" if class_name else func.__name__
+                    )
+
+                    # Print execution information
+                    print(f"[{timestamp}] {context} line {line_no}: {line}")
+
+                    # Print local variables if they exist and have changed
+                    if local_vars:
+                        vars_str = ", ".join(
+                            f"{k}={repr(v)}" for k, v in local_vars.items()
+                        )
+                        print(f"    Variables: {vars_str}")
+            return trace
+
+        # Set the trace function
+        sys.settrace(trace)
+
+        # Call the original function
+        result = func(*args, **kwargs)
+
+        # Disable tracing
+        sys.settrace(None)
+
+        return result
+
+    return wrapper

{chdb-2.1.1.dist-info → chdb-2.2.0b1.dist-info}/METADATA

@@ -1,12 +1,15 @@
 Metadata-Version: 2.1
 Name: chdb
-Version: 2.1.1
+Version: 2.2.0b1
 Summary: chDB is an in-process SQL OLAP Engine powered by ClickHouse
 Home-page: https://github.com/chdb-io/chdb
 Author: auxten
 Author-email: auxten@clickhouse.com
 License: Apache-2.0
-Project-URL: Documentation, https://doc.chdb.io/
+Project-URL: Homepage, https://clickhouse.com/chdb
+Project-URL: Documentation, https://clickhouse.com/docs/en/chdb
+Project-URL: Source, https://github.com/chdb-io/chdb
+Project-URL: Download, https://pypi.org/project/chdb/#files
 Project-URL: Twitter, https://twitter.com/chdb_io
 Platform: Mac
 Platform: Linux
@@ -19,11 +22,14 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 License-File: LICENSE.txt
+Requires-Dist: pyarrow>=13.0.0
+Requires-Dist: pandas>=2.0.0
 
 <div align="center">
    <a href="https://clickhouse.com/blog/chdb-joins-clickhouse-family">📢 chDB joins the ClickHouse family 🐍+🚀</a>
@@ -312,8 +318,11 @@ For more examples, see [examples](examples) and [tests](tests).
 
 - [chDB vs Pandas](https://colab.research.google.com/drive/1FogLujJ_-ds7RGurDrUnK-U0IW8a8Qd0)
 
+- [Benchmark on DataFrame: chDB Pandas DuckDB Polars](https://benchmark.clickhouse.com/#eyJzeXN0ZW0iOnsiQWxsb3lEQiI6dHJ1ZSwiQWxsb3lEQiAodHVuZWQpIjp0cnVlLCJBdGhlbmEgKHBhcnRpdGlvbmVkKSI6dHJ1ZSwiQXRoZW5hIChzaW5nbGUpIjp0cnVlLCJBdXJvcmEgZm9yIE15U1FMIjp0cnVlLCJBdXJvcmEgZm9yIFBvc3RncmVTUUwiOnRydWUsIkJ5Q29uaXR5Ijp0cnVlLCJCeXRlSG91c2UiOnRydWUsImNoREIgKERhdGFGcmFtZSkiOnRydWUsImNoREIgKFBhcnF1ZXQsIHBhcnRpdGlvbmVkKSI6dHJ1ZSwiY2hEQiI6dHJ1ZSwiQ2l0dXMiOnRydWUsIkNsaWNrSG91c2UgQ2xvdWQgKGF3cykiOnRydWUsIkNsaWNrSG91c2UgQ2xvdWQgKGF6dXJlKSI6dHJ1ZSwiQ2xpY2tIb3VzZSBDbG91ZCAoZ2NwKSI6dHJ1ZSwiQ2xpY2tIb3VzZSAoZGF0YSBsYWtlLCBwYXJ0aXRpb25lZCkiOnRydWUsIkNsaWNrSG91c2UgKGRhdGEgbGFrZSwgc2luZ2xlKSI6dHJ1ZSwiQ2xpY2tIb3VzZSAoUGFycXVldCwgcGFydGl0aW9uZWQpIjp0cnVlLCJDbGlja0hvdXNlIChQYXJxdWV0LCBzaW5nbGUpIjp0cnVlLCJDbGlja0hvdXNlICh3ZWIpIjp0cnVlLCJDbGlja0hvdXNlIjp0cnVlLCJDbGlja0hvdXNlICh0dW5lZCkiOnRydWUsIkNsaWNrSG91c2UgKHR1bmVkLCBtZW1vcnkpIjp0cnVlLCJDbG91ZGJlcnJ5Ijp0cnVlLCJDcmF0ZURCIjp0cnVlLCJDcnVuY2h5IEJyaWRnZSBmb3IgQW5hbHl0aWNzIChQYXJxdWV0KSI6dHJ1ZSwiRGF0YWJlbmQiOnRydWUsIkRhdGFGdXNpb24gKFBhcnF1ZXQsIHBhcnRpdGlvbmVkKSI6dHJ1ZSwiRGF0YUZ1c2lvbiAoUGFycXVldCwgc2luZ2xlKSI6dHJ1ZSwiQXBhY2hlIERvcmlzIjp0cnVlLCJEcnVpZCI6dHJ1ZSwiRHVja0RCIChEYXRhRnJhbWUpIjp0cnVlLCJEdWNrREIgKFBhcnF1ZXQsIHBhcnRpdGlvbmVkKSI6dHJ1ZSwiRHVja0RCIjp0cnVlLCJFbGFzdGljc2VhcmNoIjp0cnVlLCJFbGFzdGljc2VhcmNoICh0dW5lZCkiOmZhbHNlLCJHbGFyZURCIjp0cnVlLCJHcmVlbnBsdW0iOnRydWUsIkhlYXZ5QUkiOnRydWUsIkh5ZHJhIjp0cnVlLCJJbmZvYnJpZ2h0Ijp0cnVlLCJLaW5ldGljYSI6dHJ1ZSwiTWFyaWFEQiBDb2x1bW5TdG9yZSI6dHJ1ZSwiTWFyaWFEQiI6ZmFsc2UsIk1vbmV0REIiOnRydWUsIk1vbmdvREIiOnRydWUsIk1vdGhlcmR1Y2siOnRydWUsIk15U1FMIChNeUlTQU0pIjp0cnVlLCJNeVNRTCI6dHJ1ZSwiT3hsYSI6dHJ1ZSwiUGFuZGFzIChEYXRhRnJhbWUpIjp0cnVlLCJQYXJhZGVEQiAoUGFycXVldCwgcGFydGl0aW9uZWQpIjp0cnVlLCJQYXJhZGVEQiAoUGFycXVldCwgc2luZ2xlKSI6dHJ1ZSwiUGlub3QiOnRydWUsIlBvbGFycyAoRGF0YUZyYW1lKSI6dHJ1ZSwiUG9zdGdyZVNRTCAodHVuZWQpIjpmYWxzZSwiUG9zdGdyZVNRTCI6dHJ1ZSwiUXVlc3REQiAocGFydGl0aW9uZWQpIjp0cnVlLCJRdWVzdERCIjp0cnVlLCJSZWRzaGlmdCI6dHJ1ZSwiU2luZ2xlU3RvcmUiOnRydWUsIlNub3dmbGFrZSI6dHJ1ZSwiU1FMaXRlIjp0cnVlLCJTdGFyUm9ja3MiOnRydWUsIlRhYmxlc3BhY2UiOnRydWUsIlRlbWJvIE9MQVAgKGNvbHVtbmFyKSI6dHJ1ZSwiVGltZXNjYWxlREIgKGNvbXByZXNzaW9uKSI6dHJ1ZSwiVGltZXNjYWxlREIiOnRydWUsIlVtYnJhIjp0cnVlfSwidHlwZSI6eyJDIjpmYWxzZSwiY29sdW1uLW9yaWVudGVkIjpmYWxzZSwiUG9zdGdyZVNRTCBjb21wYXRpYmxlIjpmYWxzZSwibWFuYWdlZCI6ZmFsc2UsImdjcCI6ZmFsc2UsInN0YXRlbGVzcyI6ZmFsc2UsIkphdmEiOmZhbHNlLCJDKysiOmZhbHNlLCJNeVNRTCBjb21wYXRpYmxlIjpmYWxzZSwicm93LW9yaWVudGVkIjpmYWxzZSwiQ2xpY2tIb3VzZSBkZXJpdmF0aXZlIjpmYWxzZSwiZW1iZWRkZWQiOmZhbHNlLCJzZXJ2ZXJsZXNzIjpmYWxzZSwiZGF0YWZyYW1lIjp0cnVlLCJhd3MiOmZhbHNlLCJhenVyZSI6ZmFsc2UsImFuYWx5dGljYWwiOmZhbHNlLCJSdXN0IjpmYWxzZSwic2VhcmNoIjpmYWxzZSwiZG9jdW1lbnQiOmZhbHNlLCJzb21ld2hhdCBQb3N0Z3JlU1FMIGNvbXBhdGlibGUiOmZhbHNlLCJ0aW1lLXNlcmllcyI6ZmFsc2V9LCJtYWNoaW5lIjp7IjE2IHZDUFUgMTI4R0IiOnRydWUsIjggdkNQVSA2NEdCIjp0cnVlLCJzZXJ2ZXJsZXNzIjp0cnVlLCIxNmFjdSI6dHJ1ZSwiYzZhLjR4bGFyZ2UsIDUwMGdiIGdwMiI6dHJ1ZSwiTCI6dHJ1ZSwiTSI6dHJ1ZSwiUyI6dHJ1ZSwiWFMiOnRydWUsImM2YS5tZXRhbCwgNTAwZ2IgZ3AyIjp0cnVlLCIxOTJHQiI6dHJ1ZSwiMjRHQiI6dHJ1ZSwiMzYwR0IiOnRydWUsIjQ4R0IiOnRydWUsIjcyMEdCIjp0cnVlLCI5NkdCIjp0cnVlLCJkZXYiOnRydWUsIjcwOEdCIjp0cnVlLCJjNW4uNHhsYXJnZSwgNTAwZ2IgZ3AyIjp0cnVlLCJBbmFseXRpY3MtMjU2R0IgKDY0IHZDb3JlcywgMjU2IEdCKSI6dHJ1ZSwiYzUuNHhsYXJnZSwgNTAwZ2IgZ3AyIjp0cnVlLCJjNmEuNHhsYXJnZSwgMTUwMGdiIGdwMiI6dHJ1ZSwiY2xvdWQiOnRydWUsImRjMi44eGxhcmdlIjp0cnVlLCJyYTMuMTZ4bGFyZ2UiOnRydWUsInJhMy40eGxhcmdlIjp0cnVlLCJyYTMueGxwbHVzIjp0cnVlLCJTMiI6dHJ1ZSwiUzI0Ijp0cnVlLCIyWEwiOnRydWUsIjNYTCI6dHJ1ZSwiNFhMIjp0cnVlLCJYTCI6dHJ1ZSwiTDEgLSAxNkNQVSAzMkdCIjp0cnVlLCJjNmEuNHhsYXJnZSwgNTAwZ2IgZ3AzIjp0cnVlfSwiY2x1c3Rlcl9zaXplIjp7IjEiOnRydWUsIjIiOnRydWUsIjQiOnRydWUsIjgiOnRydWUsIjE2Ijp0cnVlLCIzMiI6dHJ1ZSwiNjQiOnRydWUsIjEyOCI6dHJ1ZSwic2VydmVybGVzcyI6dHJ1ZX0sIm1ldHJpYyI6ImhvdCIsInF1ZXJpZXMiOlt0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWUsdHJ1ZSx0cnVlXX0=)
+
+
 <div align="center">
-    <img src="https://github.com/chdb-io/chdb/raw/main/docs/_static/chdb-vs-pandas.jpg" width="800">
+    <img src="https://github.com/chdb-io/chdb/raw/main/docs/_static/df_bench.png" width="800">
 </div>
 
 
@@ -337,6 +346,10 @@ There are something you can help:
 
 We welcome bindings for other languages, please refer to [bindings](bindings.md) for more details.
 
+## Paper
+
+- [ClickHouse - Lightning Fast Analytics for Everyone](https://www.vldb.org/pvldb/vol17/p3731-schulze.pdf)
+
 ## License
 Apache 2.0, see [LICENSE](LICENSE.txt) for more information.
 

{chdb-2.1.1.dist-info → chdb-2.2.0b1.dist-info}/RECORD

@@ -1,25 +1,28 @@
-chdb/__init__.py,sha256=WoHYwRMh_xAz1NY8zkt2Nv0ZedTgUjQeR6Rivppk7DE,2923
+chdb/__init__.py,sha256=li1sCjhLx7HmRBbWtekahee1iQtJl5p69oGYIaVVplk,2994
 chdb/__main__.py,sha256=xNNtDY38d973YM5dlxiIazcqqKhXJSpNb7JflyyrXGE,1185
-chdb/_chdb.cpython-39-darwin.so,sha256=PZFJTUVbZfcv9e5GFCH0WqU4I_b6bYIT5sc8VFVkWQ4,355968448
+chdb/_chdb.cpython-39-darwin.so,sha256=58Nvy86wQxr1k998QjxHvLV0FvrAaPdRiAAfkthoYpo,356021376
 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=P4ZKot4r9UPC8dLfVRV4qFTZ4_VXIQdF84jjZ-01fjo,6213
+chdb/dbapi/connections.py,sha256=4RBO0h-B149xEicE8cXSSJl9wpXa4FQMY_4SghgEvCw,2762
 chdb/dbapi/converters.py,sha256=qS9k0Kzo_vDQxnFtsJ_3pLjlTrBK09SfdWcXdxzIrtI,7413
-chdb/dbapi/cursors.py,sha256=kpMam9rZH80z5Td3DbIusJPqPr_gRqyKVA57BI9PNac,9354
+chdb/dbapi/cursors.py,sha256=OXF36raoyI3MIC5SCQ5IvnCtbOnppga4Q1IKOt2EIsk,7920
 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
 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=Hc9lJGLZ97Un7ElBbeWeCZoc9p_m1k_ojQbzJMPBPKg,1341
+chdb/state/__init__.py,sha256=RVUIWDqDi7gte4Os7Mz1wPXFyFpdHT_p1klJC7QtluI,55
+chdb/state/sqlitelike.py,sha256=RSVJW5M3hH_TUBcXiH7zna21WTSGbqkOccyEiFFd8PI,4425
 chdb/udf/__init__.py,sha256=qSMaPEre7w1pYz8uJ-iZtuu8wYOUNRcI_8UNuaOymGE,80
 chdb/udf/udf.py,sha256=z0A1RmyZrx55bykpvvS-LpVt1lMrQOexjvU5zxCdCSA,3935
-chdb/utils/__init__.py,sha256=bC1m0_bbbl4Eqis0t_qt5s7hySriU7vsO1_sx7JFbGU,158
+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-2.1.1.dist-info/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
-chdb-2.1.1.dist-info/METADATA,sha256=l0tJPTzemw1dtkkOy7XBMjuw2THbdcgDW4V2mgJ-2t4,14944
-chdb-2.1.1.dist-info/WHEEL,sha256=qPSLW7RKkSazFLr9GqnCq82B2cy1OopxhNJnY83fx9k,107
-chdb-2.1.1.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
-chdb-2.1.1.dist-info/RECORD,,
+chdb-2.2.0b1.dist-info/LICENSE.txt,sha256=isYVtNCO5910aj6e9bJJ6kQceivkLqsMlFSNYwzGGKI,11366
+chdb-2.2.0b1.dist-info/METADATA,sha256=cjvQmdOiS1pll_E2ohhXF2DVb7wdbVndY00xLuCnVi8,19444
+chdb-2.2.0b1.dist-info/WHEEL,sha256=bpdNn3EW1Ro7rhzacUi9J-tn-B2haoCtXthtgNlZT0g,107
+chdb-2.2.0b1.dist-info/top_level.txt,sha256=se0Jj0A2-ijfMW51hIjiuNyDJPqy5xJU1G8a_IEdllI,11
+chdb-2.2.0b1.dist-info/RECORD,,

{chdb-2.1.1.dist-info → chdb-2.2.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: false
 Tag: cp39-cp39-macosx_11_0_arm64