cinchdb 0.1.0__py3-none-any.whl

cinchdb/cli/commands/column.py

@@ -0,0 +1,308 @@
+"""Column management commands for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.managers.column import ColumnManager
+from cinchdb.managers.change_applier import ChangeApplier
+from cinchdb.models import Column
+from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+
+app = typer.Typer(help="Column management 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(name="list")
+def list_columns(
+    ctx: typer.Context, table: Optional[str] = typer.Argument(None, help="Table name")
+):
+    """List all columns in a table."""
+    table = validate_required_arg(table, "table", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        columns = column_mgr.list_columns(table)
+
+        # Create a table
+        col_table = RichTable(title=f"Columns in '{table}'")
+        col_table.add_column("Name", style="cyan")
+        col_table.add_column("Type", style="green")
+        col_table.add_column("Nullable", style="yellow")
+        col_table.add_column("Primary Key", style="red")
+        col_table.add_column("Default", style="blue")
+
+        for col in columns:
+            nullable = "Yes" if col.nullable else "No"
+            pk = "Yes" if col.primary_key else "No"
+            default = col.default or "-"
+            col_table.add_row(col.name, col.type, nullable, pk, default)
+
+        console.print(col_table)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    table: Optional[str] = typer.Argument(None, help="Table name"),
+    name: Optional[str] = typer.Argument(None, help="Column name"),
+    type: Optional[str] = typer.Argument(
+        None, help="Column type (TEXT, INTEGER, REAL, BLOB, NUMERIC)"
+    ),
+    nullable: bool = typer.Option(
+        True, "--nullable/--not-null", help="Allow NULL values"
+    ),
+    default: Optional[str] = typer.Option(
+        None, "--default", "-d", help="Default value"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Add a new column to a table."""
+    table = validate_required_arg(table, "table", ctx)
+    name = validate_required_arg(name, "name", ctx)
+    type = validate_required_arg(type, "type", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    # Validate type
+    type = type.upper()
+    if type not in ["TEXT", "INTEGER", "REAL", "BLOB", "NUMERIC"]:
+        console.print(f"[red]❌ Invalid type: '{type}'[/red]")
+        console.print(
+            "[yellow]Valid types: TEXT, INTEGER, REAL, BLOB, NUMERIC[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        column = Column(name=name, type=type, nullable=nullable, default=default)
+        column_mgr.add_column(table, column)
+
+        console.print(f"[green]✅ Added column '{name}' to table '{table}'[/green]")
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def drop(
+    ctx: typer.Context,
+    table: Optional[str] = typer.Argument(None, help="Table name"),
+    name: Optional[str] = typer.Argument(None, help="Column name to drop"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force deletion without confirmation"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Drop a column from a table."""
+    table = validate_required_arg(table, "table", ctx)
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    # Confirmation
+    if not force:
+        confirm = typer.confirm(
+            f"Are you sure you want to drop column '{name}' from table '{table}'?"
+        )
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        column_mgr.drop_column(table, name)
+
+        console.print(f"[green]✅ Dropped column '{name}' from table '{table}'[/green]")
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def rename(
+    ctx: typer.Context,
+    table: Optional[str] = typer.Argument(None, help="Table name"),
+    old_name: Optional[str] = typer.Argument(None, help="Current column name"),
+    new_name: Optional[str] = typer.Argument(None, help="New column name"),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Rename a column in a table."""
+    table = validate_required_arg(table, "table", ctx)
+    old_name = validate_required_arg(old_name, "old_name", ctx)
+    new_name = validate_required_arg(new_name, "new_name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        column_mgr.rename_column(table, old_name, new_name)
+
+        console.print(
+            f"[green]✅ Renamed column '{old_name}' to '{new_name}' in table '{table}'[/green]"
+        )
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(
+    ctx: typer.Context,
+    table: Optional[str] = typer.Argument(None, help="Table name"),
+    name: Optional[str] = typer.Argument(None, help="Column name"),
+):
+    """Show detailed information about a column."""
+    table = validate_required_arg(table, "table", ctx)
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        column = column_mgr.get_column_info(table, name)
+
+        # Display info
+        console.print(f"\n[bold]Column: {column.name}[/bold]")
+        console.print(f"Table: {table}")
+        console.print(f"Type: {column.type}")
+        console.print(f"Nullable: {'Yes' if column.nullable else 'No'}")
+        console.print(f"Primary Key: {'Yes' if column.primary_key else 'No'}")
+        console.print(f"Unique: {'Yes' if column.unique else 'No'}")
+        console.print(f"Default: {column.default or 'None'}")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command(name="alter-nullable")
+def alter_nullable(
+    ctx: typer.Context,
+    table: Optional[str] = typer.Argument(None, help="Table name"),
+    column: Optional[str] = typer.Argument(None, help="Column name"),
+    nullable: bool = typer.Option(
+        None, "--nullable/--not-nullable", help="Make column nullable or NOT NULL"
+    ),
+    fill_value: Optional[str] = typer.Option(
+        None, "--fill-value", "-f", help="Value to use for NULL values when making NOT NULL"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Change the nullable constraint on a column."""
+    table = validate_required_arg(table, "table", ctx)
+    column = validate_required_arg(column, "column", ctx)
+    
+    # Validate nullable flag was provided
+    if nullable is None:
+        console.print(ctx.get_help())
+        console.print("\n[red]❌ Error: Must specify either --nullable or --not-nullable[/red]")
+        raise typer.Exit(1)
+    
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        column_mgr = ColumnManager(config.project_dir, db_name, branch_name, "main")
+        
+        # Check if column has NULLs when making NOT NULL
+        if not nullable and fill_value is None:
+            # Get column info to check current state
+            col_info = column_mgr.get_column_info(table, column)
+            if col_info.nullable:
+                # Check for NULL values
+                from cinchdb.core.connection import DatabaseConnection
+                from cinchdb.core.path_utils import get_tenant_db_path
+                
+                db_path = get_tenant_db_path(config.project_dir, db_name, branch_name, "main")
+                with DatabaseConnection(db_path) as conn:
+                    cursor = conn.execute(
+                        f"SELECT COUNT(*) FROM {table} WHERE {column} IS NULL"
+                    )
+                    null_count = cursor.fetchone()[0]
+                    
+                    if null_count > 0:
+                        console.print(f"[yellow]Column '{column}' has {null_count} NULL values.[/yellow]")
+                        fill_value = typer.prompt("Provide a fill value")
+        
+        # Convert fill_value to appropriate type
+        if fill_value is not None:
+            # Try to interpret the value
+            if fill_value.lower() == "null":
+                fill_value = None
+            elif fill_value.isdigit():
+                fill_value = int(fill_value)
+            elif fill_value.replace(".", "", 1).isdigit():
+                fill_value = float(fill_value)
+            # Otherwise keep as string
+        
+        column_mgr.alter_column_nullable(table, column, nullable, fill_value)
+        
+        if nullable:
+            console.print(f"[green]✅ Made column '{column}' nullable in table '{table}'[/green]")
+        else:
+            console.print(f"[green]✅ Made column '{column}' NOT NULL in table '{table}'[/green]")
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)

cinchdb/cli/commands/database.py

@@ -0,0 +1,212 @@
+"""Database management commands for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.core.path_utils import list_databases
+from cinchdb.cli.utils import (
+    get_config_with_data,
+    set_active_database,
+    set_active_branch,
+    validate_required_arg,
+)
+
+app = typer.Typer(help="Database management commands", invoke_without_command=True)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """Database management commands."""
+    if ctx.invoked_subcommand is None:
+        print(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@app.command(name="list")
+def list_dbs():
+    """List all databases in the project."""
+    config, config_data = get_config_with_data()
+    databases = list_databases(config.project_dir)
+
+    if not databases:
+        console.print("[yellow]No databases found[/yellow]")
+        return
+
+    # Create a table
+    table = RichTable(title="Databases")
+    table.add_column("Name", style="cyan")
+    table.add_column("Active", style="green")
+    table.add_column("Protected", style="yellow")
+
+    current_db = config_data.active_database
+
+    for db_name in databases:
+        is_active = "✓" if db_name == current_db else ""
+        is_protected = "✓" if db_name == "main" else ""
+        table.add_row(db_name, is_active, is_protected)
+
+    console.print(table)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the database to create"),
+    description: Optional[str] = typer.Option(
+        None, "--description", "-d", help="Database description"
+    ),
+    switch: bool = typer.Option(
+        False, "--switch", "-s", help="Switch to the new database after creation"
+    ),
+):
+    """Create a new database."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+
+    # Create database directory structure
+    db_path = config.project_dir / ".cinchdb" / "databases" / name
+    if db_path.exists():
+        console.print(f"[red]❌ Database '{name}' already exists[/red]")
+        raise typer.Exit(1)
+
+    # Create the database structure
+    db_path.mkdir(parents=True)
+    branches_dir = db_path / "branches"
+    branches_dir.mkdir()
+
+    # Create main branch
+    main_branch = branches_dir / "main"
+    main_branch.mkdir()
+
+    # Create main tenant
+    tenants_dir = main_branch / "tenants"
+    tenants_dir.mkdir()
+    main_tenant = tenants_dir / "main.db"
+    main_tenant.touch()
+
+    # Create branch metadata
+    import json
+    from datetime import datetime, timezone
+
+    metadata = {
+        "name": "main",
+        "parent": None,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }
+    with open(main_branch / "metadata.json", "w") as f:
+        json.dump(metadata, f, indent=2)
+
+    # Create empty changes file
+    with open(main_branch / "changes.json", "w") as f:
+        json.dump([], f)
+
+    console.print(f"[green]✅ Created database '{name}'[/green]")
+
+    if switch:
+        set_active_database(config, name)
+        console.print(f"[green]✅ Switched to database '{name}'[/green]")
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the database to delete"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force deletion without confirmation"
+    ),
+):
+    """Delete a database."""
+    name = validate_required_arg(name, "name", ctx)
+    if name == "main":
+        console.print("[red]❌ Cannot delete the main database[/red]")
+        raise typer.Exit(1)
+
+    config, config_data = get_config_with_data()
+    db_path = config.project_dir / ".cinchdb" / "databases" / name
+
+    if not db_path.exists():
+        console.print(f"[red]❌ Database '{name}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    # Confirmation
+    if not force:
+        confirm = typer.confirm(f"Are you sure you want to delete database '{name}'?")
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    # Delete the database
+    import shutil
+
+    shutil.rmtree(db_path)
+
+    # If this was the active database, switch to main
+    if config_data.active_database == name:
+        set_active_database(config, "main")
+        console.print("[yellow]Switched to main database[/yellow]")
+
+    console.print(f"[green]✅ Deleted database '{name}'[/green]")
+
+
+@app.command()
+def info(
+    name: Optional[str] = typer.Argument(None, help="Database name (default: current)"),
+):
+    """Show information about a database."""
+    config, config_data = get_config_with_data()
+    db_name = name or config_data.active_database
+
+    db_path = config.project_dir / ".cinchdb" / "databases" / db_name
+    if not db_path.exists():
+        console.print(f"[red]❌ Database '{db_name}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    # Count branches
+    branches_path = db_path / "branches"
+    branch_count = len(list(branches_path.iterdir())) if branches_path.exists() else 0
+
+    # Get active branch
+    active_branch = config_data.active_branch
+
+    # Display info
+    console.print(f"\n[bold]Database: {db_name}[/bold]")
+    console.print(f"Location: {db_path}")
+    console.print(f"Branches: {branch_count}")
+    console.print(f"Active Branch: {active_branch}")
+    console.print(f"Protected: {'Yes' if db_name == 'main' else 'No'}")
+
+    # List branches
+    if branch_count > 0:
+        console.print("\n[bold]Branches:[/bold]")
+        for branch_dir in sorted(branches_path.iterdir()):
+            if branch_dir.is_dir():
+                branch_name = branch_dir.name
+                is_active = " (active)" if branch_name == active_branch else ""
+                console.print(f"  - {branch_name}{is_active}")
+
+
+@app.command()
+def switch(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(
+        None, help="Name of the database to switch to"
+    ),
+):
+    """Switch to a different database."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+
+    # Check if database exists
+    db_path = config.project_dir / ".cinchdb" / "databases" / name
+    if not db_path.exists():
+        console.print(f"[red]❌ Database '{name}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    # Switch
+    set_active_database(config, name)
+    set_active_branch(config, "main")  # Always switch to main branch
+
+    console.print(f"[green]✅ Switched to database '{name}'[/green]")

cinchdb/cli/commands/query.py

@@ -0,0 +1,136 @@
+"""Query execution command for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.cli.utils import get_config_with_data, get_cinchdb_instance
+from cinchdb.managers.query import QueryManager
+
+app = typer.Typer(help="Execute SQL queries", invoke_without_command=True)
+console = Console()
+
+
+def execute_query(sql: str, tenant: str, format: str, limit: Optional[int], force_local: bool = False, remote_alias: Optional[str] = None):
+    """Execute a SQL query."""
+    # Add LIMIT if specified
+    query_sql = sql
+    if limit and "LIMIT" not in sql.upper():
+        query_sql = f"{sql} LIMIT {limit}"
+
+    # Get CinchDB instance (handles local/remote automatically)
+    db = get_cinchdb_instance(tenant=tenant, force_local=force_local, remote_alias=remote_alias)
+
+    try:
+        # Check if this is a SELECT query
+        is_select = query_sql.strip().upper().startswith("SELECT")
+
+        if is_select:
+            # Execute SELECT query
+            rows = db.query(query_sql)
+
+            if not rows:
+                console.print("[yellow]No results[/yellow]")
+                return
+
+            # Get column names from first row
+            columns = list(rows[0].keys()) if rows else []
+
+            if format == "json":
+                # JSON output - rows are already dicts
+                console.print_json(data=rows)
+
+            elif format == "csv":
+                # CSV output
+                import csv
+                import sys
+
+                writer = csv.writer(sys.stdout)
+                writer.writerow(columns)
+                for row in rows:
+                    writer.writerow([row[col] for col in columns])
+
+            else:
+                # Table output (default)
+                table = RichTable(title=f"Query Results ({len(rows)} rows)")
+
+                # Add columns
+                for col in columns:
+                    table.add_column(col, style="cyan")
+
+                # Add rows
+                for row in rows:
+                    # Convert all values to strings
+                    str_row = [
+                        str(row[col]) if row[col] is not None else "NULL"
+                        for col in columns
+                    ]
+                    table.add_row(*str_row)
+
+                console.print(table)
+        else:
+            # For INSERT/UPDATE/DELETE, we need to handle local vs remote differently
+            if db.is_local:
+                # For local connections, use the query manager directly
+                from cinchdb.managers.query import QueryManager
+                query_mgr = QueryManager(db.project_dir, db.database, db.branch, tenant)
+                affected_rows = query_mgr.execute_non_query(query_sql)
+                console.print(
+                    f"[green]✅ Query executed successfully[/green]\n"
+                    f"[cyan]Rows affected: {affected_rows}[/cyan]"
+                )
+            else:
+                # For remote connections, the API should handle all SQL types
+                # This might need API support - for now, try using query
+                try:
+                    result = db.query(query_sql)
+                    console.print(
+                        f"[green]✅ Query executed successfully[/green]"
+                    )
+                except Exception as e:
+                    # If remote doesn't support non-SELECT via query, show helpful message
+                    console.print(
+                        f"[red]❌ Remote execution of non-SELECT queries may require API support[/red]\n"
+                        f"[yellow]Error: {e}[/yellow]"
+                    )
+                    raise
+
+    except Exception as e:
+        console.print(f"[red]❌ Query error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    sql: Optional[str] = typer.Argument(None, help="SQL query to execute"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    format: Optional[str] = typer.Option(
+        "table", "--format", "-f", help="Output format (table, json, csv)"
+    ),
+    limit: Optional[int] = typer.Option(
+        None, "--limit", "-l", help="Limit number of rows"
+    ),
+    local: bool = typer.Option(
+        False, "--local", "-L", help="Force local connection"
+    ),
+    remote: Optional[str] = typer.Option(
+        None, "--remote", "-r", help="Use specific remote alias"
+    ),
+):
+    """Execute a SQL query.
+
+    Examples:
+        cinch query "SELECT * FROM users"
+        cinch query "SELECT * FROM users WHERE active = 1" --format json
+        cinch query "SELECT COUNT(*) FROM posts" --tenant tenant1
+        cinch query "SELECT * FROM users" --remote production
+        cinch query "SELECT * FROM users" --local
+    """
+    # If no subcommand is invoked and we have SQL, execute it
+    if ctx.invoked_subcommand is None:
+        if not sql:
+            console.print(ctx.get_help())
+            raise typer.Exit(0)
+        execute_query(sql, tenant, format, limit, force_local=local, remote_alias=remote)