cinchdb 0.1.14__py3-none-any.whl → 0.1.17__py3-none-any.whl

cinchdb/__init__.py

@@ -1,6 +1,7 @@
 """CinchDB - A Git-like SQLite database management system."""
 
 from cinchdb.core.database import connect, connect_api
+from cinchdb.plugins.manager import PluginManager
 
 try:
     from importlib.metadata import version
@@ -13,4 +14,7 @@ except Exception:
     # Final fallback if package metadata is not available
     __version__ = "0.1.13"
 
-__all__ = ["connect", "connect_api"]
+# Global plugin manager
+plugin_manager = PluginManager()
+
+__all__ = ["connect", "connect_api", "plugin_manager"]

cinchdb/cli/commands/__init__.py

@@ -1,6 +1,6 @@
 """CLI command modules."""
 
-from . import database, branch, tenant, table, column, view, query, codegen, remote, index
+from . import database, branch, tenant, table, column, view, query, codegen, remote, index, data
 
 __all__ = [
     "database",
@@ -13,4 +13,5 @@ __all__ = [
     "codegen",
     "remote",
     "index",
+    "data",
 ]

cinchdb/cli/commands/data.py

@@ -0,0 +1,350 @@
+"""Data manipulation commands for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from rich.console import Console
+
+from cinchdb.cli.utils import get_config_with_data
+
+app = typer.Typer(help="Data manipulation commands", invoke_without_command=True)
+console = Console()
+
+
+@app.callback()
+def callback(ctx: typer.Context):
+    """Show help when no subcommand is provided."""
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@app.command()
+def delete(
+    table_name: str = typer.Argument(..., help="Name of table to delete from"),
+    where: str = typer.Option(..., "--where", "-w", help="Filter conditions (e.g., 'status=inactive' or 'age__gt=65' or 'id__in=1,2,3')"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    confirm: bool = typer.Option(False, "--confirm", "-y", help="Skip confirmation prompt"),
+):
+    """Delete records from a table based on filter criteria.
+    
+    Examples:
+        cinch data delete users --where "status=inactive" 
+        cinch data delete items --where "price__gt=100"
+        cinch data delete logs --where "id__in=1,2,3,4,5"
+    """
+    from cinchdb.core.database import CinchDB
+    
+    config, config_data = get_config_with_data()
+    
+    # Parse conditions into filter dict
+    try:
+        filters = _parse_conditions(where)
+    except ValueError as e:
+        console.print(f"[red]❌ Invalid conditions format: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not confirm:
+        console.print(f"[yellow]⚠️  About to delete records from table '{table_name}' where: {where}[/yellow]")
+        console.print(f"[yellow]   Tenant: {tenant}[/yellow]")
+        confirm_delete = typer.confirm("Are you sure you want to proceed?")
+        if not confirm_delete:
+            console.print("Operation cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        db = CinchDB(config_data.active_database, tenant=tenant, project_dir=config.project_dir)
+        
+        console.print(f"[yellow]🗑️  Deleting records from '{table_name}'...[/yellow]")
+        
+        deleted_count = db.delete_where(table_name, **filters)
+        
+        if deleted_count > 0:
+            console.print(f"[green]✅ Deleted {deleted_count} record(s) from '{table_name}'[/green]")
+        else:
+            console.print(f"[blue]ℹ️  No records matched the criteria in '{table_name}'[/blue]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def update(
+    table_name: str = typer.Argument(..., help="Name of table to update"),
+    set_data: str = typer.Option(..., "--set", "-s", help="Data to update (e.g., 'status=active,priority=high')"),
+    where: str = typer.Option(..., "--where", "-w", help="Filter conditions (e.g., 'status=inactive' or 'age__gt=65')"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    confirm: bool = typer.Option(False, "--confirm", "-y", help="Skip confirmation prompt"),
+):
+    """Update records in a table based on filter criteria.
+    
+    Examples:
+        cinch data update users --set "status=active" --where "status=inactive"
+        cinch data update items --set "price=99.99,category=sale" --where "price__gt=100"
+    """
+    from cinchdb.core.database import CinchDB
+    
+    config, config_data = get_config_with_data()
+    
+    # Parse conditions and data
+    try:
+        filters = _parse_conditions(where)
+        update_data = _parse_set_data(set_data)
+    except ValueError as e:
+        console.print(f"[red]❌ Invalid format: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not confirm:
+        console.print(f"[yellow]⚠️  About to update records in table '{table_name}'[/yellow]")
+        console.print(f"[yellow]   Set: {set_data}[/yellow]")
+        console.print(f"[yellow]   Where: {where}[/yellow]")
+        console.print(f"[yellow]   Tenant: {tenant}[/yellow]")
+        confirm_update = typer.confirm("Are you sure you want to proceed?")
+        if not confirm_update:
+            console.print("Operation cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        db = CinchDB(config_data.active_database, tenant=tenant, project_dir=config.project_dir)
+        
+        console.print(f"[yellow]📝 Updating records in '{table_name}'...[/yellow]")
+        
+        updated_count = db.update_where(table_name, update_data, **filters)
+        
+        if updated_count > 0:
+            console.print(f"[green]✅ Updated {updated_count} record(s) in '{table_name}'[/green]")
+        else:
+            console.print(f"[blue]ℹ️  No records matched the criteria in '{table_name}'[/blue]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def bulk_update(
+    table_name: str = typer.Argument(..., help="Name of table to update"),
+    data: str = typer.Option(..., "--data", "-d", help="JSON array of update objects with 'id' field"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    confirm: bool = typer.Option(False, "--confirm", "-y", help="Skip confirmation prompt"),
+):
+    """Update multiple records in a table using JSON data.
+    
+    Examples:
+        cinch data bulk-update users --data '[{"id":"123","name":"John"},{"id":"456","status":"active"}]'
+        cinch data bulk-update items --data '[{"id":"1","price":99.99},{"id":"2","category":"sale"}]'
+    """
+    import json
+    from cinchdb.core.database import CinchDB
+    
+    config, config_data = get_config_with_data()
+    
+    # Parse JSON data
+    try:
+        updates = json.loads(data)
+        if not isinstance(updates, list):
+            updates = [updates]
+    except json.JSONDecodeError as e:
+        console.print(f"[red]❌ Invalid JSON format: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not confirm:
+        console.print(f"[yellow]⚠️  About to update {len(updates)} record(s) in table '{table_name}'[/yellow]")
+        console.print(f"[yellow]   Tenant: {tenant}[/yellow]")
+        console.print(f"[yellow]   Data preview: {json.dumps(updates[:3], indent=2)}{'...' if len(updates) > 3 else ''}[/yellow]")
+        confirm_update = typer.confirm("Are you sure you want to proceed?")
+        if not confirm_update:
+            console.print("Operation cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        db = CinchDB(config_data.active_database, tenant=tenant, project_dir=config.project_dir)
+        
+        console.print(f"[yellow]📝 Updating {len(updates)} record(s) in '{table_name}'...[/yellow]")
+        
+        result = db.update(table_name, *updates)
+        updated_count = len(updates)
+        
+        console.print(f"[green]✅ Updated {updated_count} record(s) in '{table_name}'[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def bulk_delete(
+    table_name: str = typer.Argument(..., help="Name of table to delete from"),
+    ids: str = typer.Option(..., "--ids", "-i", help="Comma-separated list of IDs or JSON array"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    confirm: bool = typer.Option(False, "--confirm", "-y", help="Skip confirmation prompt"),
+):
+    """Delete multiple records from a table by IDs.
+    
+    Examples:
+        cinch data bulk-delete users --ids "123,456,789"
+        cinch data bulk-delete items --ids '["abc","def","ghi"]'
+    """
+    import json
+    from cinchdb.core.database import CinchDB
+    
+    config, config_data = get_config_with_data()
+    
+    # Parse IDs - try JSON first, then comma-separated
+    try:
+        id_list = json.loads(ids)
+        if not isinstance(id_list, list):
+            id_list = [str(id_list)]
+    except json.JSONDecodeError:
+        # Try comma-separated format
+        id_list = [id_str.strip() for id_str in ids.split(",") if id_str.strip()]
+
+    if not id_list:
+        console.print("[red]❌ No valid IDs provided[/red]")
+        raise typer.Exit(1)
+
+    if not confirm:
+        console.print(f"[yellow]⚠️  About to delete {len(id_list)} record(s) from table '{table_name}'[/yellow]")
+        console.print(f"[yellow]   Tenant: {tenant}[/yellow]")
+        console.print(f"[yellow]   IDs: {id_list[:5]}{'...' if len(id_list) > 5 else ''}[/yellow]")
+        confirm_delete = typer.confirm("Are you sure you want to proceed?")
+        if not confirm_delete:
+            console.print("Operation cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        db = CinchDB(config_data.active_database, tenant=tenant, project_dir=config.project_dir)
+        
+        console.print(f"[yellow]🗑️  Deleting {len(id_list)} record(s) from '{table_name}'...[/yellow]")
+        
+        deleted_count = db.delete(table_name, *id_list)
+        
+        console.print(f"[green]✅ Deleted {deleted_count} record(s) from '{table_name}'[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+def _parse_conditions(conditions_str: str) -> dict:
+    """Parse condition string into filter dictionary."""
+    filters = {}
+    
+    # Split by commas but handle quotes
+    parts = []
+    current_part = ""
+    in_quotes = False
+    
+    for char in conditions_str:
+        if char == '"' and not in_quotes:
+            in_quotes = True
+            current_part += char
+        elif char == '"' and in_quotes:
+            in_quotes = False
+            current_part += char
+        elif char == ',' and not in_quotes:
+            if current_part.strip():
+                parts.append(current_part.strip())
+            current_part = ""
+        else:
+            current_part += char
+    
+    if current_part.strip():
+        parts.append(current_part.strip())
+    
+    for part in parts:
+        if '=' not in part:
+            raise ValueError(f"Invalid condition format: '{part}'. Expected format: 'column=value' or 'column__operator=value'")
+        
+        key, value_str = part.split('=', 1)
+        key = key.strip()
+        value_str = value_str.strip()
+        
+        # Remove quotes if present
+        if value_str.startswith('"') and value_str.endswith('"'):
+            value_str = value_str[1:-1]
+        
+        # Handle special cases
+        if '__in' in key:
+            # Convert comma-separated values to list
+            value = [v.strip() for v in value_str.split(',')]
+            # Try to convert to numbers if possible
+            try:
+                value = [int(v) for v in value]
+            except ValueError:
+                try:
+                    value = [float(v) for v in value]
+                except ValueError:
+                    pass  # Keep as strings
+        else:
+            # Try to convert to appropriate type
+            value = _convert_value(value_str)
+        
+        filters[key] = value
+    
+    return filters
+
+
+def _parse_set_data(set_str: str) -> dict:
+    """Parse set string into update data dictionary."""
+    data = {}
+    
+    # Split by commas but handle quotes (similar to conditions)
+    parts = []
+    current_part = ""
+    in_quotes = False
+    
+    for char in set_str:
+        if char == '"' and not in_quotes:
+            in_quotes = True
+            current_part += char
+        elif char == '"' and in_quotes:
+            in_quotes = False
+            current_part += char
+        elif char == ',' and not in_quotes:
+            if current_part.strip():
+                parts.append(current_part.strip())
+            current_part = ""
+        else:
+            current_part += char
+    
+    if current_part.strip():
+        parts.append(current_part.strip())
+    
+    for part in parts:
+        if '=' not in part:
+            raise ValueError(f"Invalid set format: '{part}'. Expected format: 'column=value'")
+        
+        key, value_str = part.split('=', 1)
+        key = key.strip()
+        value_str = value_str.strip()
+        
+        # Remove quotes if present
+        if value_str.startswith('"') and value_str.endswith('"'):
+            value_str = value_str[1:-1]
+        
+        data[key] = _convert_value(value_str)
+    
+    return data
+
+
+def _convert_value(value_str: str):
+    """Convert string value to appropriate Python type."""
+    # Try integer
+    try:
+        return int(value_str)
+    except ValueError:
+        pass
+    
+    # Try float
+    try:
+        return float(value_str)
+    except ValueError:
+        pass
+    
+    # Try boolean
+    if value_str.lower() in ('true', 'false'):
+        return value_str.lower() == 'true'
+    
+    # Default to string
+    return value_str

cinchdb/cli/commands/index.py

@@ -169,11 +169,11 @@ def index_info(
         print(f"Partial: [blue]{'Yes' if info.get('partial') else 'No'}[/blue]")
         
         if info.get('sql'):
-            print(f"\nSQL Definition:")
+            print("\nSQL Definition:")
             print(f"[dim]{info['sql']}[/dim]")
             
         if info.get('columns_info'):
-            print(f"\nColumn Details:")
+            print("\nColumn Details:")
             for col in info['columns_info']:
                 print(f"  - Position {col['position']}: {col['column_name']}")
                 

cinchdb/cli/commands/tenant.py

@@ -188,3 +188,50 @@ def rename(
     except ValueError as e:
         console.print(f"[red]❌ {e}[/red]")
         raise typer.Exit(1)
+
+
+@app.command()
+def vacuum(
+    tenant_name: str = typer.Argument(..., help="Name of tenant to vacuum"),
+):
+    """Run VACUUM operation on a tenant to optimize storage and performance.
+    
+    VACUUM reclaims space from deleted records, defragments the database file,
+    and can improve query performance. This is especially useful after
+    deleting large amounts of data.
+    
+    Examples:
+        cinch tenant vacuum main
+        cinch tenant vacuum store_east
+    """
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+        
+        console.print(f"[yellow]🔧 Starting VACUUM operation on tenant '{tenant_name}'...[/yellow]")
+        
+        result = tenant_mgr.vacuum_tenant(tenant_name)
+        
+        if result['success']:
+            console.print("[green]✅ VACUUM completed successfully[/green]")
+            console.print(f"  Tenant: {result['tenant']}")
+            console.print(f"  Size before: {result['size_before']:,} bytes ({result['size_before'] / (1024*1024):.2f} MB)")
+            console.print(f"  Size after: {result['size_after']:,} bytes ({result['size_after'] / (1024*1024):.2f} MB)")
+            console.print(f"  Space reclaimed: {result['space_reclaimed']:,} bytes ({result['space_reclaimed_mb']} MB)")
+            console.print(f"  Duration: {result['duration_seconds']} seconds")
+            
+            if result['space_reclaimed'] > 0:
+                percent_saved = (result['space_reclaimed'] / result['size_before']) * 100
+                console.print(f"  [green]💾 Saved {percent_saved:.1f}% of space[/green]")
+            else:
+                console.print("  [blue]ℹ️  No space to reclaim (database was already optimized)[/blue]")
+        else:
+            console.print(f"[red]❌ VACUUM failed: {result.get('error', 'Unknown error')}[/red]")
+            raise typer.Exit(1)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)

cinchdb/cli/main.py

@@ -15,10 +15,11 @@ from cinchdb.cli.commands import (
     codegen,
     index,
 )
+from cinchdb.cli.commands.data import app as data_app
 
 app = typer.Typer(
     name="cinch",
-    help="CinchDB - A Git-like SQLite database management system\n\nENCRYPTION: Set CINCH_ENCRYPT_DATA=true to enable tenant database encryption.",
+    help="CinchDB - A Git-like SQLite database management system",
     add_completion=False,
     invoke_without_command=True,
 )
@@ -28,11 +29,6 @@ app = typer.Typer(
 def main(ctx: typer.Context):
     """
     CinchDB - A Git-like SQLite database management system
-    
-    ENCRYPTION:
-      Set CINCH_ENCRYPT_DATA=true to enable tenant database encryption.
-      Set CINCH_ENCRYPTION_KEY=your-key to provide encryption key.
-      Requires SQLite3MultipleCiphers for encryption support.
     """
     if ctx.invoked_subcommand is None:
         # No subcommand was invoked, show help
@@ -48,6 +44,7 @@ app.add_typer(table.app, name="table", help="Table management commands")
 app.add_typer(column.app, name="column", help="Column management commands")
 app.add_typer(view.app, name="view", help="View management commands")
 app.add_typer(index.app, name="index", help="Index management commands")
+app.add_typer(data_app, name="data", help="Data manipulation commands")
 app.add_typer(codegen.app, name="codegen", help="Code generation commands")
 
 

cinchdb/config.py

@@ -134,17 +134,8 @@ class Config:
         with open(self.config_path, "w") as f:
             toml.dump(config_dict, f)
 
-    def init_project(self) -> ProjectConfig:
-        """Initialize a new CinchDB project with default configuration.
-
-        This method now delegates to the ProjectInitializer for the actual
-        initialization logic.
-        """
-        from cinchdb.core.initializer import ProjectInitializer
-
-        initializer = ProjectInitializer(self.project_dir)
-        config = initializer.init_project()
+    @property
+    def base_dir(self) -> Path:
+        """Get the base project directory."""
+        return self.project_dir
 
-        # Load the config into this instance
-        self._config = config
-        return config

cinchdb/core/connection.py

@@ -1,12 +1,12 @@
 """SQLite connection management for CinchDB."""
 
+import os
 import sqlite3
 from pathlib import Path
-from typing import Optional, Dict, List
+from typing import Optional, Dict, List, Any
 from contextlib import contextmanager
 from datetime import datetime
 
-from cinchdb.security.encryption import encryption
 
 
 # Custom datetime adapter and converter for SQLite
@@ -44,23 +44,19 @@ class DatabaseConnection:
         # Ensure directory exists
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Use encryption if enabled, otherwise standard connection
-        if encryption.enabled:
-            self._conn = encryption.get_connection(self.path)
-        else:
-            # Connect with row factory for dict-like access
-            # detect_types=PARSE_DECLTYPES tells SQLite to use our registered converters
-            self._conn = sqlite3.connect(
-                str(self.path),
-                detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
-            )
-            
-            # Configure WAL mode and settings (encryption module handles this if enabled)
-            self._conn.execute("PRAGMA journal_mode = WAL")
-            self._conn.execute("PRAGMA synchronous = NORMAL")
-            self._conn.execute("PRAGMA wal_autocheckpoint = 0")
+        # Connect with row factory for dict-like access
+        # detect_types=PARSE_DECLTYPES tells SQLite to use our registered converters
+        self._conn = sqlite3.connect(
+            str(self.path),
+            detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
+        )
         
-        # Always set row factory and foreign keys
+        # Configure WAL mode and settings
+        self._conn.execute("PRAGMA journal_mode = WAL")
+        self._conn.execute("PRAGMA synchronous = NORMAL")
+        self._conn.execute("PRAGMA wal_autocheckpoint = 0")
+        
+        # Set row factory and foreign keys
         self._conn.row_factory = sqlite3.Row
         self._conn.execute("PRAGMA foreign_keys = ON")
         self._conn.commit()