commitdb 2.2.0__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitdb
-Version: 2.2.0
+Version: 2.3.0
 Summary: Python driver for CommitDB SQL Server
 Author: CommitDB Contributors
 License: Apache-2.0
@@ -20,7 +20,7 @@ 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: ibis-framework>=11.0; extra == "ibis"
 Requires-Dist: pandas>=2.0; extra == "ibis"
 
 # CommitDB Python Driver
@@ -32,6 +32,8 @@ Python client for CommitDB - a Git-backed SQL database engine.
 
 **[📚 Full Documentation](https://nickyhof.github.io/CommitDB/python-driver/)**
 
+> ⚠️ **Experimental Project** - This is a hobby project and should not be used in any production environment.
+
 ## Installation
 
 ```bash

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

@@ -7,6 +7,8 @@ Python client for CommitDB - a Git-backed SQL database engine.
 
 **[📚 Full Documentation](https://nickyhof.github.io/CommitDB/python-driver/)**
 
+> ⚠️ **Experimental Project** - This is a hobby project and should not be used in any production environment.
+
 ## Installation
 
 ```bash

{commitdb-2.2.0 → commitdb-2.3.0}/commitdb/ibis_backend.py

@@ -122,7 +122,8 @@ class Backend(SQLBackend):
         super().__init__()
         self._client: CommitDBClient | None = None
         self._current_database: str | None = None
-        self._in_memory_tables: dict[str, Any] = {}
+        # Compile must be an instance, not a class
+        self.compiler = CommitDBCompiler()
     
     def _get_schema_using_query(self, query: str) -> sch.Schema:
         """Get schema by executing a query with LIMIT 1.
@@ -150,11 +151,10 @@ class Backend(SQLBackend):
     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.
+        CommitDB doesn't support in-memory tables, so this is a no-op.
+        Required by SQLBackend abstract base class.
         """
-        # Store the table data for later insertion
-        name = op.name
-        self._in_memory_tables[name] = op
+        pass
     
     @property
     def version(self) -> str:
@@ -299,11 +299,43 @@ class Backend(SQLBackend):
     @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
+        yield self.raw_sql(query, **kwargs)
+    
+    def table(
+        self,
+        name: str,
+        database: str | None = None,
+    ) -> ir.Table:
+        """Get a reference to a table.
+        
+        Handles CommitDB's database.table format by splitting the name.
+        """
+        # Handle database.table format
+        if "." in name and database is None:
+            database, name = name.split(".", 1)
+        
+        return super().table(name, database=database)
+    
+    def compile(
+        self,
+        expr: ir.Expr,
+        /,
+        *,
+        limit: str | int | None = None,
+        params: dict | None = None,
+        pretty: bool = False,
+    ) -> str:
+        """Compile an expression to a SQL string.
+        
+        Overridden to remove quotes from identifiers since CommitDB
+        doesn't require quoted identifiers for simple names.
+        """
+        query = self.compiler.to_sqlglot(expr, limit=limit, params=params)
+        sql = query.sql(dialect=self.dialect, pretty=pretty, copy=False)
+        # Remove quotes from simple identifiers (CommitDB doesn't need them)
+        sql = sql.replace('"', '')
+        self._log(sql)
+        return sql
     
     def execute(
         self,
@@ -322,22 +354,8 @@ class Backend(SQLBackend):
         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
+        # Convert to DataFrame - pandas infers types from the JSON response
+        return pd.DataFrame(result.data, columns=result.columns)
     
     def create_table(
         self,
@@ -432,25 +450,44 @@ class Backend(SQLBackend):
     def insert(
         self,
         table_name: str,
-        obj: pd.DataFrame | ir.Table,
+        obj: pd.DataFrame,
         *,
         database: str | None = None,
     ) -> None:
-        """Insert data into a table."""
-        import pandas as pd
-        
+        """Insert data from a pandas DataFrame into a table."""
         db = database or self._current_database
         if not db:
             raise CommitDBError("No database specified.")
         
         full_name = f"{db}.{table_name}"
+        self._insert_dataframe(full_name, obj)
+    
+    def drop_table(
+        self,
+        name: str,
+        *,
+        database: str | None = None,
+        force: bool = False,
+    ) -> None:
+        """Drop a table.
         
-        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)
+        Parameters
+        ----------
+        name
+            Table name to drop
+        database
+            Database containing the table
+        force
+            If True, use IF EXISTS to avoid error if table doesn't exist
+        """
+        client = self._ensure_connected()
+        db = database or self._current_database
+        if not db:
+            raise CommitDBError("No database specified.")
+        
+        full_name = f"{db}.{name}"
+        if_exists = "IF EXISTS " if force else ""
+        client.execute(f"DROP TABLE {if_exists}{full_name}")
 
 
 def connect(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitdb
-Version: 2.2.0
+Version: 2.3.0
 Summary: Python driver for CommitDB SQL Server
 Author: CommitDB Contributors
 License: Apache-2.0
@@ -20,7 +20,7 @@ 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: ibis-framework>=11.0; extra == "ibis"
 Requires-Dist: pandas>=2.0; extra == "ibis"
 
 # CommitDB Python Driver
@@ -32,6 +32,8 @@ Python client for CommitDB - a Git-backed SQL database engine.
 
 **[📚 Full Documentation](https://nickyhof.github.io/CommitDB/python-driver/)**
 
+> ⚠️ **Experimental Project** - This is a hobby project and should not be used in any production environment.
+
 ## Installation
 
 ```bash

{commitdb-2.2.0 → commitdb-2.3.0}/commitdb.egg-info/requires.txt

@@ -3,5 +3,5 @@
 pytest>=7.0
 
 [ibis]
-ibis-framework>=9.0
+ibis-framework>=11.0
 pandas>=2.0

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

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

commitdb-2.3.0/tests/test_ibis.py

@@ -0,0 +1,152 @@
+"""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."""
+        from commitdb.client import CommitDBError
+        
+        # Setup: create database (ignore if exists)
+        try:
+            connection._client.execute("CREATE DATABASE ibis_test")
+        except CommitDBError:
+            pass  # Already exists
+        
+        connection._client.execute("DROP TABLE IF EXISTS ibis_test.users")
+        connection._client.execute(
+            "CREATE TABLE ibis_test.users (id INT PRIMARY KEY, name STRING, age INT)"
+        )
+        connection._client.execute(
+            "INSERT INTO ibis_test.users (id, name, age) VALUES (1, 'Alice', 30)"
+        )
+        connection._client.execute(
+            "INSERT INTO ibis_test.users (id, name, age) VALUES (2, 'Bob', 25)"
+        )
+        
+        try:
+            # Query using Ibis
+            table = connection.table("ibis_test.users")
+            result = table.execute()
+            
+            assert isinstance(result, pd.DataFrame)
+            assert len(result) == 2
+            assert "id" in result.columns
+            assert "name" in result.columns
+            assert "age" in result.columns
+        finally:
+            # Cleanup
+            connection._client.execute("DROP TABLE IF EXISTS ibis_test.users")
+            connection._client.execute("DROP DATABASE IF EXISTS ibis_test")
+    
+    def test_drop_table(self, connection):
+        """Test dropping a table via the backend."""
+        from commitdb.client import CommitDBError
+        
+        # Setup: create database (ignore if exists)
+        try:
+            connection._client.execute("CREATE DATABASE ibis_test")
+        except CommitDBError:
+            pass
+        
+        connection._client.execute("DROP TABLE IF EXISTS ibis_test.temp_table")
+        connection._client.execute(
+            "CREATE TABLE ibis_test.temp_table (id INT PRIMARY KEY)"
+        )
+        
+        try:
+            # Drop using the backend method
+            connection.drop_table("temp_table", database="ibis_test")
+            
+            # Verify table is gone
+            tables = connection.list_tables(database="ibis_test")
+            assert "temp_table" not in tables
+        finally:
+            # Cleanup
+            connection._client.execute("DROP TABLE IF EXISTS ibis_test.temp_table")
+            connection._client.execute("DROP DATABASE IF EXISTS ibis_test")
+    
+    def test_drop_table_force(self, connection):
+        """Test dropping a non-existent table with force=True."""
+        from commitdb.client import CommitDBError
+        
+        # Setup: create database (ignore if exists)
+        try:
+            connection._client.execute("CREATE DATABASE ibis_test")
+        except CommitDBError:
+            pass
+        
+        try:
+            # Should not raise an error with force=True
+            connection.drop_table("nonexistent_table", database="ibis_test", force=True)
+        finally:
+            connection._client.execute("DROP DATABASE IF EXISTS ibis_test")
+

commitdb-2.2.0/tests/test_ibis.py

@@ -1,88 +0,0 @@
-"""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)