cinchdb 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

cinchdb/cli/commands/__init__.py

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

cinchdb/cli/commands/index.py

@@ -0,0 +1,186 @@
+"""Index management commands for CinchDB CLI."""
+
+import typer
+from typing import List, Optional
+from rich import print
+from rich.table import Table
+from rich.console import Console
+
+from cinchdb.config import Config
+from cinchdb.managers.index import IndexManager
+from cinchdb.cli.utils import handle_cli_error
+
+app = typer.Typer(help="Manage database indexes")
+console = Console()
+
+
+@app.command("create")
+@handle_cli_error
+def create_index(
+    table: str = typer.Argument(..., help="Table name"),
+    columns: List[str] = typer.Argument(..., help="Column names to index"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Index name"),
+    unique: bool = typer.Option(False, "--unique", "-u", help="Create unique index"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Create an index on a table.
+    
+    Indexes are created at the branch level and apply to all tenants.
+    
+    Examples:
+        cinch index create users email
+        cinch index create orders user_id created_at --name idx_user_orders
+        cinch index create products sku --unique
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        index_name = manager.create_index(table, columns, name, unique)
+        
+        unique_text = "[green]UNIQUE[/green] " if unique else ""
+        columns_text = ", ".join(columns)
+        print(f"✓ Created {unique_text}index [bold cyan]{index_name}[/bold cyan] on {table}({columns_text})")
+        
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("drop")
+@handle_cli_error
+def drop_index(
+    name: str = typer.Argument(..., help="Index name"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Drop an index.
+    
+    Indexes are managed at the branch level.
+    
+    Example:
+        cinch index drop idx_users_email
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        manager.drop_index(name)
+        print(f"✓ Dropped index [bold cyan]{name}[/bold cyan]")
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+@handle_cli_error
+def list_indexes(
+    table: Optional[str] = typer.Argument(None, help="Table name to filter indexes"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """List indexes for a table or all tables.
+    
+    Indexes are managed at the branch level and apply to all tenants.
+    
+    Examples:
+        cinch index list
+        cinch index list users
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    indexes = manager.list_indexes(table)
+    
+    if not indexes:
+        if table:
+            print(f"No indexes found for table [cyan]{table}[/cyan]")
+        else:
+            print("No indexes found")
+        return
+    
+    # Create table for display
+    table_obj = Table(title=f"Indexes{f' for {table}' if table else ''}")
+    table_obj.add_column("Name", style="cyan")
+    table_obj.add_column("Table", style="yellow")
+    table_obj.add_column("Columns", style="green")
+    table_obj.add_column("Unique", style="magenta")
+    
+    for idx in indexes:
+        columns_str = ", ".join(idx["columns"])
+        unique_str = "✓" if idx["unique"] else ""
+        table_obj.add_row(
+            idx["name"],
+            idx["table"],
+            columns_str,
+            unique_str
+        )
+    
+    console.print(table_obj)
+
+
+@app.command("info")
+@handle_cli_error
+def index_info(
+    name: str = typer.Argument(..., help="Index name"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Show detailed information about an index.
+    
+    Example:
+        cinch index info idx_users_email
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        info = manager.get_index_info(name)
+        
+        print(f"\nIndex: [bold cyan]{info['name']}[/bold cyan]")
+        print(f"Table: [yellow]{info['table']}[/yellow]")
+        print(f"Columns: [green]{', '.join(info['columns'])}[/green]")
+        print(f"Unique: [magenta]{'Yes' if info['unique'] else 'No'}[/magenta]")
+        print(f"Partial: [blue]{'Yes' if info.get('partial') else 'No'}[/blue]")
+        
+        if info.get('sql'):
+            print(f"\nSQL Definition:")
+            print(f"[dim]{info['sql']}[/dim]")
+            
+        if info.get('columns_info'):
+            print(f"\nColumn Details:")
+            for col in info['columns_info']:
+                print(f"  - Position {col['position']}: {col['column_name']}")
+                
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

cinchdb/cli/main.py

@@ -14,6 +14,7 @@ from cinchdb.cli.commands import (
     view,
     codegen,
     remote,
+    index,
 )
 
 app = typer.Typer(
@@ -42,6 +43,7 @@ app.add_typer(tenant.app, name="tenant", help="Tenant management commands")
 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(codegen.app, name="codegen", help="Code generation commands")
 app.add_typer(remote.app, name="remote", help="Remote instance management")
 

cinchdb/core/database.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     from cinchdb.managers.tenant import TenantManager
     from cinchdb.managers.codegen import CodegenManager
     from cinchdb.managers.merge_manager import MergeManager
+    from cinchdb.managers.index import IndexManager
 
 
 class CinchDB:
@@ -108,6 +109,7 @@ class CinchDB:
         self._tenant_manager: Optional["TenantManager"] = None
         self._codegen_manager: Optional["CodegenManager"] = None
         self._merge_manager: Optional["MergeManager"] = None
+        self._index_manager: Optional["IndexManager"] = None
 
     @property
     def session(self):
@@ -303,6 +305,21 @@ class CinchDB:
             self._merge_manager = MergeManager(self.project_dir, self.database)
         return self._merge_manager
 
+    @property
+    def indexes(self) -> "IndexManager":
+        """Access index operations (local only)."""
+        if not self.is_local:
+            raise RuntimeError(
+                "Direct manager access not available for remote connections"
+            )
+        if self._index_manager is None:
+            from cinchdb.managers.index import IndexManager
+
+            self._index_manager = IndexManager(
+                self.project_dir, self.database, self.branch
+            )
+        return self._index_manager
+
     # Convenience methods for common operations
 
     def query(
@@ -460,6 +477,56 @@ class CinchDB:
             # Remote delete
             self._make_request("DELETE", f"/tables/{table}/data/{id}")
 
+    def create_index(
+        self,
+        table: str,
+        columns: List[str],
+        name: Optional[str] = None,
+        unique: bool = False,
+    ) -> str:
+        """Create an index on a table at the branch level.
+        
+        Indexes are created for the current branch and apply to all tenants.
+
+        Args:
+            table: Table name
+            columns: List of column names to index
+            name: Optional index name (auto-generated if not provided)
+            unique: Whether to create a unique index
+
+        Returns:
+            str: Name of the created index
+
+        Examples:
+            # Simple index on one column
+            db.create_index("users", ["email"])
+            
+            # Unique compound index
+            db.create_index("orders", ["user_id", "order_number"], unique=True)
+            
+            # Named index
+            db.create_index("products", ["category", "price"], name="idx_category_price")
+        """
+        # Convert parameters to Index model for validation
+        from cinchdb.models import Index
+        index = Index(columns=columns, name=name, unique=unique)
+        
+        if self.is_local:
+            return self.indexes.create_index(table, index.columns, index.name, index.unique)
+        else:
+            # Remote index creation
+            result = self._make_request(
+                "POST",
+                "/indexes",
+                json={
+                    "table": table,
+                    "columns": index.columns,
+                    "name": index.name,
+                    "unique": index.unique,
+                },
+            )
+            return result.get("name")
+
     def list_changes(self) -> List["Change"]:
         """List all changes for the current branch.
 

cinchdb/managers/index.py

@@ -0,0 +1,304 @@
+"""Index management for CinchDB."""
+
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import sqlite3
+import json
+from datetime import datetime, timezone
+import uuid
+
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.models.change import Change, ChangeType
+
+
+class IndexManager:
+    """Manages database indexes for CinchDB tables at the branch level."""
+
+    def __init__(
+        self, project_dir: Path, database: str, branch: str
+    ):
+        """Initialize IndexManager.
+
+        Args:
+            project_dir: Path to the project directory
+            database: Database name
+            branch: Branch name
+        """
+        self.project_dir = Path(project_dir)
+        self.database = database
+        self.branch = branch
+
+    def create_index(
+        self,
+        table: str,
+        columns: List[str],
+        name: Optional[str] = None,
+        unique: bool = False,
+        if_not_exists: bool = True,
+    ) -> str:
+        """Create an index on a table.
+
+        Args:
+            table: Table name
+            columns: List of column names to index
+            name: Optional index name (auto-generated if not provided)
+            unique: Whether to create a unique index
+            if_not_exists: Whether to use IF NOT EXISTS clause
+
+        Returns:
+            str: Name of the created index
+
+        Raises:
+            ValueError: If table doesn't exist or columns are invalid
+        """
+        # Convert parameters to Index model for validation
+        from cinchdb.models import Index
+        index = Index(columns=columns, name=name, unique=unique)
+        
+        if not index.columns:
+            raise ValueError("At least one column must be specified for the index")
+
+        # Generate index name if not provided
+        if not index.name:
+            column_str = "_".join(index.columns)
+            unique_prefix = "uniq_" if index.unique else "idx_"
+            index.name = f"{unique_prefix}{table}_{column_str}"
+
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            # Verify table exists
+            result = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                [table]
+            )
+            if not result.fetchone():
+                raise ValueError(f"Table '{table}' does not exist")
+            
+            # Verify columns exist
+            result = conn.execute(f"PRAGMA table_info({table})")
+            existing_columns = {row[1] for row in result.fetchall()}
+            
+            invalid_columns = set(index.columns) - existing_columns
+            if invalid_columns:
+                raise ValueError(
+                    f"Columns {invalid_columns} do not exist in table '{table}'"
+                )
+            
+            # Build and execute CREATE INDEX statement
+            unique_clause = "UNIQUE " if index.unique else ""
+            if_not_exists_clause = "IF NOT EXISTS " if if_not_exists else ""
+            column_list = ", ".join(index.columns)
+            
+            sql = f"CREATE {unique_clause}INDEX {if_not_exists_clause}{index.name} ON {table} ({column_list})"
+            
+            try:
+                result = conn.execute(sql)
+                conn.commit()
+            except sqlite3.Error as e:
+                if "already exists" in str(e):
+                    if not if_not_exists:
+                        raise ValueError(f"Index '{index.name}' already exists")
+                else:
+                    raise
+        
+        # Track the change
+        self._track_change(
+            ChangeType.CREATE_INDEX,
+            index.name,
+            {"table": table, "columns": index.columns, "unique": index.unique}
+        )
+        
+        return index.name
+
+    def drop_index(self, name: str, if_exists: bool = True) -> None:
+        """Drop an index.
+
+        Args:
+            name: Index name
+            if_exists: Whether to use IF EXISTS clause
+
+        Raises:
+            ValueError: If index doesn't exist and if_exists is False
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Check if index exists
+            result = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='index' AND name=?",
+                [name]
+            )
+            exists = result.fetchone() is not None
+            
+            if not exists and not if_exists:
+                raise ValueError(f"Index '{name}' does not exist")
+            
+            if exists:
+                if_exists_clause = "IF EXISTS " if if_exists else ""
+                sql = f"DROP INDEX {if_exists_clause}{name}"
+                
+                result = conn.execute(sql)
+                conn.commit()
+                
+                # Track the change
+                self._track_change(ChangeType.DROP_INDEX, name, {})
+
+    def list_indexes(self, table: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List indexes for a table or all tables.
+
+        Args:
+            table: Optional table name to filter indexes
+
+        Returns:
+            List of index information dictionaries
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        indexes = []
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Get all indexes (excluding SQLite internal indexes)
+            if table:
+                result = conn.execute(
+                    """
+                    SELECT name, tbl_name, sql 
+                    FROM sqlite_master 
+                    WHERE type='index' 
+                    AND tbl_name=? 
+                    AND sql IS NOT NULL
+                    """,
+                    [table]
+                )
+            else:
+                result = conn.execute(
+                    """
+                    SELECT name, tbl_name, sql 
+                    FROM sqlite_master 
+                    WHERE type='index' 
+                    AND sql IS NOT NULL
+                    """
+                )
+            
+            for row in result.fetchall():
+                index_name, table_name, sql = row
+                
+                # Parse unique from SQL
+                is_unique = "CREATE UNIQUE INDEX" in sql.upper()
+                
+                # Get indexed columns
+                pragma_result = conn.execute(f"PRAGMA index_info({index_name})")
+                columns = [info[2] for info in pragma_result.fetchall()]
+                
+                indexes.append({
+                    "name": index_name,
+                    "table": table_name,
+                    "columns": columns,
+                    "unique": is_unique,
+                    "sql": sql
+                })
+        
+        return indexes
+
+    def get_index_info(self, name: str) -> Dict[str, Any]:
+        """Get detailed information about a specific index.
+
+        Args:
+            name: Index name
+
+        Returns:
+            Dictionary with index information
+
+        Raises:
+            ValueError: If index doesn't exist
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Get index info
+            result = conn.execute(
+                """
+                SELECT name, tbl_name, sql 
+                FROM sqlite_master 
+                WHERE type='index' 
+                AND name=?
+                """,
+                [name]
+            )
+            
+            row = result.fetchone()
+            if not row:
+                raise ValueError(f"Index '{name}' does not exist")
+            
+            index_name, table_name, sql = row
+            
+            # Parse unique from SQL
+            is_unique = "CREATE UNIQUE INDEX" in (sql or "").upper()
+            
+            # Get indexed columns with more details
+            pragma_result = conn.execute(f"PRAGMA index_info({index_name})")
+            columns_info = []
+            for info in pragma_result.fetchall():
+                columns_info.append({
+                    "position": info[0],
+                    "column_id": info[1],
+                    "column_name": info[2]
+                })
+            
+            # Get index statistics
+            xinfo_result = conn.execute(f"PRAGMA index_xinfo({index_name})")
+            extended_info = xinfo_result.fetchall()
+            
+            return {
+                "name": index_name,
+                "table": table_name,
+                "columns": [col["column_name"] for col in columns_info],
+                "columns_info": columns_info,
+                "unique": is_unique,
+                "sql": sql,
+                "partial": sql and "WHERE" in sql.upper() if sql else False
+            }
+
+    def _track_change(
+        self, change_type: ChangeType, entity_name: str, metadata: Dict[str, Any]
+    ) -> None:
+        """Track a change for this branch.
+
+        Args:
+            change_type: Type of change
+            entity_name: Name of the entity being changed
+            metadata: Additional metadata about the change
+        """
+        # Import here to avoid circular dependency
+        from cinchdb.managers.change_tracker import ChangeTracker
+        
+        tracker = ChangeTracker(self.project_dir, self.database, self.branch)
+        
+        change = Change(
+            id=str(uuid.uuid4()),
+            type=change_type,
+            entity_type="index",
+            entity_name=entity_name,
+            branch=self.branch,
+            metadata=metadata,
+            applied=True,
+            created_at=datetime.now(timezone.utc),
+        )
+        
+        tracker.add_change(change)

cinchdb/managers/table.py

@@ -1,9 +1,12 @@
 """Table management for CinchDB."""
 
 from pathlib import Path
-from typing import List
+from typing import List, Optional, TYPE_CHECKING
 
 from cinchdb.models import Table, Column, Change, ChangeType
+
+if TYPE_CHECKING:
+    from cinchdb.models import Index
 from cinchdb.core.connection import DatabaseConnection
 from cinchdb.core.path_utils import get_tenant_db_path
 from cinchdb.core.maintenance import check_maintenance_mode
@@ -61,12 +64,13 @@ class TableManager:
 
         return tables
 
-    def create_table(self, table_name: str, columns: List[Column]) -> Table:
-        """Create a new table with optional foreign key constraints.
+    def create_table(self, table_name: str, columns: List[Column], indexes: Optional[List["Index"]] = None) -> Table:
+        """Create a new table with optional foreign key constraints and indexes.
 
         Args:
             table_name: Name of the table
             columns: List of Column objects defining the schema
+            indexes: Optional list of Index objects to create on the table
 
         Returns:
             Created Table object
@@ -168,6 +172,20 @@ class TableManager:
         applier = ChangeApplier(self.project_root, self.database, self.branch)
         applier.apply_change(change.id)
 
+        # Create indexes if specified
+        if indexes:
+            from cinchdb.managers.index import IndexManager
+            index_manager = IndexManager(self.project_root, self.database, self.branch)
+            
+            for index in indexes:
+                index_manager.create_index(
+                    table=table_name,
+                    columns=index.columns,
+                    name=index.name,
+                    unique=index.unique,
+                    if_not_exists=True
+                )
+
         # Return the created table
         return Table(
             name=table_name,

cinchdb/managers/tenant.py

@@ -104,6 +104,10 @@ class TenantManager:
                 conn.execute(f"DELETE FROM {table}")
 
             conn.commit()
+        
+        # Open a new connection to vacuum the database
+        with DatabaseConnection(new_db_path) as conn:
+            conn.execute("VACUUM")
 
         return Tenant(
             name=tenant_name,

cinchdb/models/__init__.py

@@ -5,7 +5,7 @@ from .project import Project
 from .database import Database
 from .branch import Branch
 from .tenant import Tenant
-from .table import Table, Column, ColumnType, ForeignKeyRef, ForeignKeyAction
+from .table import Table, Column, ColumnType, ForeignKeyRef, ForeignKeyAction, Index
 from .view import View
 from .change import Change, ChangeType
 
@@ -21,6 +21,7 @@ __all__ = [
     "ColumnType",
     "ForeignKeyRef",
     "ForeignKeyAction",
+    "Index",
     "View",
     "Change",
     "ChangeType",

cinchdb/models/table.py

@@ -27,6 +27,16 @@ class ForeignKeyRef(BaseModel):
     )
 
 
+class Index(BaseModel):
+    """Index specification for table columns."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    columns: List[str] = Field(description="Column names to index")
+    name: Optional[str] = Field(default=None, description="Index name")
+    unique: bool = Field(default=False, description="Create unique index")
+
+
 class Column(BaseModel):
     """Represents a column in a table."""
 

{cinchdb-0.1.6.dist-info → cinchdb-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.6
+Version: 0.1.8
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb

{cinchdb-0.1.6.dist-info → cinchdb-0.1.8.dist-info}/RECORD

@@ -2,13 +2,14 @@ cinchdb/__init__.py,sha256=NZdSzfhRguSBTjJ2dcESOQYy53OZEuBndlB7U08GMY0,179
 cinchdb/__main__.py,sha256=OpkDqn9zkTZhhYgvv_grswWLAHKbmxs4M-8C6Z5HfWY,85
 cinchdb/config.py,sha256=gocjMnYKLWhgvnteo6zprgwtK6Oevoxq547J_v-C9Ns,5265
 cinchdb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cinchdb/cli/main.py,sha256=Icr_uhe_zXPAuhM9NB7evR5b1ZP7f_N40HQcC1JFhQ0,4706
+cinchdb/cli/main.py,sha256=tGX8Z78Oy4rukXth56Xp_pm52rijIDujyMdhSEhFWPw,4790
 cinchdb/cli/utils.py,sha256=NREFxN9k53FnPbDoPt4SXmdZzlzw9zUMv5ICQwTT8gk,5679
-cinchdb/cli/commands/__init__.py,sha256=gQ6tnU0Rvm0-ESWFUBU-KDl5dpNOpUTG509hXOQQjwY,27
+cinchdb/cli/commands/__init__.py,sha256=IRUIPHgdpF4hBDbDy0SgaWn39o5GNUjH54_C42sjlQg,273
 cinchdb/cli/commands/branch.py,sha256=Nz8YQYJ7lizSXEAv0usTx85TDOC-N5Ul9KIxN8JQtKc,17973
 cinchdb/cli/commands/codegen.py,sha256=WsRWmXNTDuaLPyECW5psXM9zOQnKHpUiv8BJnBAjMII,6189
 cinchdb/cli/commands/column.py,sha256=ISHRmcoLf1fAbPqC2MaAYH7Fc6xZWtzCMSRh7_9o-lY,11757
 cinchdb/cli/commands/database.py,sha256=-UCOnn3VatdNog-fX5pguJ2GKdSSXQN99-LSVwkvinY,6857
+cinchdb/cli/commands/index.py,sha256=P0sM9lu1rVliacYl49LPqtxNYdrwzKzpVKW10jC-5i4,6096
 cinchdb/cli/commands/query.py,sha256=XW_YL6M5IYHHHMpVB5p-M01kawFxwDOK5B5hGIy_BA8,5044
 cinchdb/cli/commands/remote.py,sha256=i07hfiAxgrROB9lVJVaKK_nWxT1SGiSbtFb4jvEwxEo,4445
 cinchdb/cli/commands/table.py,sha256=NxfOTCd9beaujffiAPiW0Vko0--HS1JVeCwBMp_khx4,10518
@@ -18,7 +19,7 @@ cinchdb/cli/handlers/__init__.py,sha256=f2f-Cc96rSBLbVsiIbf-b4pZCKZoHfmhNEvnZ0Ou
 cinchdb/cli/handlers/codegen_handler.py,sha256=i5we_AbiUW3zfO6pIKWxvtO8OvOqz3H__4xPmTLEuQM,6524
 cinchdb/core/__init__.py,sha256=iNlT0iO9cM0HLoYwzBavUBoXRh1Tcnz1l_vfbwVxK_Q,246
 cinchdb/core/connection.py,sha256=SlKyEfIpeaDws8M6SfEbvCEVnt26zBY1RYwHtTXj0kY,5110
-cinchdb/core/database.py,sha256=IyMo1wfO3mTnnth0m7eP7Dib6_cEC7bTBo1JhOt6Vlo,19792
+cinchdb/core/database.py,sha256=yeBxzxgKz20Dtoilzj609GHrD3UL2bWG4ArWrRM2VnA,22090
 cinchdb/core/initializer.py,sha256=CjnJSMuR1NrHobyFfwL44tUeH8VE62q02bijEtVH3p4,6922
 cinchdb/core/maintenance.py,sha256=PAgrSL7Cj9p3rKHV0h_L7gupN6nLD0-5eQpJZNiqyEs,2097
 cinchdb/core/path_utils.py,sha256=J2UEu1X_NFOqDamcsrPrC7ZitGTg9Y-HFjmx4sHf5j8,3806
@@ -30,25 +31,26 @@ cinchdb/managers/change_tracker.py,sha256=U93BPnuGv8xSaO5qr_y5Q8ppKrVXygozdp5zUv
 cinchdb/managers/codegen.py,sha256=1CfIwjgHnNDdjrq4SzQ9VE7DFgnWfk7RtpupBFUTqxk,21804
 cinchdb/managers/column.py,sha256=YhYq-hnH0o2BqZkyihnsY5KIWEztzs-_iLJNZMdVUkk,20807
 cinchdb/managers/data.py,sha256=zS1HkMGf436m6f8VdFAqQbQFgo4sL5yKJRcRf4A6lIc,16253
+cinchdb/managers/index.py,sha256=n9bCXggZP6muJQZXCpTT46JvuvcbbnYgeV3j6iXtTVM,10371
 cinchdb/managers/merge_manager.py,sha256=R8S2hLkLJg4hLDpeJTzjVkduZgqPOjXtYgOSJhTXXrE,15690
 cinchdb/managers/query.py,sha256=pBlbqoovnFsZ36pB7nv8NtzcTFwtT26hp8IlwjIx29Q,7301
-cinchdb/managers/table.py,sha256=KWSAfZCJafKZPx-dRG7KwQUGVqVQ56ARMVBllb3VBig,13114
-cinchdb/managers/tenant.py,sha256=QONC5R8tW5CJoGUxECJmQyiSP12mz3rZBmRqxCsKjmM,8726
+cinchdb/managers/table.py,sha256=GltELZ465M8JYwZB5xoMDOvyhRYm-HflPJsQQTStD2c,13837
+cinchdb/managers/tenant.py,sha256=Wx32u71ejZEKStaPRTPw_TqCoE8XzAqFfCRNvmBfNlE,8879
 cinchdb/managers/view.py,sha256=v9gYtRufZyxywPKLGvIjvlUXcxYh9CLRArefu9QX6zk,7809
-cinchdb/models/__init__.py,sha256=382OuS0BaKPA71GjqNW5lfVhtUYqmcMlLRin7HPi6XI,602
+cinchdb/models/__init__.py,sha256=cZ-ailJ6qu44Iap5Rq555iB-_w9ufXVDBH3rDH-ojk0,622
 cinchdb/models/base.py,sha256=7j4rlFTP5K9ZuF8vxwC7lMFEaL7O90NJ47Ig5i7ubcw,1320
 cinchdb/models/branch.py,sha256=gRgLpRFkMC3fxf9ZigVOkS6wdkBERWqlLk0_gOYjqNk,1180
 cinchdb/models/change.py,sha256=YpBWdI6yMT3uucd8duET9s75xr5JUWJqurkkyTlXPlk,1449
 cinchdb/models/database.py,sha256=QrWd_SkE1G8TMWflO4sXRUbSdbqcrfGOt2e-PS7OW7A,971
 cinchdb/models/project.py,sha256=6GMXUZUsEIebqQJgRXIthWzpWKuNNmJ3drgI1vFDrMo,644
-cinchdb/models/table.py,sha256=k2_nnyW1E6-UM2Zw49K5njP_fxySW3HVWymcR_a0e_0,2759
+cinchdb/models/table.py,sha256=hamYjYUunNnVBMcE5NNyubS5Y8_wTJ8_aMnA5r8mpkE,3097
 cinchdb/models/tenant.py,sha256=UKYTKM4mQH3IqEjI_tOU5CszwBWH4cXa3lI0mpMFF_4,967
 cinchdb/models/view.py,sha256=q6j-jYzFJuhRJO87rKt6Uv8hOizHQx8xwoPKoH6XnNY,530
 cinchdb/utils/__init__.py,sha256=yQQhEjndDiB2SUJybUmp9dvEOQKiR-GySe-WiCius5E,490
 cinchdb/utils/name_validator.py,sha256=dyGX5bjlTFRA9EGrWRQKp6kR__HSV04hLV5VueJs4IQ,4027
 cinchdb/utils/sql_validator.py,sha256=aWOGlPX0gBkuR6R1EBP2stbP4PHZuI6FUBi2Ljx7JUI,5815
-cinchdb-0.1.6.dist-info/METADATA,sha256=1vNN2cSZJi_B_ho9yHtnLRjYt3x537gd905QAOtJyK0,6334
-cinchdb-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cinchdb-0.1.6.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
-cinchdb-0.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cinchdb-0.1.6.dist-info/RECORD,,
+cinchdb-0.1.8.dist-info/METADATA,sha256=Lx66m_6wkzVWt_N2rtcO5xVBVL5XHNxlfaOI-5-DN30,6334
+cinchdb-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cinchdb-0.1.8.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
+cinchdb-0.1.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cinchdb-0.1.8.dist-info/RECORD,,