cinchdb 0.1.0__py3-none-any.whl

cinchdb/managers/merge_manager.py

@@ -0,0 +1,429 @@
+"""Branch merging functionality for CinchDB."""
+
+from pathlib import Path
+from typing import List, Dict, Any
+from cinchdb.models import Change, ChangeType
+from cinchdb.managers.change_tracker import ChangeTracker
+from cinchdb.managers.change_applier import ChangeApplier
+from cinchdb.managers.change_comparator import ChangeComparator
+from cinchdb.managers.branch import BranchManager
+from cinchdb.core.path_utils import list_tenants
+
+
+class MergeError(Exception):
+    """Exception raised when merge operations fail."""
+
+    pass
+
+
+class MergeManager:
+    """Manages merging operations between branches."""
+
+    def __init__(self, project_root: Path, database_name: str):
+        """Initialize the merge manager.
+
+        Args:
+            project_root: Path to the project root
+            database_name: Name of the database
+        """
+        self.project_root = Path(project_root)
+        self.database_name = database_name
+        self.comparator = ChangeComparator(project_root, database_name)
+        self.branch_manager = BranchManager(project_root, database_name)
+
+    def can_merge(self, source_branch: str, target_branch: str) -> Dict[str, Any]:
+        """Check if source branch can be merged into target branch.
+
+        Args:
+            source_branch: Name of the source branch
+            target_branch: Name of the target branch
+
+        Returns:
+            Dictionary with merge status and details
+        """
+        # Check if branches exist
+        if not self.branch_manager.branch_exists(source_branch):
+            return {
+                "can_merge": False,
+                "reason": f"Source branch '{source_branch}' does not exist",
+            }
+
+        if not self.branch_manager.branch_exists(target_branch):
+            return {
+                "can_merge": False,
+                "reason": f"Target branch '{target_branch}' does not exist",
+            }
+
+        # Check for conflicts
+        conflicts = self.comparator.detect_conflicts(source_branch, target_branch)
+        if conflicts:
+            return {
+                "can_merge": False,
+                "reason": "Merge conflicts detected",
+                "conflicts": conflicts,
+            }
+
+        # Check if there are changes to merge
+        source_only, target_only = self.comparator.get_divergent_changes(
+            source_branch, target_branch
+        )
+        if not source_only:
+            return {
+                "can_merge": False,
+                "reason": "No changes to merge from source branch",
+            }
+
+        # Check merge type
+        is_fast_forward = self.comparator.can_fast_forward_merge(
+            source_branch, target_branch
+        )
+
+        return {
+            "can_merge": True,
+            "merge_type": "fast_forward" if is_fast_forward else "three_way",
+            "changes_to_merge": len(source_only),
+            "target_changes": len(target_only),
+        }
+
+    def _merge_branches_internal(
+        self,
+        source_branch: str,
+        target_branch: str,
+        force: bool = False,
+        dry_run: bool = False,
+    ) -> Dict[str, Any]:
+        """Internal merge method without main branch protection.
+
+        Args:
+            source_branch: Name of the source branch
+            target_branch: Name of the target branch
+            force: If True, attempt merge even with conflicts
+            dry_run: If True, return SQL statements without executing
+
+        Returns:
+            Dictionary with merge result details
+
+        Raises:
+            MergeError: If merge cannot be completed
+        """
+        # Check if merge is possible
+        merge_check = self.can_merge(source_branch, target_branch)
+        if not merge_check["can_merge"]:
+            if not force:
+                raise MergeError(f"Cannot merge: {merge_check['reason']}")
+            elif "conflicts" in merge_check:
+                raise MergeError(
+                    f"Cannot force merge due to conflicts: {', '.join(merge_check['conflicts'])}"
+                )
+
+        # Get changes to merge
+        source_only, _ = self.comparator.get_divergent_changes(
+            source_branch, target_branch
+        )
+        if not source_only:
+            return {
+                "success": True,
+                "message": "No changes to merge",
+                "changes_merged": 0,
+            }
+
+        # Order changes for safe merging
+        ordered_changes = self.comparator.get_merge_order(source_only)
+
+        if dry_run:
+            # Collect SQL statements that would be executed
+            sql_statements = self._collect_sql_statements(
+                ordered_changes, target_branch
+            )
+            return {
+                "success": True,
+                "dry_run": True,
+                "message": f"Dry run: would merge {len(ordered_changes)} changes from '{source_branch}' to '{target_branch}'",
+                "changes_to_merge": len(ordered_changes),
+                "merge_type": merge_check.get("merge_type", "unknown"),
+                "sql_statements": sql_statements,
+            }
+
+        try:
+            # Apply changes to target branch atomically
+            self._apply_changes_to_branch(ordered_changes, target_branch)
+
+            return {
+                "success": True,
+                "message": f"Successfully merged {len(ordered_changes)} changes from '{source_branch}' to '{target_branch}'",
+                "changes_merged": len(ordered_changes),
+                "merge_type": merge_check.get("merge_type", "unknown"),
+            }
+
+        except Exception as e:
+            raise MergeError(f"Merge failed during application: {str(e)}")
+
+    def merge_branches(
+        self,
+        source_branch: str,
+        target_branch: str,
+        force: bool = False,
+        dry_run: bool = False,
+    ) -> Dict[str, Any]:
+        """Merge source branch into target branch.
+
+        Args:
+            source_branch: Name of the source branch
+            target_branch: Name of the target branch
+            force: If True, attempt merge even with conflicts
+            dry_run: If True, return SQL statements without executing
+
+        Returns:
+            Dictionary with merge result details
+
+        Raises:
+            MergeError: If merge cannot be completed
+        """
+        # Protect main branch from direct changes
+        if target_branch == "main":
+            raise MergeError(
+                "Cannot merge directly into main branch. Main branch is protected."
+            )
+
+        # Use internal method for actual merge
+        return self._merge_branches_internal(
+            source_branch, target_branch, force, dry_run
+        )
+
+    def _apply_changes_to_branch(
+        self, changes: List[Change], target_branch: str
+    ) -> None:
+        """Apply changes to target branch atomically.
+
+        Args:
+            changes: List of changes to apply
+            target_branch: Name of the target branch
+
+        Raises:
+            MergeError: If changes cannot be applied
+        """
+        target_tracker = ChangeTracker(
+            self.project_root, self.database_name, target_branch
+        )
+        target_applier = ChangeApplier(
+            self.project_root, self.database_name, target_branch
+        )
+
+        # Get all tenants for the target branch
+        list_tenants(self.project_root, self.database_name, target_branch)
+
+        applied_changes = []
+
+        try:
+            for change in changes:
+                # Create a copy of the change for the target branch, marking as unapplied
+                # so it gets executed in the target branch's database
+                change_copy = change.model_copy()
+                change_copy.applied = False
+
+                # Add change to target branch history
+                target_tracker.add_change(change_copy)
+                applied_changes.append(change_copy.id)
+
+                # Apply change to all tenants in target branch
+                target_applier.apply_change(change_copy.id)
+
+        except Exception as e:
+            # Rollback: remove changes that were added but not fully applied
+            for change_id in applied_changes:
+                try:
+                    # Note: This is a simplified rollback - in production you'd want
+                    # more sophisticated transaction handling
+                    target_tracker.remove_change(change_id) if hasattr(
+                        target_tracker, "remove_change"
+                    ) else None
+                except Exception:
+                    pass  # Best effort rollback
+
+            raise MergeError(f"Failed to apply changes: {str(e)}")
+
+    def _collect_sql_statements(
+        self, changes: List[Change], target_branch: str
+    ) -> List[Dict[str, Any]]:
+        """Collect SQL statements that would be executed for the given changes.
+
+        Args:
+            changes: List of changes to collect SQL for
+            target_branch: Name of the target branch
+
+        Returns:
+            List of dictionaries with SQL statement information
+        """
+        sql_statements = []
+
+        for change in changes:
+            # Determine what SQL would be executed
+            if change.details and "statements" in change.details:
+                # Multiple statements in a transaction
+                for step_name, sql in change.details["statements"]:
+                    sql_statements.append(
+                        {
+                            "change_id": change.id,
+                            "change_type": change.type.value
+                            if hasattr(change.type, "value")
+                            else change.type,
+                            "entity_name": change.entity_name,
+                            "step": step_name,
+                            "sql": sql,
+                        }
+                    )
+            elif change.type == ChangeType.UPDATE_VIEW:
+                # View update requires DROP and CREATE
+                sql_statements.append(
+                    {
+                        "change_id": change.id,
+                        "change_type": change.type.value
+                        if hasattr(change.type, "value")
+                        else change.type,
+                        "entity_name": change.entity_name,
+                        "step": "drop_existing",
+                        "sql": f"DROP VIEW IF EXISTS {change.entity_name}",
+                    }
+                )
+                sql_statements.append(
+                    {
+                        "change_id": change.id,
+                        "change_type": change.type.value
+                        if hasattr(change.type, "value")
+                        else change.type,
+                        "entity_name": change.entity_name,
+                        "step": "create_view",
+                        "sql": change.sql,
+                    }
+                )
+            elif (
+                change.type == ChangeType.CREATE_TABLE
+                and change.details
+                and change.details.get("copy_sql")
+            ):
+                # Table copy operation
+                sql_statements.append(
+                    {
+                        "change_id": change.id,
+                        "change_type": change.type.value
+                        if hasattr(change.type, "value")
+                        else change.type,
+                        "entity_name": change.entity_name,
+                        "step": "create_table",
+                        "sql": change.sql,
+                    }
+                )
+                sql_statements.append(
+                    {
+                        "change_id": change.id,
+                        "change_type": change.type.value
+                        if hasattr(change.type, "value")
+                        else change.type,
+                        "entity_name": change.entity_name,
+                        "step": "copy_data",
+                        "sql": change.details["copy_sql"],
+                    }
+                )
+            else:
+                # Regular single statement
+                sql_statements.append(
+                    {
+                        "change_id": change.id,
+                        "change_type": change.type.value
+                        if hasattr(change.type, "value")
+                        else change.type,
+                        "entity_name": change.entity_name,
+                        "sql": change.sql,
+                    }
+                )
+
+        return sql_statements
+
+    def merge_into_main(
+        self, source_branch: str, dry_run: bool = False
+    ) -> Dict[str, Any]:
+        """Merge a branch into main branch with additional validation.
+
+        This is the primary way to get changes into main branch.
+
+        Args:
+            source_branch: Name of the source branch to merge
+            dry_run: If True, return SQL statements without executing
+
+        Returns:
+            Dictionary with merge result details
+
+        Raises:
+            MergeError: If merge cannot be completed
+        """
+        if source_branch == "main":
+            raise MergeError("Cannot merge main branch into itself")
+
+        # Additional validation for main branch merges
+        merge_check = self.can_merge(source_branch, "main")
+        if not merge_check["can_merge"]:
+            raise MergeError(f"Cannot merge into main: {merge_check['reason']}")
+
+        # Ensure source branch has all changes from main (is up to date)
+        main_only, source_only = self.comparator.get_divergent_changes(
+            "main", source_branch
+        )
+        if main_only:
+            raise MergeError(
+                f"Source branch '{source_branch}' is not up to date with main. "
+                f"Pull latest changes from main first."
+            )
+
+        # Perform the merge (bypass protection for official merge into main)
+        return self._merge_branches_internal(source_branch, "main", dry_run=dry_run)
+
+    def get_merge_preview(
+        self, source_branch: str, target_branch: str
+    ) -> Dict[str, Any]:
+        """Get a preview of what would happen during a merge.
+
+        Args:
+            source_branch: Name of the source branch
+            target_branch: Name of the target branch
+
+        Returns:
+            Dictionary with merge preview details
+        """
+        merge_check = self.can_merge(source_branch, target_branch)
+
+        if not merge_check["can_merge"]:
+            return {
+                "can_merge": False,
+                "reason": merge_check["reason"],
+                "conflicts": merge_check.get("conflicts", []),
+            }
+
+        source_only, target_only = self.comparator.get_divergent_changes(
+            source_branch, target_branch
+        )
+
+        # Categorize changes by type
+        changes_by_type = {}
+        for change in source_only:
+            entity_type = change.entity_type
+            if entity_type not in changes_by_type:
+                changes_by_type[entity_type] = []
+            changes_by_type[entity_type].append(
+                {
+                    "id": change.id,
+                    "entity_name": change.entity_name,
+                    "operation": change.type,
+                    "timestamp": change.created_at.isoformat(),
+                }
+            )
+
+        return {
+            "can_merge": True,
+            "merge_type": merge_check.get("merge_type", "unknown"),
+            "changes_to_merge": len(source_only),
+            "target_has_changes": len(target_only) > 0,
+            "changes_by_type": changes_by_type,
+            "common_ancestor": self.comparator.find_common_ancestor(
+                source_branch, target_branch
+            ),
+        }

cinchdb/managers/query.py

@@ -0,0 +1,214 @@
+"""Query execution manager for CinchDB - handles SQL queries with type-safe returns."""
+
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Type, TypeVar, Union
+
+from pydantic import BaseModel, ValidationError
+
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.utils import validate_query_safe, SQLValidationError
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class QueryManager:
+    """Manages SQL query execution with support for typed returns."""
+
+    def __init__(
+        self, project_root: Path, database: str, branch: str, tenant: str = "main"
+    ):
+        """Initialize query 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)
+
+    def execute(
+        self, sql: str, params: Optional[Union[tuple, dict]] = None, skip_validation: bool = False
+    ) -> List[Dict[str, Any]]:
+        """Execute a SQL query and return results as dictionaries.
+
+        Args:
+            sql: SQL query to execute
+            params: Optional query parameters (tuple for positional, dict for named)
+            skip_validation: Skip SQL validation (default: False)
+
+        Returns:
+            List of dictionaries representing rows
+
+        Raises:
+            SQLValidationError: If query contains restricted operations
+            Exception: If query execution fails
+        """
+        # Validate query unless explicitly skipped
+        if not skip_validation:
+            validate_query_safe(sql)
+            
+        # Note: The original code had SELECT-only validation, but we're now more permissive
+        if not sql.strip().upper().startswith("SELECT"):
+            raise ValueError(
+                "execute() can only be used with SELECT queries. Use execute_non_query() for INSERT/UPDATE/DELETE operations."
+            )
+
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, params)
+            rows = cursor.fetchall()
+            return [dict(row) for row in rows]
+
+    def execute_typed(
+        self,
+        sql: str,
+        model: Type[T],
+        params: Optional[Union[tuple, dict]] = None,
+        strict: bool = True,
+    ) -> List[T]:
+        """Execute a SQL query and return results as typed model instances.
+
+        Args:
+            sql: SQL query to execute
+            model: Pydantic model class to validate results against
+            params: Optional query parameters
+            strict: If True, raise on validation errors; if False, skip invalid rows
+
+        Returns:
+            List of model instances
+
+        Raises:
+            ValueError: If query is not a SELECT query
+            ValidationError: If strict=True and validation fails
+            Exception: If query execution fails
+        """
+        # Ensure this is a SELECT query
+        if not sql.strip().upper().startswith("SELECT"):
+            raise ValueError("execute_typed can only be used with SELECT queries")
+
+        # Execute query and get raw results
+        rows = self.execute(sql, params)
+
+        # Convert to typed results
+        typed_results = []
+        validation_errors = []
+
+        for i, row in enumerate(rows):
+            try:
+                instance = model(**row)
+                typed_results.append(instance)
+            except ValidationError as e:
+                if strict:
+                    # Re-raise with more context
+                    raise ValueError(
+                        f"Row {i} failed validation for {model.__name__}: {str(e)}"
+                    )
+                else:
+                    validation_errors.append((i, str(e)))
+
+        # If we had validation errors in non-strict mode, we could log them
+        # For now, we'll just return the valid results
+
+        return typed_results
+
+    def execute_one(
+        self, sql: str, params: Optional[Union[tuple, dict]] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Execute a SQL query and return at most one result as a dictionary.
+
+        Args:
+            sql: SQL query to execute
+            params: Optional query parameters
+
+        Returns:
+            Dictionary representing a single row, or None if no results
+
+        Raises:
+            Exception: If query execution fails
+        """
+        results = self.execute(sql, params)
+        return results[0] if results else None
+
+    def execute_one_typed(
+        self,
+        sql: str,
+        model: Type[T],
+        params: Optional[Union[tuple, dict]] = None,
+        strict: bool = True,
+    ) -> Optional[T]:
+        """Execute a SQL query and return at most one result as a typed model instance.
+
+        Args:
+            sql: SQL query to execute
+            model: Pydantic model class to validate result against
+            params: Optional query parameters
+            strict: If True, raise on validation errors
+
+        Returns:
+            Model instance or None if no results
+
+        Raises:
+            ValueError: If query is not a SELECT query
+            ValidationError: If strict=True and validation fails
+            Exception: If query execution fails
+        """
+        results = self.execute_typed(sql, model, params, strict)
+        return results[0] if results else None
+
+    def execute_non_query(
+        self, sql: str, params: Optional[Union[tuple, dict]] = None, skip_validation: bool = False
+    ) -> int:
+        """Execute a non-SELECT SQL query (INSERT, UPDATE, DELETE, etc.).
+
+        Args:
+            sql: SQL query to execute
+            params: Optional query parameters
+            skip_validation: Skip SQL validation (default: False)
+
+        Returns:
+            Number of rows affected
+            
+        Raises:
+            SQLValidationError: If query contains restricted operations
+            Exception: If query execution fails
+        """
+        # Validate query unless explicitly skipped
+        if not skip_validation:
+            validate_query_safe(sql)
+            
+        with DatabaseConnection(self.db_path) as conn:
+            cursor = conn.execute(sql, params)
+            affected_rows = cursor.rowcount
+            conn.commit()
+            return affected_rows
+
+    def execute_many(self, sql: str, params_list: List[Union[tuple, dict]]) -> int:
+        """Execute the same SQL query multiple times with different parameters.
+
+        Args:
+            sql: SQL query to execute
+            params_list: List of parameter sets
+
+        Returns:
+            Total number of rows affected
+
+        Raises:
+            Exception: If query execution fails
+        """
+        total_affected = 0
+
+        with DatabaseConnection(self.db_path) as conn:
+            try:
+                for params in params_list:
+                    cursor = conn.execute(sql, params)
+                    total_affected += cursor.rowcount
+                conn.commit()
+                return total_affected
+            except Exception:
+                conn.rollback()
+                raise