cinchdb 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

cinchdb/core/database.py

@@ -464,38 +464,189 @@ class CinchDB:
                 )
                 return result
 
-    def update(self, table: str, id: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Update a record in a table.
+    def update(self, table: str, *updates: Dict[str, Any]) -> Dict[str, Any] | List[Dict[str, Any]]:
+        """Update one or more records in a table.
 
         Args:
             table: Table name
-            id: Record ID
-            data: Updated data as dictionary
+            *updates: One or more update dictionaries, each must contain 'id' field
 
         Returns:
-            Updated record
+            Single record dict if one record updated, list of dicts if multiple
+
+        Examples:
+            # Single update
+            db.update("users", {"id": "123", "name": "John Updated", "status": "active"})
+            
+            # Multiple updates using star expansion
+            db.update("users", 
+                {"id": "123", "name": "John Updated", "status": "active"},
+                {"id": "456", "name": "Jane Updated", "email": "jane.new@example.com"},
+                {"id": "789", "status": "inactive"}
+            )
+            
+            # Or with a list using star expansion
+            user_updates = [
+                {"id": "abc", "name": "Alice Updated"},
+                {"id": "def", "status": "premium"}
+            ]
+            db.update("users", *user_updates)
         """
+        if not updates:
+            raise ValueError("At least one update record must be provided")
+            
+        # Validate that all updates have an 'id' field
+        for i, update_data in enumerate(updates):
+            if 'id' not in update_data:
+                raise ValueError(f"Update record {i} missing required 'id' field")
+            
         if self.is_local:
-            return self.data.update(table, id, data)
+            # Single record
+            if len(updates) == 1:
+                update_data = updates[0].copy()
+                record_id = update_data.pop('id')
+                return self.data.update_by_id(table, record_id, update_data)
+            
+            # Multiple records - batch update
+            results = []
+            for update_data in updates:
+                update_copy = update_data.copy()
+                record_id = update_copy.pop('id')
+                result = self.data.update_by_id(table, record_id, update_copy)
+                results.append(result)
+            return results
         else:
-            # Remote update - use new data CRUD endpoint
-            result = self._make_request(
-                "PUT", f"/tables/{table}/data/{id}", json={"data": data}
-            )
-            return result
+            # Remote update
+            if len(updates) == 1:
+                # Single record - use existing endpoint
+                update_data = updates[0].copy()
+                record_id = update_data.pop('id')
+                result = self._make_request(
+                    "PUT", f"/tables/{table}/data/{record_id}", json={"data": update_data}
+                )
+                return result
+            else:
+                # Multiple records - use bulk endpoint
+                result = self._make_request(
+                    "PUT", f"/tables/{table}/data/bulk", json={"updates": list(updates)}
+                )
+                return result
 
-    def delete(self, table: str, id: str) -> None:
-        """Delete a record from a table.
+    def delete(self, table: str, *ids: str) -> int:
+        """Delete one or more records from a table.
 
         Args:
             table: Table name
-            id: Record ID
+            *ids: One or more record IDs
+
+        Returns:
+            Number of records deleted
+
+        Examples:
+            # Single delete
+            db.delete("users", "123")
+            
+            # Multiple deletes
+            db.delete("users", "123", "456", "789")
+            
+            # Or with a list using star expansion
+            user_ids = ["abc", "def", "ghi"]
+            db.delete("users", *user_ids)
         """
+        if not ids:
+            raise ValueError("At least one ID must be provided")
+            
         if self.is_local:
-            self.data.delete(table, id)
+            # Single record
+            if len(ids) == 1:
+                success = self.data.delete_by_id(table, ids[0])
+                return 1 if success else 0
+            
+            # Multiple records - batch delete
+            deleted_count = 0
+            for record_id in ids:
+                success = self.data.delete_by_id(table, record_id)
+                if success:
+                    deleted_count += 1
+            return deleted_count
         else:
             # Remote delete
-            self._make_request("DELETE", f"/tables/{table}/data/{id}")
+            if len(ids) == 1:
+                # Single record - use existing endpoint
+                self._make_request("DELETE", f"/tables/{table}/data/{ids[0]}")
+                return 1
+            else:
+                # Multiple records - use bulk endpoint
+                result = self._make_request(
+                    "DELETE", f"/tables/{table}/data/bulk", json={"ids": list(ids)}
+                )
+                return result.get("deleted_count", len(ids))
+
+    def delete_where(self, table: str, operator: str = "AND", **filters) -> int:
+        """Delete records from a table based on filter criteria.
+        
+        Args:
+            table: Table name
+            operator: Logical operator to combine conditions - "AND" (default) or "OR"
+            **filters: Filter criteria (supports operators like __gt, __lt, __in, __like, __not)
+                      Multiple conditions are combined with the specified operator
+            
+        Returns:
+            Number of records deleted
+            
+        Examples:
+            # Delete records where status = 'inactive' (single condition)
+            count = db.delete_where('users', status='inactive')
+            
+            # Delete records where status = 'inactive' AND age > 65 (default AND)
+            count = db.delete_where('users', status='inactive', age__gt=65)
+            
+            # Delete records where status = 'inactive' OR age > 65
+            count = db.delete_where('users', operator='OR', status='inactive', age__gt=65)
+            
+            # Delete records where item_id in [1, 2, 3]
+            count = db.delete_where('items', item_id__in=[1, 2, 3])
+        """
+        if self.is_local:
+            return self.data.delete_where(table, operator=operator, **filters)
+        else:
+            raise NotImplementedError("Remote bulk delete not implemented")
+
+    def update_where(self, table: str, data: Dict[str, Any], operator: str = "AND", **filters) -> int:
+        """Update records in a table based on filter criteria.
+        
+        Args:
+            table: Table name
+            data: Dictionary of column-value pairs to update
+            operator: Logical operator to combine conditions - "AND" (default) or "OR"
+            **filters: Filter criteria (supports operators like __gt, __lt, __in, __like, __not)
+                      Multiple conditions are combined with the specified operator
+            
+        Returns:
+            Number of records updated
+            
+        Examples:
+            # Update status for all users with age > 65 (single condition)
+            count = db.update_where('users', {'status': 'senior'}, age__gt=65)
+            
+            # Update status where age > 65 AND status = 'active' (default AND)
+            count = db.update_where('users', {'status': 'senior'}, age__gt=65, status='active')
+            
+            # Update status where age > 65 OR status = 'pending' 
+            count = db.update_where('users', {'status': 'senior'}, operator='OR', age__gt=65, status='pending')
+            
+            # Update multiple fields where item_id in specific list
+            count = db.update_where(
+                'items', 
+                {'status': 'inactive', 'updated_at': datetime.now()},
+                item_id__in=[1, 2, 3]
+            )
+        """
+        if self.is_local:
+            return self.data.update_where(table, data, operator=operator, **filters)
+        else:
+            raise NotImplementedError("Remote bulk update not implemented")
+
 
     def create_index(
         self,
@@ -581,31 +732,6 @@ class CinchDB:
                 changes.append(Change(**data))
             return changes
 
-    def optimize_tenant(self, tenant_name: str = None, force: bool = False) -> bool:
-        """Optimize a tenant's storage with VACUUM and page size adjustment.
-
-        Args:
-            tenant_name: Name of the tenant to optimize (default: current tenant)
-            force: If True, always perform optimization
-
-        Returns:
-            True if optimization was performed, False otherwise
-            
-        Examples:
-            # Optimize current tenant
-            db.optimize_tenant()
-            
-            # Optimize specific tenant
-            db.optimize_tenant("store_west")
-            
-            # Force optimization even if not needed
-            db.optimize_tenant(force=True)
-        """
-        if self.is_local:
-            tenant_to_optimize = tenant_name or self.tenant
-            return self.tenants.optimize_tenant_storage(tenant_to_optimize, force=force)
-        else:
-            raise NotImplementedError("Remote tenant optimization not implemented")
 
     def get_tenant_size(self, tenant_name: str = None) -> dict:
         """Get storage size information for a tenant.
@@ -639,6 +765,46 @@ class CinchDB:
         else:
             raise NotImplementedError("Remote tenant size query not implemented")
     
+    def vacuum_tenant(self, tenant_name: str = None) -> dict:
+        """Run VACUUM operation on a specific tenant to optimize storage and performance.
+        
+        VACUUM reclaims space from deleted records, defragments the database file,
+        and can improve query performance by rebuilding internal structures.
+        
+        Args:
+            tenant_name: Name of tenant to vacuum (default: current tenant)
+            
+        Returns:
+            Dictionary with vacuum results:
+            - success: Whether vacuum completed successfully
+            - tenant: Name of the tenant
+            - size_before: Size in bytes before vacuum
+            - size_after: Size in bytes after vacuum
+            - space_reclaimed: Bytes reclaimed by vacuum
+            - space_reclaimed_mb: MB reclaimed (rounded to 2 decimals)
+            - duration_seconds: Time taken for vacuum operation
+            - error: Error message if vacuum failed
+            
+        Raises:
+            ValueError: If tenant doesn't exist or is not materialized
+            NotImplementedError: If called on remote database
+            
+        Examples:
+            # Vacuum current tenant
+            result = db.vacuum_tenant()
+            if result['success']:
+                print(f"Reclaimed {result['space_reclaimed_mb']:.2f} MB")
+            
+            # Vacuum specific tenant
+            result = db.vacuum_tenant("store_east")
+            print(f"Vacuum took {result['duration_seconds']} seconds")
+        """
+        if self.is_local:
+            tenant_to_vacuum = tenant_name or self.tenant
+            return self.tenants.vacuum_tenant(tenant_to_vacuum)
+        else:
+            raise NotImplementedError("Remote tenant vacuum not implemented")
+    
     def get_storage_info(self) -> dict:
         """Get storage size information for all tenants in current branch.
         
@@ -667,35 +833,6 @@ class CinchDB:
         else:
             raise NotImplementedError("Remote storage info not implemented")
     
-    def optimize_all_tenants(self, force: bool = False) -> dict:
-        """Optimize storage for all tenants in current branch.
-
-        This is designed to be called periodically to:
-        - Reclaim unused space with VACUUM
-        - Adjust page sizes as databases grow
-        - Keep small databases compact
-
-        Args:
-            force: If True, optimize all tenants regardless of size
-
-        Returns:
-            Dictionary with optimization results:
-            - optimized: List of tenant names that were optimized
-            - skipped: List of tenant names that were skipped
-            - errors: List of tuples (tenant_name, error_message)
-            
-        Examples:
-            # Run periodic optimization
-            results = db.optimize_all_tenants()
-            print(f"Optimized {len(results['optimized'])} tenants")
-            
-            # Force optimization of all tenants
-            results = db.optimize_all_tenants(force=True)
-        """
-        if self.is_local:
-            return self.tenants.optimize_all_tenants(force=force)
-        else:
-            raise NotImplementedError("Remote tenant optimization not implemented")
 
     def close(self):
         """Close any open connections."""

cinchdb/core/path_utils.py

@@ -1,7 +1,7 @@
 """Path utilities for CinchDB."""
 
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
 
 def get_project_root(start_path: Path) -> Path:

cinchdb/infrastructure/metadata_connection_pool.py

@@ -3,7 +3,6 @@
 import threading
 from pathlib import Path
 from typing import Optional, Dict
-from weakref import WeakValueDictionary
 
 from cinchdb.infrastructure.metadata_db import MetadataDB
 

cinchdb/infrastructure/metadata_db.py

@@ -4,7 +4,6 @@ import sqlite3
 import uuid
 from pathlib import Path
 from typing import Optional, List, Dict, Any
-from datetime import datetime
 import json
 
 
@@ -117,6 +116,21 @@ class MetadataDB:
                 CREATE INDEX IF NOT EXISTS idx_tenants_shard 
                 ON tenants(shard)
             """)
+            
+            # Add cdc_enabled field to branches table for plugin use
+            # Note: This field is managed by plugins (like bdhcnic), not core CinchDB
+            try:
+                self.conn.execute("""
+                    ALTER TABLE branches ADD COLUMN cdc_enabled BOOLEAN DEFAULT FALSE
+                """)
+            except sqlite3.OperationalError:
+                # Column already exists
+                pass
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_branches_cdc_enabled 
+                ON branches(cdc_enabled)
+            """)
     
     # Database operations
     def create_database(self, database_id: str, name: str, 

cinchdb/managers/branch.py

@@ -4,7 +4,7 @@ import json
 import shutil
 import uuid
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any
 from datetime import datetime, timezone
 
 from cinchdb.models import Branch

cinchdb/managers/data.py

@@ -283,8 +283,8 @@ class DataManager:
                 conn.rollback()
                 raise
 
-    def delete_by_id(self, model_class: Type[T], record_id: str) -> bool:
-        """Delete a single record by ID.
+    def delete_model_by_id(self, model_class: Type[T], record_id: str) -> bool:
+        """Delete a single record by ID using model class.
 
         Args:
             model_class: Pydantic model class representing the table
@@ -420,12 +420,13 @@ class DataManager:
         return snake_case
 
     def _build_where_clause(
-        self, filters: Dict[str, Any]
+        self, filters: Dict[str, Any], operator: str = "AND"
     ) -> tuple[str, Dict[str, Any]]:
         """Build WHERE clause and parameters from filters.
 
         Args:
             filters: Dictionary of column filters
+            operator: Logical operator to combine conditions - "AND" (default) or "OR"
 
         Returns:
             Tuple of (where_clause, parameters)
@@ -433,31 +434,34 @@ class DataManager:
         if not filters:
             return "", {}
 
+        if operator not in ("AND", "OR"):
+            raise ValueError(f"Operator must be 'AND' or 'OR', got: {operator}")
+
         conditions = []
         params = {}
 
         for key, value in filters.items():
             # Handle special operators (column__operator format)
             if "__" in key:
-                column, operator = key.split("__", 1)
-                param_key = f"{column}_{operator}"
+                column, op = key.split("__", 1)
+                param_key = f"{column}_{op}"
 
-                if operator == "gte":
+                if op == "gte":
                     conditions.append(f"{column} >= :{param_key}")
                     params[param_key] = value
-                elif operator == "lte":
+                elif op == "lte":
                     conditions.append(f"{column} <= :{param_key}")
                     params[param_key] = value
-                elif operator == "gt":
+                elif op == "gt":
                     conditions.append(f"{column} > :{param_key}")
                     params[param_key] = value
-                elif operator == "lt":
+                elif op == "lt":
                     conditions.append(f"{column} < :{param_key}")
                     params[param_key] = value
-                elif operator == "like":
+                elif op == "like":
                     conditions.append(f"{column} LIKE :{param_key}")
                     params[param_key] = value
-                elif operator == "in":
+                elif op == "in":
                     if not isinstance(value, (list, tuple)):
                         raise ValueError(
                             f"'in' operator requires list or tuple, got {type(value)}"
@@ -467,10 +471,182 @@ class DataManager:
                     for i, v in enumerate(value):
                         params[f"{param_key}_{i}"] = v
                 else:
-                    raise ValueError(f"Unsupported operator: {operator}")
+                    raise ValueError(f"Unsupported operator: {op}")
             else:
                 # Exact match
                 conditions.append(f"{key} = :{key}")
                 params[key] = value
 
-        return " AND ".join(conditions), params
+        return f" {operator} ".join(conditions), params
+
+    def delete_where(self, table: str, operator: str = "AND", **filters) -> int:
+        """Delete records from a table based on filter criteria.
+        
+        Args:
+            table: Table name
+            operator: Logical operator to combine conditions - "AND" (default) or "OR"
+            **filters: Filter criteria (supports operators like __gt, __lt, __in, __like, __not)
+                      Multiple conditions are combined with the specified operator
+            
+        Returns:
+            Number of records deleted
+            
+        Examples:
+            # Delete records where status = 'inactive'
+            count = dm.delete_where('users', status='inactive')
+            
+            # Delete records where status = 'inactive' AND age > 65 (default AND)
+            count = dm.delete_where('users', status='inactive', age__gt=65)
+            
+            # Delete records where status = 'inactive' OR age > 65
+            count = dm.delete_where('users', operator='OR', status='inactive', age__gt=65)
+            
+            # Delete records where age > 65
+            count = dm.delete_where('users', age__gt=65)
+            
+            # Delete records where id in [1, 2, 3]
+            count = dm.delete_where('users', id__in=[1, 2, 3])
+            
+            # Delete records where name like 'test%'
+            count = dm.delete_where('users', name__like='test%')
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+        
+        if not filters:
+            raise ValueError("delete_where requires at least one filter condition")
+        
+        # Build WHERE clause
+        where_clause, params = self._build_where_clause(filters, operator)
+        
+        sql = f"DELETE FROM {table} WHERE {where_clause}"
+        
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, params)
+            conn.commit()
+            return cursor.rowcount
+
+    def update_where(self, table: str, data: Dict[str, Any], operator: str = "AND", **filters) -> int:
+        """Update records in a table based on filter criteria.
+        
+        Args:
+            table: Table name
+            data: Dictionary of column-value pairs to update
+            operator: Logical operator to combine conditions - "AND" (default) or "OR"
+            **filters: Filter criteria (supports operators like __gt, __lt, __in, __like, __not)
+                      Multiple conditions are combined with the specified operator
+            
+        Returns:
+            Number of records updated
+            
+        Examples:
+            # Update status for all users with age > 65
+            count = dm.update_where('users', {'status': 'senior'}, age__gt=65)
+            
+            # Update status where age > 65 AND status = 'active' (default AND)
+            count = dm.update_where('users', {'status': 'senior'}, age__gt=65, status='active')
+            
+            # Update status where age > 65 OR status = 'pending'
+            count = dm.update_where('users', {'status': 'senior'}, operator='OR', age__gt=65, status='pending')
+            
+            # Update multiple fields where id in specific list
+            count = dm.update_where(
+                'users', 
+                {'status': 'inactive', 'updated_at': datetime.now()},
+                id__in=[1, 2, 3]
+            )
+            
+            # Update where name like pattern
+            count = dm.update_where('users', {'category': 'test'}, name__like='test%')
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+        
+        if not filters:
+            raise ValueError("update_where requires at least one filter condition")
+            
+        if not data:
+            raise ValueError("update_where requires data to update")
+        
+        # Build WHERE clause
+        where_clause, where_params = self._build_where_clause(filters, operator)
+        
+        # Build SET clause
+        set_clauses = []
+        update_params = {}
+        
+        for key, value in data.items():
+            param_key = f"update_{key}"
+            set_clauses.append(f"{key} = :{param_key}")
+            update_params[param_key] = value
+        
+        # Combine parameters (update params first to avoid conflicts)
+        all_params = {**update_params, **where_params}
+        
+        sql = f"UPDATE {table} SET {', '.join(set_clauses)} WHERE {where_clause}"
+        
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, all_params)
+            conn.commit()
+            return cursor.rowcount
+
+    def update_by_id(self, table: str, record_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update a single record by ID.
+        
+        Args:
+            table: Table name
+            record_id: Record ID to update
+            data: Dictionary of column-value pairs to update
+            
+        Returns:
+            Updated record
+        """
+        # Build SET clause
+        set_parts = []
+        params = []
+        
+        for key, value in data.items():
+            set_parts.append(f"{key} = ?")
+            params.append(value)
+        
+        if not set_parts:
+            raise ValueError("No data provided for update")
+        
+        set_clause = ", ".join(set_parts)
+        sql = f"UPDATE {table} SET {set_clause} WHERE id = ?"
+        params.append(record_id)
+        
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, params)
+            conn.commit()
+            
+            if cursor.rowcount == 0:
+                raise ValueError(f"No record found with id: {record_id}")
+            
+            # Return the updated record
+            result = conn.execute(f"SELECT * FROM {table} WHERE id = ?", [record_id])
+            row = result.fetchone()
+            if row:
+                return dict(row)
+            else:
+                raise ValueError(f"Record not found after update: {record_id}")
+    
+    def delete_by_id(self, table: str, record_id: str) -> bool:
+        """Delete a single record by ID using table name.
+        
+        This method is used by the high-level database API.
+        
+        Args:
+            table: Table name
+            record_id: Record ID to delete
+            
+        Returns:
+            True if record was deleted, False if not found
+        """
+        sql = f"DELETE FROM {table} WHERE id = ?"
+        
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, [record_id])
+            conn.commit()
+            return cursor.rowcount > 0
+

cinchdb/managers/index.py

@@ -3,7 +3,6 @@
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 import sqlite3
-import json
 from datetime import datetime, timezone
 import uuid
 
@@ -263,7 +262,7 @@ class IndexManager:
             
             # Get index statistics
             xinfo_result = conn.execute(f"PRAGMA index_xinfo({index_name})")
-            extended_info = xinfo_result.fetchall()
+            xinfo_result.fetchall()
             
             return {
                 "name": index_name,

cinchdb/managers/query.py

@@ -6,7 +6,6 @@ from typing import List, Dict, Any, Optional, Type, TypeVar, Union
 from pydantic import BaseModel, ValidationError
 
 from cinchdb.core.connection import DatabaseConnection
-from cinchdb.core.path_utils import get_tenant_db_path
 from cinchdb.utils import validate_query_safe
 from cinchdb.managers.tenant import TenantManager