commitdb 2.1.0__tar.gz → 2.2.0__tar.gz

{commitdb-2.1.0 → commitdb-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitdb
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python driver for CommitDB SQL Server
 Author: CommitDB Contributors
 License: Apache-2.0
@@ -19,6 +19,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: ibis
+Requires-Dist: ibis-framework>=9.0; extra == "ibis"
+Requires-Dist: pandas>=2.0; extra == "ibis"
 
 # CommitDB Python Driver
 
@@ -65,6 +68,31 @@ with CommitDBLocal('/path/to/data') as db:  # File-based (persistent)
     db.execute('CREATE DATABASE mydb')
 ```
 
+### Ibis Mode (pandas DataFrame support)
+
+```bash
+pip install commitdb[ibis]
+```
+
+```python
+import ibis
+
+con = ibis.commitdb.connect('localhost', 3306, database='mydb')
+
+# Or use URL-based connection:
+con = ibis.connect('commitdb://localhost:3306/mydb')
+
+# Query with Ibis expressions
+users = con.table('users')
+result = users.filter(users.age > 30).select('name', 'city').execute()  # → pandas DataFrame
+print(result)
+
+# Insert from DataFrame
+import pandas as pd
+df = pd.DataFrame({'id': [1, 2], 'name': ['Alice', 'Bob']})
+con.insert('users', df)
+```
+
 ---
 
 ## API Reference

{commitdb-2.1.0 → commitdb-2.2.0}/README.md

@@ -43,6 +43,31 @@ with CommitDBLocal('/path/to/data') as db:  # File-based (persistent)
     db.execute('CREATE DATABASE mydb')
 ```
 
+### Ibis Mode (pandas DataFrame support)
+
+```bash
+pip install commitdb[ibis]
+```
+
+```python
+import ibis
+
+con = ibis.commitdb.connect('localhost', 3306, database='mydb')
+
+# Or use URL-based connection:
+con = ibis.connect('commitdb://localhost:3306/mydb')
+
+# Query with Ibis expressions
+users = con.table('users')
+result = users.filter(users.age > 30).select('name', 'city').execute()  # → pandas DataFrame
+print(result)
+
+# Insert from DataFrame
+import pandas as pd
+df = pd.DataFrame({'id': [1, 2], 'name': ['Alice', 'Bob']})
+con.insert('users', df)
+```
+
 ---
 
 ## API Reference

{commitdb-2.1.0 → commitdb-2.2.0}/commitdb/__init__.py

@@ -30,7 +30,14 @@ Embedded mode (requires libcommitdb):
         db.execute('CREATE DATABASE mydb')
 """
 
+from importlib.metadata import version, PackageNotFoundError
+
 from .client import CommitDB, CommitDBLocal, QueryResult, CommitResult, CommitDBError
 
-__version__ = '0.1.0'
-__all__ = ['CommitDB', 'CommitDBLocal', 'QueryResult', 'CommitResult', 'CommitDBError']
+try:
+    __version__ = version("commitdb")
+except PackageNotFoundError:
+    __version__ = "0.0.0"  # Fallback for development/editable installs
+
+__all__ = ['CommitDB', 'CommitDBLocal', 'QueryResult', 'CommitResult', 'CommitDBError', '__version__']
+

{commitdb-2.1.0 → commitdb-2.2.0}/commitdb/client.py

@@ -20,7 +20,8 @@ class QueryResult:
     columns: list[str]
     data: list[list[str]]
     records_read: int
-    time_ms: float
+    execution_time_ms: float
+    execution_ops: int = 0
 
     def __iter__(self) -> Iterator[dict[str, str]]:
         """Iterate over rows as dictionaries."""
@@ -43,7 +44,8 @@ class CommitResult:
     tables_deleted: int = 0
     records_written: int = 0
     records_deleted: int = 0
-    time_ms: float = 0.0
+    execution_time_ms: float = 0.0
+    execution_ops: int = 0
 
     @property
     def affected_rows(self) -> int:
@@ -236,7 +238,8 @@ class CommitDB:
                 columns=result_data.get('columns', []),
                 data=result_data.get('data', []),
                 records_read=result_data.get('records_read', 0),
-                time_ms=result_data.get('time_ms', 0.0)
+                execution_time_ms=result_data.get('execution_time_ms', 0.0),
+                execution_ops=result_data.get('execution_ops', 0)
             )
         elif result_type == 'commit':
             return CommitResult(
@@ -246,7 +249,8 @@ class CommitDB:
                 tables_deleted=result_data.get('tables_deleted', 0),
                 records_written=result_data.get('records_written', 0),
                 records_deleted=result_data.get('records_deleted', 0),
-                time_ms=result_data.get('time_ms', 0.0)
+                execution_time_ms=result_data.get('execution_time_ms', 0.0),
+                execution_ops=result_data.get('execution_ops', 0)
             )
         else:
             # Unknown type, return empty commit result
@@ -325,6 +329,60 @@ class CommitDB:
         result = self.query(f'SHOW TABLES IN {database}')
         return [row[0] for row in result.data] if result.data else []
 
+    def create_share(self, name: str, url: str, token: str = None,
+                     ssh_key: str = None, passphrase: str = None) -> CommitResult:
+        """
+        Create a share from an external Git repository.
+
+        Args:
+            name: Share name
+            url: Git repository URL
+            token: Optional authentication token (for HTTPS)
+            ssh_key: Optional path to SSH private key
+            passphrase: Optional passphrase for SSH key
+
+        Example:
+            db.create_share('sample', 'https://github.com/org/data.git')
+            db.create_share('private', 'git@github.com:org/data.git', ssh_key='~/.ssh/id_rsa')
+        """
+        query = f"CREATE SHARE {name} FROM '{url}'"
+        if token:
+            query += f" WITH TOKEN '{token}'"
+        elif ssh_key:
+            query += f" WITH SSH KEY '{ssh_key}'"
+            if passphrase:
+                query += f" PASSPHRASE '{passphrase}'"
+        return self.execute(query)
+
+    def sync_share(self, name: str, token: str = None,
+                   ssh_key: str = None, passphrase: str = None) -> CommitResult:
+        """
+        Synchronize a share with its remote repository.
+
+        Args:
+            name: Share name
+            token: Optional authentication token (for HTTPS)
+            ssh_key: Optional path to SSH private key
+            passphrase: Optional passphrase for SSH key
+        """
+        query = f"SYNC SHARE {name}"
+        if token:
+            query += f" WITH TOKEN '{token}'"
+        elif ssh_key:
+            query += f" WITH SSH KEY '{ssh_key}'"
+            if passphrase:
+                query += f" PASSPHRASE '{passphrase}'"
+        return self.execute(query)
+
+    def drop_share(self, name: str) -> CommitResult:
+        """Drop a share."""
+        return self.execute(f"DROP SHARE {name}")
+
+    def show_shares(self) -> list[dict[str, str]]:
+        """List all shares."""
+        result = self.query('SHOW SHARES')
+        return [{'name': row[0], 'url': row[1]} for row in result.data] if result.data else []
+
 
 class CommitDBLocal:
     """
@@ -395,7 +453,8 @@ class CommitDBLocal:
                 columns=result_data.get('columns', []),
                 data=result_data.get('data', []),
                 records_read=result_data.get('records_read', 0),
-                time_ms=result_data.get('time_ms', 0.0)
+                execution_time_ms=result_data.get('execution_time_ms', 0.0),
+                execution_ops=result_data.get('execution_ops', 0)
             )
         elif result_type == 'commit':
             return CommitResult(
@@ -405,7 +464,8 @@ class CommitDBLocal:
                 tables_deleted=result_data.get('tables_deleted', 0),
                 records_written=result_data.get('records_written', 0),
                 records_deleted=result_data.get('records_deleted', 0),
-                time_ms=result_data.get('time_ms', 0.0)
+                execution_time_ms=result_data.get('execution_time_ms', 0.0),
+                execution_ops=result_data.get('execution_ops', 0)
             )
         else:
             return CommitResult()

commitdb-2.2.0/commitdb/ibis_backend.py

@@ -0,0 +1,490 @@
+"""
+CommitDB Ibis Backend
+
+Provides an Ibis backend for CommitDB, enabling pandas DataFrame support
+and lazy expression evaluation.
+
+Usage:
+    import ibis
+
+    # Connect using ibis.commitdb
+    con = ibis.commitdb.connect('localhost', 3306, database='mydb')
+
+    # Or use URL-based connection
+    con = ibis.connect('commitdb://localhost:3306/mydb')
+
+    # Query with Ibis expressions
+    users = con.table('users')
+    result = users.filter(users.age > 30).execute()  # Returns pandas DataFrame
+"""
+
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING, Any
+
+import ibis.expr.datatypes as dt
+import ibis.expr.schema as sch
+import ibis.expr.types as ir
+from ibis.backends.sql import SQLBackend
+from ibis.backends.sql.compilers import SQLiteCompiler
+
+from . import __version__
+
+from .client import CommitDB as CommitDBClient, CommitDBError
+
+if TYPE_CHECKING:
+    import pandas as pd
+    import sqlglot as sg
+
+
+# Type mapping from CommitDB types to Ibis types
+# Based on: STRING, INT, INTEGER, FLOAT, DOUBLE, REAL, BOOL, BOOLEAN, TEXT, DATE, TIMESTAMP, DATETIME, JSON
+COMMITDB_TYPE_MAP = {
+    # String types
+    "STRING": dt.String,
+    "TEXT": dt.String,
+    # Integer types
+    "INT": dt.Int64,
+    "INTEGER": dt.Int64,
+    # Float types
+    "FLOAT": dt.Float64,
+    "DOUBLE": dt.Float64,
+    "REAL": dt.Float64,
+    # Boolean types
+    "BOOL": dt.Boolean,
+    "BOOLEAN": dt.Boolean,
+    # Date/time types
+    "DATE": dt.Date,
+    "TIMESTAMP": dt.Timestamp,
+    "DATETIME": dt.Timestamp,
+    # JSON type
+    "JSON": dt.JSON,
+}
+
+
+class CommitDBCompiler(SQLiteCompiler):
+    """SQL compiler for CommitDB.
+    
+    CommitDB's SQL is similar enough to SQLite that we can reuse most of it.
+    """
+    __slots__ = ()
+    dialect = "sqlite"  # Use SQLite dialect for sqlglot
+
+
+class Backend(SQLBackend):
+    """Ibis backend for CommitDB.
+    
+    This backend connects to a CommitDB server and executes queries,
+    returning results as pandas DataFrames.
+    """
+    
+    name = "commitdb"
+    compiler = CommitDBCompiler
+    supports_temporary_tables = False
+    supports_python_udfs = False
+    
+    @classmethod
+    def _from_url(cls, url, **kwargs) -> "Backend":
+        """Create a backend from a URL.
+        
+        URL format: commitdb://host:port/database
+        
+        Examples
+        --------
+        >>> ibis.connect("commitdb://localhost:3306/mydb")
+        """
+        from urllib.parse import urlparse, ParseResult
+        
+        # Handle both string URLs and pre-parsed ParseResult
+        if isinstance(url, str):
+            parsed = urlparse(url)
+        else:
+            parsed = url  # Already a ParseResult from ibis.connect()
+        
+        host = parsed.hostname or "localhost"
+        port = parsed.port or 3306
+        database = parsed.path.lstrip("/") or None
+        
+        # Parse query params for additional options
+        if parsed.query:
+            from urllib.parse import parse_qs
+            params = parse_qs(parsed.query)
+            for key, values in params.items():
+                if key not in kwargs:
+                    kwargs[key] = values[0] if len(values) == 1 else values
+        
+        backend = cls()
+        backend.do_connect(host=host, port=port, database=database, **kwargs)
+        return backend
+    
+    def __init__(self):
+        super().__init__()
+        self._client: CommitDBClient | None = None
+        self._current_database: str | None = None
+        self._in_memory_tables: dict[str, Any] = {}
+    
+    def _get_schema_using_query(self, query: str) -> sch.Schema:
+        """Get schema by executing a query with LIMIT 1.
+        
+        Note: CommitDB doesn't support subqueries, so we execute the query
+        directly with a limit to infer the schema from results.
+        """
+        client = self._ensure_connected()
+        
+        # Add LIMIT 1 if not already present to minimize data transfer
+        query_upper = query.strip().upper()
+        if "LIMIT" not in query_upper:
+            query = f"{query.rstrip().rstrip(';')} LIMIT 1"
+        
+        try:
+            result = client.query(query)
+            # Infer schema from column names (all strings for now since
+            # CommitDB returns string values over the wire)
+            fields = {col: dt.String(nullable=True) for col in result.columns}
+            return sch.Schema(fields)
+        except Exception:
+            # If query fails, return empty schema
+            return sch.Schema({})
+    
+    def _register_in_memory_table(self, op: Any) -> None:
+        """Register a table for in-memory operations.
+        
+        CommitDB doesn't support in-memory tables, so we store them locally.
+        """
+        # Store the table data for later insertion
+        name = op.name
+        self._in_memory_tables[name] = op
+    
+    @property
+    def version(self) -> str:
+        """Return CommitDB Python driver version."""
+        return __version__
+    
+    @property
+    def current_database(self) -> str | None:
+        """Return the current database."""
+        return self._current_database
+    
+    def connect(self, *args, **kwargs) -> "Backend":
+        """Connect to the database.
+        
+        Creates a new backend instance and connects it.
+        """
+        new = self.__class__()
+        new.do_connect(*args, **kwargs)
+        return new
+    
+    def do_connect(
+        self,
+        host: str = "localhost",
+        port: int = 3306,
+        database: str | None = None,
+        use_ssl: bool = False,
+        ssl_verify: bool = True,
+        ssl_ca_cert: str | None = None,
+        jwt_token: str | None = None,
+    ) -> None:
+        """Connect to a CommitDB server.
+        
+        Parameters
+        ----------
+        host
+            Server hostname
+        port
+            Server port (default 3306)
+        database
+            Default database to use
+        use_ssl
+            Enable SSL/TLS encryption
+        ssl_verify
+            Verify server certificate
+        ssl_ca_cert
+            Path to CA certificate file
+        jwt_token
+            JWT token for authentication
+        """
+        self._client = CommitDBClient(
+            host=host,
+            port=port,
+            use_ssl=use_ssl,
+            ssl_verify=ssl_verify,
+            ssl_ca_cert=ssl_ca_cert,
+            jwt_token=jwt_token,
+        )
+        self._client.connect()
+        self._current_database = database
+    
+    def disconnect(self) -> None:
+        """Close the connection."""
+        if self._client:
+            self._client.close()
+            self._client = None
+    
+    def _ensure_connected(self) -> CommitDBClient:
+        """Ensure we have a valid connection."""
+        if self._client is None:
+            raise CommitDBError("Not connected. Call connect() first.")
+        return self._client
+    
+    def list_databases(self, *, like: str | None = None) -> list[str]:
+        """List all databases."""
+        client = self._ensure_connected()
+        result = client.query("SHOW DATABASES")
+        databases = [row[0] for row in result.data]
+        return self._filter_with_like(databases, like)
+    
+    def list_tables(
+        self, *, like: str | None = None, database: str | None = None
+    ) -> list[str]:
+        """List tables in a database."""
+        client = self._ensure_connected()
+        db = database or self._current_database
+        if not db:
+            raise CommitDBError("No database specified. Use database parameter or set current_database.")
+        
+        result = client.query(f"SHOW TABLES IN {db}")
+        tables = [row[0] for row in result.data]
+        return self._filter_with_like(tables, like)
+    
+    def _parse_type(self, type_str: str) -> dt.DataType:
+        """Parse a CommitDB type string into an Ibis DataType."""
+        type_upper = type_str.upper().strip()
+        
+        # Handle PRIMARY KEY suffix
+        if "PRIMARY KEY" in type_upper:
+            type_upper = type_upper.replace("PRIMARY KEY", "").strip()
+        
+        type_class = COMMITDB_TYPE_MAP.get(type_upper, dt.String)
+        return type_class(nullable=True)
+    
+    def get_schema(
+        self,
+        table_name: str,
+        *,
+        catalog: str | None = None,
+        database: str | None = None,
+    ) -> sch.Schema:
+        """Get the schema of a table."""
+        client = self._ensure_connected()
+        
+        # Handle database.table format
+        if "." in table_name:
+            db, tbl = table_name.split(".", 1)
+        else:
+            db = database or self._current_database
+            tbl = table_name
+            if not db:
+                raise CommitDBError("No database specified.")
+        
+        # Get table structure using DESCRIBE
+        result = client.query(f"DESCRIBE {db}.{tbl}")
+        
+        # Parse columns: DESCRIBE returns (name, type) tuples
+        fields = {}
+        for row in result.data:
+            col_name = row[0]
+            col_type = row[1] if len(row) > 1 else "STRING"
+            fields[col_name] = self._parse_type(col_type)
+        
+        return sch.Schema(fields)
+    
+    def raw_sql(self, query: str | sg.Expression, **kwargs: Any) -> Any:
+        """Execute raw SQL."""
+        client = self._ensure_connected()
+        if not isinstance(query, str):
+            query = query.sql(dialect="sqlite")
+        return client.execute(query)
+    
+    @contextlib.contextmanager
+    def _safe_raw_sql(self, query: str | sg.Expression, **kwargs):
+        """Execute SQL and yield the result."""
+        result = self.raw_sql(query, **kwargs)
+        try:
+            yield result
+        finally:
+            pass  # No cursor to close
+    
+    def execute(
+        self,
+        expr: ir.Expr,
+        params: dict | None = None,
+        limit: str | None = "default",
+        **kwargs: Any,
+    ) -> pd.DataFrame:
+        """Execute an Ibis expression and return a pandas DataFrame."""
+        import pandas as pd
+        
+        # Compile expression to SQL
+        sql = self.compile(expr, params=params, limit=limit)
+        
+        # Execute
+        client = self._ensure_connected()
+        result = client.query(sql)
+        
+        # Convert to DataFrame
+        df = pd.DataFrame(result.data, columns=result.columns)
+        
+        # Apply type conversions if needed
+        schema = expr.schema() if hasattr(expr, "schema") else None
+        if schema:
+            for col, dtype in schema.items():
+                if col in df.columns:
+                    if isinstance(dtype, dt.Int64):
+                        df[col] = pd.to_numeric(df[col], errors="coerce").astype("Int64")
+                    elif isinstance(dtype, dt.Float64):
+                        df[col] = pd.to_numeric(df[col], errors="coerce")
+                    elif isinstance(dtype, dt.Boolean):
+                        df[col] = df[col].map({"true": True, "false": False, "1": True, "0": False})
+        
+        return df
+    
+    def create_table(
+        self,
+        name: str,
+        obj: ir.Table | pd.DataFrame | None = None,
+        *,
+        schema: sch.Schema | None = None,
+        database: str | None = None,
+        temp: bool = False,
+        overwrite: bool = False,
+    ) -> ir.Table:
+        """Create a table."""
+        client = self._ensure_connected()
+        db = database or self._current_database
+        if not db:
+            raise CommitDBError("No database specified.")
+        
+        full_name = f"{db}.{name}"
+        
+        if overwrite:
+            client.execute(f"DROP TABLE IF EXISTS {full_name}")
+        
+        if schema is not None:
+            # Create from schema
+            cols = ", ".join(
+                f"{col} {self._ibis_type_to_commitdb(dtype)}"
+                for col, dtype in schema.items()
+            )
+            client.execute(f"CREATE TABLE {full_name} ({cols})")
+        
+        if obj is not None:
+            import pandas as pd
+            if isinstance(obj, pd.DataFrame):
+                # Insert data from DataFrame
+                self._insert_dataframe(full_name, obj)
+        
+        return self.table(name, database=db)
+    
+    def _ibis_type_to_commitdb(self, dtype: dt.DataType) -> str:
+        """Convert Ibis DataType to CommitDB type string."""
+        if isinstance(dtype, (dt.Int8, dt.Int16, dt.Int32, dt.Int64,
+                              dt.UInt8, dt.UInt16, dt.UInt32, dt.UInt64)):
+            return "INT"
+        elif isinstance(dtype, (dt.Float32, dt.Float64)):
+            return "FLOAT"
+        elif isinstance(dtype, dt.String):
+            return "STRING"
+        elif isinstance(dtype, dt.Boolean):
+            return "BOOL"
+        elif isinstance(dtype, dt.Date):
+            return "DATE"
+        elif isinstance(dtype, dt.Timestamp):
+            return "TIMESTAMP"
+        elif isinstance(dtype, dt.JSON):
+            return "JSON"
+        else:
+            return "STRING"
+    
+    def _insert_dataframe(self, table: str, df: pd.DataFrame) -> None:
+        """Insert a pandas DataFrame into a table."""
+        client = self._ensure_connected()
+        
+        if df.empty:
+            return
+        
+        cols = ", ".join(df.columns)
+        
+        # Build multi-value INSERT
+        values_list = []
+        for _, row in df.iterrows():
+            vals = []
+            for v in row:
+                if v is None or (isinstance(v, float) and pd.isna(v)):
+                    vals.append("NULL")
+                elif isinstance(v, str):
+                    # Escape single quotes
+                    escaped = v.replace("'", "''")
+                    vals.append(f"'{escaped}'")
+                elif isinstance(v, bool):
+                    vals.append("1" if v else "0")
+                else:
+                    vals.append(str(v))
+            values_list.append(f"({', '.join(vals)})")
+        
+        # Insert in batches of 100
+        batch_size = 100
+        for i in range(0, len(values_list), batch_size):
+            batch = values_list[i:i + batch_size]
+            sql = f"INSERT INTO {table} ({cols}) VALUES {', '.join(batch)}"
+            client.execute(sql)
+    
+    def insert(
+        self,
+        table_name: str,
+        obj: pd.DataFrame | ir.Table,
+        *,
+        database: str | None = None,
+    ) -> None:
+        """Insert data into a table."""
+        import pandas as pd
+        
+        db = database or self._current_database
+        if not db:
+            raise CommitDBError("No database specified.")
+        
+        full_name = f"{db}.{table_name}"
+        
+        if isinstance(obj, pd.DataFrame):
+            self._insert_dataframe(full_name, obj)
+        else:
+            # Ibis Table - execute and insert
+            df = obj.execute()
+            self._insert_dataframe(full_name, df)
+
+
+def connect(
+    host: str = "localhost",
+    port: int = 3306,
+    database: str | None = None,
+    **kwargs,
+) -> Backend:
+    """Connect to a CommitDB server.
+    
+    Parameters
+    ----------
+    host
+        Server hostname
+    port
+        Server port (default 3306)
+    database
+        Default database to use
+    **kwargs
+        Additional connection parameters (use_ssl, jwt_token, etc.)
+    
+    Returns
+    -------
+    Backend
+        Connected Ibis backend
+    
+    Examples
+    --------
+    >>> import ibis
+    >>> con = ibis.commitdb.connect('localhost', 3306, database='mydb')
+    >>> users = con.table('users')
+    >>> users.filter(users.age > 30).execute()
+    """
+    backend = Backend()
+    backend.do_connect(host=host, port=port, database=database, **kwargs)
+    return backend
+

{commitdb-2.1.0 → commitdb-2.2.0}/commitdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitdb
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python driver for CommitDB SQL Server
 Author: CommitDB Contributors
 License: Apache-2.0
@@ -19,6 +19,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: ibis
+Requires-Dist: ibis-framework>=9.0; extra == "ibis"
+Requires-Dist: pandas>=2.0; extra == "ibis"
 
 # CommitDB Python Driver
 
@@ -65,6 +68,31 @@ with CommitDBLocal('/path/to/data') as db:  # File-based (persistent)
     db.execute('CREATE DATABASE mydb')
 ```
 
+### Ibis Mode (pandas DataFrame support)
+
+```bash
+pip install commitdb[ibis]
+```
+
+```python
+import ibis
+
+con = ibis.commitdb.connect('localhost', 3306, database='mydb')
+
+# Or use URL-based connection:
+con = ibis.connect('commitdb://localhost:3306/mydb')
+
+# Query with Ibis expressions
+users = con.table('users')
+result = users.filter(users.age > 30).select('name', 'city').execute()  # → pandas DataFrame
+print(result)
+
+# Insert from DataFrame
+import pandas as pd
+df = pd.DataFrame({'id': [1, 2], 'name': ['Alice', 'Bob']})
+con.insert('users', df)
+```
+
 ---
 
 ## API Reference

{commitdb-2.1.0 → commitdb-2.2.0}/commitdb.egg-info/SOURCES.txt

@@ -3,11 +3,14 @@ pyproject.toml
 commitdb/__init__.py
 commitdb/binding.py
 commitdb/client.py
+commitdb/ibis_backend.py
 commitdb.egg-info/PKG-INFO
 commitdb.egg-info/SOURCES.txt
 commitdb.egg-info/dependency_links.txt
+commitdb.egg-info/entry_points.txt
 commitdb.egg-info/requires.txt
 commitdb.egg-info/top_level.txt
 commitdb/lib/libcommitdb-linux-amd64.so
 tests/__init__.py
-tests/test_client.py
+tests/test_client.py
+tests/test_ibis.py

commitdb-2.2.0/commitdb.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[ibis.backends]
+commitdb = commitdb.ibis_backend

commitdb-2.2.0/commitdb.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+pytest>=7.0
+
+[ibis]
+ibis-framework>=9.0
+pandas>=2.0

{commitdb-2.1.0 → commitdb-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "commitdb"
-version = "2.1.0"
+version = "2.2.0"
 description = "Python driver for CommitDB SQL Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -36,3 +36,7 @@ commitdb = ["lib/*.so", "lib/*.dylib", "lib/*.dll"]
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0"]
+ibis = ["ibis-framework>=9.0", "pandas>=2.0"]
+
+[project.entry-points."ibis.backends"]
+commitdb = "commitdb.ibis_backend"

{commitdb-2.1.0 → commitdb-2.2.0}/tests/test_client.py

@@ -18,7 +18,7 @@ class TestQueryResult:
             columns=['id', 'name'],
             data=[['1', 'Alice'], ['2', 'Bob']],
             records_read=2,
-            time_ms=1.0
+            execution_time_ms=1.0
         )
 
         rows = list(result)
@@ -32,7 +32,7 @@ class TestQueryResult:
             columns=['id'],
             data=[['1'], ['2'], ['3']],
             records_read=3,
-            time_ms=1.0
+            execution_time_ms=1.0
         )
         assert len(result) == 3
 
@@ -41,7 +41,7 @@ class TestQueryResult:
             columns=['id', 'name'],
             data=[['1', 'Alice'], ['2', 'Bob']],
             records_read=2,
-            time_ms=1.0
+            execution_time_ms=1.0
         )
         assert result[0] == {'id': '1', 'name': 'Alice'}
         assert result[1] == {'id': '2', 'name': 'Bob'}
@@ -61,7 +61,7 @@ class TestCommitResult:
     def test_defaults(self):
         result = CommitResult()
         assert result.affected_rows == 0
-        assert result.time_ms == 0.0
+        assert result.execution_time_ms == 0.0
 
 
 class TestCommitDBUnit:

commitdb-2.2.0/tests/test_ibis.py

@@ -0,0 +1,88 @@
+"""Tests for the Ibis backend."""
+
+import pytest
+
+# Skip all tests if ibis is not installed
+ibis = pytest.importorskip("ibis")
+pd = pytest.importorskip("pandas")
+
+
+class TestIbisBackendUnit:
+    """Unit tests for ibis backend that don't require a server."""
+    
+    def test_import_backend(self):
+        """Test that the backend can be imported."""
+        from commitdb import ibis_backend
+        assert hasattr(ibis_backend, "Backend")
+    
+    def test_backend_registered(self):
+        """Test that the backend is registered via entry points."""
+        from importlib.metadata import entry_points
+        
+        # Check entry points registration
+        eps = entry_points(group='ibis.backends')
+        names = [ep.name for ep in eps]
+        assert 'commitdb' in names
+    
+    def test_type_mapping(self):
+        """Test CommitDB to Ibis type mapping."""
+        from commitdb.ibis_backend import COMMITDB_TYPE_MAP
+        import ibis.expr.datatypes as dt
+        
+        assert COMMITDB_TYPE_MAP["INT"] == dt.Int64
+        assert COMMITDB_TYPE_MAP["STRING"] == dt.String
+        assert COMMITDB_TYPE_MAP["FLOAT"] == dt.Float64
+        assert COMMITDB_TYPE_MAP["BOOL"] == dt.Boolean
+    
+    def test_backend_instantiation(self):
+        """Test that the backend can be instantiated."""
+        from commitdb.ibis_backend import Backend
+        
+        backend = Backend()
+        assert backend.name == "commitdb"
+        assert backend._client is None
+
+
+@pytest.mark.integration
+class TestIbisBackendIntegration:
+    """Integration tests that require a running CommitDB server.
+    
+    Run with: pytest -m integration tests/test_ibis.py
+    """
+    
+    @pytest.fixture
+    def connection(self):
+        """Create a connection to the test server."""
+        from commitdb.ibis_backend import Backend
+        
+        backend = Backend()
+        try:
+            backend.do_connect(host="localhost", port=3306, database="test")
+            yield backend
+        finally:
+            backend.disconnect()
+    
+    def test_connect(self, connection):
+        """Test connecting to the server."""
+        assert connection._client is not None
+    
+    def test_list_databases(self, connection):
+        """Test listing databases."""
+        databases = connection.list_databases()
+        assert isinstance(databases, list)
+    
+    def test_query_to_dataframe(self, connection):
+        """Test that queries return pandas DataFrames."""
+        # This requires a table to exist
+        # Skipped if no tables exist
+        databases = connection.list_databases()
+        if not databases:
+            pytest.skip("No databases available")
+        
+        tables = connection.list_tables(database=databases[0])
+        if not tables:
+            pytest.skip("No tables available")
+        
+        table = connection.table(f"{databases[0]}.{tables[0]}")
+        result = table.limit(5).execute()
+        assert isinstance(result, pd.DataFrame)

commitdb-2.1.0/commitdb.egg-info/requires.txt

@@ -1,3 +0,0 @@
-
-[dev]
-pytest>=7.0