cinchdb 0.1.0__py3-none-any.whl

cinchdb/managers/table.py

@@ -0,0 +1,383 @@
+"""Table management for CinchDB."""
+
+from pathlib import Path
+from typing import List
+
+from cinchdb.models import Table, Column, Change, ChangeType
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.core.maintenance import check_maintenance_mode
+from cinchdb.managers.change_tracker import ChangeTracker
+from cinchdb.managers.tenant import TenantManager
+
+
+class TableManager:
+    """Manages tables within a database."""
+
+    # Protected column names that users cannot use
+    PROTECTED_COLUMNS = {"id", "created_at", "updated_at"}
+
+    def __init__(
+        self, project_root: Path, database: str, branch: str, tenant: str = "main"
+    ):
+        """Initialize table manager.
+
+        Args:
+            project_root: Path to project root
+            database: Database name
+            branch: Branch name
+            tenant: Tenant name (default: main)
+        """
+        self.project_root = Path(project_root)
+        self.database = database
+        self.branch = branch
+        self.tenant = tenant
+        self.db_path = get_tenant_db_path(project_root, database, branch, tenant)
+        self.change_tracker = ChangeTracker(project_root, database, branch)
+        self.tenant_manager = TenantManager(project_root, database, branch)
+
+    def list_tables(self) -> List[Table]:
+        """List all tables in the tenant.
+
+        Returns:
+            List of Table objects
+        """
+        tables = []
+
+        with DatabaseConnection(self.db_path) as conn:
+            # Get all user tables (exclude sqlite internal tables)
+            cursor = conn.execute(
+                """
+                SELECT name FROM sqlite_master 
+                WHERE type='table' 
+                AND name NOT LIKE 'sqlite_%'
+                ORDER BY name
+                """
+            )
+
+            for row in cursor.fetchall():
+                table = self.get_table(row["name"])
+                tables.append(table)
+
+        return tables
+
+    def create_table(self, table_name: str, columns: List[Column]) -> Table:
+        """Create a new table with optional foreign key constraints.
+
+        Args:
+            table_name: Name of the table
+            columns: List of Column objects defining the schema
+
+        Returns:
+            Created Table object
+
+        Raises:
+            ValueError: If table already exists, uses protected column names,
+                       or has invalid foreign key references
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Validate table doesn't exist
+        if self._table_exists(table_name):
+            raise ValueError(f"Table '{table_name}' already exists")
+
+        # Check for protected column names
+        for column in columns:
+            if column.name in self.PROTECTED_COLUMNS:
+                raise ValueError(
+                    f"Column name '{column.name}' is protected and cannot be used"
+                )
+
+        # Validate foreign key references
+        foreign_key_constraints = []
+        for column in columns:
+            if column.foreign_key:
+                fk = column.foreign_key
+                
+                # Validate referenced table exists
+                if not self._table_exists(fk.table):
+                    raise ValueError(
+                        f"Foreign key reference to non-existent table: '{fk.table}'"
+                    )
+                
+                # Validate referenced column exists
+                ref_table = self.get_table(fk.table)
+                ref_col_names = [col.name for col in ref_table.columns]
+                if fk.column not in ref_col_names:
+                    raise ValueError(
+                        f"Foreign key reference to non-existent column: '{fk.table}.{fk.column}'"
+                    )
+                
+                # Build foreign key constraint
+                fk_constraint = f"FOREIGN KEY ({column.name}) REFERENCES {fk.table}({fk.column})"
+                if fk.on_delete != "RESTRICT":
+                    fk_constraint += f" ON DELETE {fk.on_delete}"
+                if fk.on_update != "RESTRICT":
+                    fk_constraint += f" ON UPDATE {fk.on_update}"
+                foreign_key_constraints.append(fk_constraint)
+
+        # Build automatic columns
+        auto_columns = [
+            Column(name="id", type="TEXT", primary_key=True, nullable=False),
+            Column(name="created_at", type="TEXT", nullable=False),
+            Column(name="updated_at", type="TEXT", nullable=True),
+        ]
+
+        # Combine all columns
+        all_columns = auto_columns + columns
+
+        # Build CREATE TABLE SQL
+        sql_parts = []
+        for col in all_columns:
+            col_def = f"{col.name} {col.type}"
+
+            if col.primary_key:
+                col_def += " PRIMARY KEY"
+            if not col.nullable:
+                col_def += " NOT NULL"
+            if col.default is not None:
+                col_def += f" DEFAULT {col.default}"
+            if col.unique and not col.primary_key:
+                col_def += " UNIQUE"
+
+            sql_parts.append(col_def)
+        
+        # Add foreign key constraints
+        sql_parts.extend(foreign_key_constraints)
+
+        create_sql = f"CREATE TABLE {table_name} ({', '.join(sql_parts)})"
+
+        # Track the change first (as unapplied)
+        change = Change(
+            type=ChangeType.CREATE_TABLE,
+            entity_type="table",
+            entity_name=table_name,
+            branch=self.branch,
+            details={"columns": [col.model_dump() for col in all_columns]},
+            sql=create_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+        # Return the created table
+        return Table(
+            name=table_name,
+            database=self.database,
+            branch=self.branch,
+            columns=all_columns,
+        )
+
+    def get_table(self, table_name: str) -> Table:
+        """Get table information.
+
+        Args:
+            table_name: Name of the table
+
+        Returns:
+            Table object with schema information
+
+        Raises:
+            ValueError: If table doesn't exist
+        """
+        if not self._table_exists(table_name):
+            raise ValueError(f"Table '{table_name}' does not exist")
+
+        columns = []
+        foreign_keys = {}
+
+        with DatabaseConnection(self.db_path) as conn:
+            # Get foreign key information first
+            fk_cursor = conn.execute(f"PRAGMA foreign_key_list({table_name})")
+            for fk_row in fk_cursor.fetchall():
+                from_col = fk_row["from"]
+                to_table = fk_row["table"]
+                to_col = fk_row["to"]
+                on_update = fk_row["on_update"]
+                on_delete = fk_row["on_delete"]
+                
+                # Create ForeignKeyRef
+                from cinchdb.models import ForeignKeyRef
+                foreign_keys[from_col] = ForeignKeyRef(
+                    table=to_table,
+                    column=to_col,
+                    on_update=on_update,
+                    on_delete=on_delete
+                )
+            
+            # Get column information
+            cursor = conn.execute(f"PRAGMA table_info({table_name})")
+
+            for row in cursor.fetchall():
+                # Map SQLite types
+                sqlite_type = row["type"].upper()
+                if "INT" in sqlite_type:
+                    col_type = "INTEGER"
+                elif (
+                    "REAL" in sqlite_type
+                    or "FLOAT" in sqlite_type
+                    or "DOUBLE" in sqlite_type
+                ):
+                    col_type = "REAL"
+                elif "BLOB" in sqlite_type:
+                    col_type = "BLOB"
+                elif "NUMERIC" in sqlite_type:
+                    col_type = "NUMERIC"
+                else:
+                    col_type = "TEXT"
+
+                # Check if this column has a foreign key
+                foreign_key = foreign_keys.get(row["name"])
+
+                column = Column(
+                    name=row["name"],
+                    type=col_type,
+                    nullable=(row["notnull"] == 0),
+                    default=row["dflt_value"],
+                    primary_key=(row["pk"] == 1),
+                    foreign_key=foreign_key
+                )
+                columns.append(column)
+
+        return Table(
+            name=table_name, database=self.database, branch=self.branch, columns=columns
+        )
+
+    def delete_table(self, table_name: str) -> None:
+        """Delete a table.
+
+        Args:
+            table_name: Name of the table to delete
+
+        Raises:
+            ValueError: If table doesn't exist
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        if not self._table_exists(table_name):
+            raise ValueError(f"Table '{table_name}' does not exist")
+
+        # Build DROP TABLE SQL
+        drop_sql = f"DROP TABLE {table_name}"
+
+        # Track the change
+        change = Change(
+            type=ChangeType.DROP_TABLE,
+            entity_type="table",
+            entity_name=table_name,
+            branch=self.branch,
+            sql=drop_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+    def copy_table(
+        self, source_table: str, target_table: str, copy_data: bool = True
+    ) -> Table:
+        """Copy a table to a new table.
+
+        Args:
+            source_table: Name of the source table
+            target_table: Name of the target table
+            copy_data: Whether to copy data (default: True)
+
+        Returns:
+            Created Table object
+
+        Raises:
+            ValueError: If source doesn't exist or target already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        if not self._table_exists(source_table):
+            raise ValueError(f"Source table '{source_table}' does not exist")
+
+        if self._table_exists(target_table):
+            raise ValueError(f"Target table '{target_table}' already exists")
+
+        # Get source table structure
+        source = self.get_table(source_table)
+
+        # Create SQL for new table
+        sql_parts = []
+        for col in source.columns:
+            col_def = f"{col.name} {col.type}"
+
+            if col.primary_key:
+                col_def += " PRIMARY KEY"
+            if not col.nullable:
+                col_def += " NOT NULL"
+            if col.default is not None:
+                col_def += f" DEFAULT {col.default}"
+
+            sql_parts.append(col_def)
+
+        create_sql = f"CREATE TABLE {target_table} ({', '.join(sql_parts)})"
+
+        # Build copy data SQL if requested
+        copy_sql = None
+        if copy_data:
+            col_names = [col.name for col in source.columns]
+            col_list = ", ".join(col_names)
+            copy_sql = f"INSERT INTO {target_table} ({col_list}) SELECT {col_list} FROM {source_table}"
+
+        # Track the change
+        change = Change(
+            type=ChangeType.CREATE_TABLE,
+            entity_type="table",
+            entity_name=target_table,
+            branch=self.branch,
+            details={
+                "columns": [col.model_dump() for col in source.columns],
+                "copied_from": source_table,
+                "with_data": copy_data,
+                "copy_sql": copy_sql,
+            },
+            sql=create_sql,
+        )
+        self.change_tracker.add_change(change)
+
+        # Apply to all tenants in the branch
+        from cinchdb.managers.change_applier import ChangeApplier
+
+        applier = ChangeApplier(self.project_root, self.database, self.branch)
+        applier.apply_change(change.id)
+
+        # Return the new table
+        return Table(
+            name=target_table,
+            database=self.database,
+            branch=self.branch,
+            columns=source.columns,
+        )
+
+    def _table_exists(self, table_name: str) -> bool:
+        """Check if a table exists.
+
+        Args:
+            table_name: Name of the table
+
+        Returns:
+            True if table exists
+        """
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                (table_name,),
+            )
+            return cursor.fetchone() is not None

cinchdb/managers/tenant.py

@@ -0,0 +1,258 @@
+"""Tenant management for CinchDB."""
+
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+from cinchdb.models import Tenant
+from cinchdb.core.path_utils import (
+    get_branch_path,
+    get_tenant_db_path,
+    list_tenants,
+)
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.maintenance import check_maintenance_mode
+
+
+class TenantManager:
+    """Manages tenants within a branch."""
+
+    def __init__(self, project_root: Path, database: str, branch: str):
+        """Initialize tenant manager.
+
+        Args:
+            project_root: Path to project root
+            database: Database name
+            branch: Branch name
+        """
+        self.project_root = Path(project_root)
+        self.database = database
+        self.branch = branch
+        self.branch_path = get_branch_path(self.project_root, database, branch)
+
+    def list_tenants(self) -> List[Tenant]:
+        """List all tenants in the branch.
+
+        Returns:
+            List of Tenant objects
+        """
+        tenant_names = list_tenants(self.project_root, self.database, self.branch)
+        tenants = []
+
+        for name in tenant_names:
+            tenant = Tenant(
+                name=name,
+                database=self.database,
+                branch=self.branch,
+                is_main=(name == "main"),
+            )
+            tenants.append(tenant)
+
+        return tenants
+
+    def create_tenant(
+        self, tenant_name: str, description: Optional[str] = None
+    ) -> Tenant:
+        """Create a new tenant by copying schema from main tenant.
+
+        Args:
+            tenant_name: Name for the new tenant
+            description: Optional description
+
+        Returns:
+            Created Tenant object
+
+        Raises:
+            ValueError: If tenant already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Validate tenant doesn't exist
+        if tenant_name in list_tenants(self.project_root, self.database, self.branch):
+            raise ValueError(f"Tenant '{tenant_name}' already exists")
+
+        # Get paths
+        main_db_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, "main"
+        )
+        new_db_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, tenant_name
+        )
+
+        # Copy main tenant database to new tenant
+        shutil.copy2(main_db_path, new_db_path)
+
+        # Clear any data from the copied database (keep schema only)
+        with DatabaseConnection(new_db_path) as conn:
+            # Get all tables
+            result = conn.execute("""
+                SELECT name FROM sqlite_master 
+                WHERE type='table' 
+                AND name NOT LIKE 'sqlite_%'
+            """)
+            tables = [row["name"] for row in result.fetchall()]
+
+            # Clear data from each table
+            for table in tables:
+                conn.execute(f"DELETE FROM {table}")
+
+            conn.commit()
+
+        return Tenant(
+            name=tenant_name,
+            database=self.database,
+            branch=self.branch,
+            description=description,
+            is_main=False,
+        )
+
+    def delete_tenant(self, tenant_name: str) -> None:
+        """Delete a tenant.
+
+        Args:
+            tenant_name: Name of tenant to delete
+
+        Raises:
+            ValueError: If tenant doesn't exist or is main tenant
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Can't delete main tenant
+        if tenant_name == "main":
+            raise ValueError("Cannot delete the main tenant")
+
+        # Validate tenant exists
+        if tenant_name not in list_tenants(
+            self.project_root, self.database, self.branch
+        ):
+            raise ValueError(f"Tenant '{tenant_name}' does not exist")
+
+        # Delete tenant database file and related files
+        db_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, tenant_name
+        )
+        db_path.unlink()
+
+        # Also remove WAL and SHM files if they exist
+        wal_path = db_path.with_suffix(".db-wal")
+        shm_path = db_path.with_suffix(".db-shm")
+
+        if wal_path.exists():
+            wal_path.unlink()
+        if shm_path.exists():
+            shm_path.unlink()
+
+    def copy_tenant(self, source_tenant: str, target_tenant: str) -> Tenant:
+        """Copy a tenant to a new tenant.
+
+        Args:
+            source_tenant: Name of tenant to copy from
+            target_tenant: Name for the new tenant
+
+        Returns:
+            Created Tenant object
+
+        Raises:
+            ValueError: If source doesn't exist or target already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        # Check maintenance mode
+        check_maintenance_mode(self.project_root, self.database, self.branch)
+
+        # Validate source exists
+        if source_tenant not in list_tenants(
+            self.project_root, self.database, self.branch
+        ):
+            raise ValueError(f"Source tenant '{source_tenant}' does not exist")
+
+        # Validate target doesn't exist
+        if target_tenant in list_tenants(self.project_root, self.database, self.branch):
+            raise ValueError(f"Tenant '{target_tenant}' already exists")
+
+        # Get paths
+        source_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, source_tenant
+        )
+        target_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, target_tenant
+        )
+
+        # Copy database file
+        shutil.copy2(source_path, target_path)
+
+        return Tenant(
+            name=target_tenant,
+            database=self.database,
+            branch=self.branch,
+            is_main=False,
+        )
+
+    def rename_tenant(self, old_name: str, new_name: str) -> None:
+        """Rename a tenant.
+
+        Args:
+            old_name: Current tenant name
+            new_name: New tenant name
+
+        Raises:
+            ValueError: If old doesn't exist, new already exists, or trying to rename main
+        """
+        # Can't rename main tenant
+        if old_name == "main":
+            raise ValueError("Cannot rename the main tenant")
+
+        # Validate old exists
+        if old_name not in list_tenants(self.project_root, self.database, self.branch):
+            raise ValueError(f"Tenant '{old_name}' does not exist")
+
+        # Validate new doesn't exist
+        if new_name in list_tenants(self.project_root, self.database, self.branch):
+            raise ValueError(f"Tenant '{new_name}' already exists")
+
+        # Get paths
+        old_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, old_name
+        )
+        new_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, new_name
+        )
+
+        # Rename database file
+        old_path.rename(new_path)
+
+        # Also rename WAL and SHM files if they exist
+        old_wal = old_path.with_suffix(".db-wal")
+        old_shm = old_path.with_suffix(".db-shm")
+        new_wal = new_path.with_suffix(".db-wal")
+        new_shm = new_path.with_suffix(".db-shm")
+
+        if old_wal.exists():
+            old_wal.rename(new_wal)
+        if old_shm.exists():
+            old_shm.rename(new_shm)
+
+    def get_tenant_connection(self, tenant_name: str) -> DatabaseConnection:
+        """Get a database connection for a tenant.
+
+        Args:
+            tenant_name: Tenant name
+
+        Returns:
+            DatabaseConnection object
+
+        Raises:
+            ValueError: If tenant doesn't exist
+        """
+        if tenant_name not in list_tenants(
+            self.project_root, self.database, self.branch
+        ):
+            raise ValueError(f"Tenant '{tenant_name}' does not exist")
+
+        db_path = get_tenant_db_path(
+            self.project_root, self.database, self.branch, tenant_name
+        )
+        return DatabaseConnection(db_path)