cinchdb 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

cinchdb/infrastructure/metadata_db.py

@@ -0,0 +1,376 @@
+"""SQLite-based metadata storage for lazy resource tracking."""
+
+import sqlite3
+import uuid
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+import json
+
+
+class MetadataDB:
+    """Manages SQLite database for project metadata."""
+    
+    def __init__(self, project_path: Path):
+        """Initialize metadata database for a project."""
+        self.db_path = project_path / ".cinchdb" / "metadata.db"
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.conn: Optional[sqlite3.Connection] = None
+        self._connect()
+        self._create_tables()
+    
+    def _connect(self):
+        """Connect to the SQLite database."""
+        # Check if this is a new database
+        is_new_db = not self.db_path.exists()
+        
+        self.conn = sqlite3.connect(
+            str(self.db_path),
+            check_same_thread=False,  # Allow multi-threaded access
+            timeout=30.0
+        )
+        self.conn.row_factory = sqlite3.Row
+        
+        # For new databases, set small page size before creating any tables
+        if is_new_db:
+            self.conn.execute("PRAGMA page_size = 1024")  # 1KB pages for metadata DB
+        
+        self.conn.execute("PRAGMA foreign_keys = ON")
+        self.conn.execute("PRAGMA journal_mode = WAL")  # Better concurrency
+    
+    def _create_tables(self):
+        """Create the metadata tables if they don't exist."""
+        with self.conn:
+            # Databases table
+            self.conn.execute("""
+                CREATE TABLE IF NOT EXISTS databases (
+                    id TEXT PRIMARY KEY,
+                    name TEXT NOT NULL UNIQUE,
+                    description TEXT,
+                    materialized BOOLEAN DEFAULT FALSE,
+                    metadata JSON,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            
+            # Branches table
+            self.conn.execute("""
+                CREATE TABLE IF NOT EXISTS branches (
+                    id TEXT PRIMARY KEY,
+                    database_id TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    parent_branch TEXT,
+                    schema_version TEXT,
+                    materialized BOOLEAN DEFAULT FALSE,
+                    metadata JSON,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (database_id) REFERENCES databases(id) ON DELETE CASCADE,
+                    UNIQUE(database_id, name)
+                )
+            """)
+            
+            # Tenants table
+            self.conn.execute("""
+                CREATE TABLE IF NOT EXISTS tenants (
+                    id TEXT PRIMARY KEY,
+                    branch_id TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    shard TEXT,
+                    materialized BOOLEAN DEFAULT FALSE,
+                    metadata JSON,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (branch_id) REFERENCES branches(id) ON DELETE CASCADE,
+                    UNIQUE(branch_id, name)
+                )
+            """)
+            
+            # Create indexes for common queries
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_branches_database 
+                ON branches(database_id)
+            """)
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_tenants_branch 
+                ON tenants(branch_id)
+            """)
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_databases_materialized 
+                ON databases(materialized)
+            """)
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_branches_materialized 
+                ON branches(materialized)
+            """)
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_tenants_materialized 
+                ON tenants(materialized)
+            """)
+            
+            self.conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_tenants_shard 
+                ON tenants(shard)
+            """)
+    
+    # Database operations
+    def create_database(self, database_id: str, name: str, 
+                       description: Optional[str] = None,
+                       metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Create a lazy database entry."""
+        with self.conn:
+            self.conn.execute("""
+                INSERT INTO databases (id, name, description, metadata)
+                VALUES (?, ?, ?, ?)
+            """, (database_id, name, description, 
+                  json.dumps(metadata) if metadata else None))
+    
+    def get_database(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get database by name."""
+        cursor = self.conn.execute("""
+            SELECT * FROM databases WHERE name = ?
+        """, (name,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+    
+    def list_databases(self, materialized_only: bool = False) -> List[Dict[str, Any]]:
+        """List all databases."""
+        query = "SELECT * FROM databases"
+        if materialized_only:
+            query += " WHERE materialized = TRUE"
+        cursor = self.conn.execute(query)
+        return [dict(row) for row in cursor.fetchall()]
+    
+    def mark_database_materialized(self, database_id: str) -> None:
+        """Mark a database as materialized."""
+        with self.conn:
+            self.conn.execute("""
+                UPDATE databases 
+                SET materialized = TRUE, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (database_id,))
+    
+    # Branch operations
+    def create_branch(self, branch_id: str, database_id: str, name: str,
+                     parent_branch: Optional[str] = None,
+                     schema_version: Optional[str] = None,
+                     metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Create a lazy branch entry."""
+        with self.conn:
+            self.conn.execute("""
+                INSERT INTO branches (id, database_id, name, parent_branch, 
+                                    schema_version, metadata)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (branch_id, database_id, name, parent_branch, schema_version,
+                  json.dumps(metadata) if metadata else None))
+    
+    def get_branch(self, database_id: str, name: str) -> Optional[Dict[str, Any]]:
+        """Get branch by database and name."""
+        cursor = self.conn.execute("""
+            SELECT * FROM branches 
+            WHERE database_id = ? AND name = ?
+        """, (database_id, name))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+    
+    def list_branches(self, database_id: str, 
+                     materialized_only: bool = False) -> List[Dict[str, Any]]:
+        """List branches for a database."""
+        query = "SELECT * FROM branches WHERE database_id = ?"
+        params = [database_id]
+        if materialized_only:
+            query += " AND materialized = TRUE"
+        cursor = self.conn.execute(query, params)
+        return [dict(row) for row in cursor.fetchall()]
+    
+    def mark_branch_materialized(self, branch_id: str) -> None:
+        """Mark a branch as materialized."""
+        with self.conn:
+            self.conn.execute("""
+                UPDATE branches 
+                SET materialized = TRUE, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (branch_id,))
+    
+    # Tenant operations
+    def create_tenant(self, tenant_id: str, branch_id: str, name: str,
+                     shard: Optional[str] = None,
+                     metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Create a lazy tenant entry."""
+        with self.conn:
+            self.conn.execute("""
+                INSERT INTO tenants (id, branch_id, name, shard, metadata)
+                VALUES (?, ?, ?, ?, ?)
+            """, (tenant_id, branch_id, name, shard,
+                  json.dumps(metadata) if metadata else None))
+    
+    def get_tenant(self, branch_id: str, name: str) -> Optional[Dict[str, Any]]:
+        """Get tenant by branch and name."""
+        cursor = self.conn.execute("""
+            SELECT * FROM tenants 
+            WHERE branch_id = ? AND name = ?
+        """, (branch_id, name))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+    
+    def list_tenants(self, branch_id: str,
+                    materialized_only: bool = False) -> List[Dict[str, Any]]:
+        """List tenants for a branch."""
+        query = "SELECT * FROM tenants WHERE branch_id = ?"
+        params = [branch_id]
+        if materialized_only:
+            query += " AND materialized = TRUE"
+        cursor = self.conn.execute(query, params)
+        return [dict(row) for row in cursor.fetchall()]
+    
+    def get_tenants_by_shard(self, branch_id: str, shard: str) -> List[Dict[str, Any]]:
+        """Get all tenants in a specific shard for a branch."""
+        cursor = self.conn.execute("""
+            SELECT * FROM tenants 
+            WHERE branch_id = ? AND shard = ?
+        """, (branch_id, shard))
+        return [dict(row) for row in cursor.fetchall()]
+    
+    def mark_tenant_materialized(self, tenant_id: str) -> None:
+        """Mark a tenant as materialized."""
+        with self.conn:
+            self.conn.execute("""
+                UPDATE tenants 
+                SET materialized = TRUE, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (tenant_id,))
+    
+    def delete_database(self, database_id: str) -> None:
+        """Delete a database and all its branches and tenants (cascading delete)."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM databases WHERE id = ?
+            """, (database_id,))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Database with id {database_id} not found")
+    
+    def delete_database_by_name(self, name: str) -> None:
+        """Delete a database by name and all its branches and tenants (cascading delete)."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM databases WHERE name = ?
+            """, (name,))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Database '{name}' not found")
+    
+    def delete_branch(self, branch_id: str) -> None:
+        """Delete a branch and all its tenants (cascading delete)."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM branches WHERE id = ?
+            """, (branch_id,))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Branch with id {branch_id} not found")
+    
+    def delete_branch_by_name(self, database_id: str, branch_name: str) -> None:
+        """Delete a branch by name and all its tenants (cascading delete)."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM branches WHERE database_id = ? AND name = ?
+            """, (database_id, branch_name))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Branch '{branch_name}' not found in database")
+    
+    def delete_tenant(self, tenant_id: str) -> None:
+        """Delete a tenant."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM tenants WHERE id = ?
+            """, (tenant_id,))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Tenant with id {tenant_id} not found")
+    
+    def delete_tenant_by_name(self, branch_id: str, tenant_name: str) -> None:
+        """Delete a tenant by name."""
+        with self.conn:
+            cursor = self.conn.execute("""
+                DELETE FROM tenants WHERE branch_id = ? AND name = ?
+            """, (branch_id, tenant_name))
+            if cursor.rowcount == 0:
+                raise ValueError(f"Tenant '{tenant_name}' not found in branch")
+    
+    def tenant_exists(self, database_name: str, branch_name: str, 
+                     tenant_name: str) -> bool:
+        """Check if a tenant exists (lazy or materialized)."""
+        cursor = self.conn.execute("""
+            SELECT 1 FROM tenants t
+            JOIN branches b ON t.branch_id = b.id
+            JOIN databases d ON b.database_id = d.id
+            WHERE d.name = ? AND b.name = ? AND t.name = ?
+            LIMIT 1
+        """, (database_name, branch_name, tenant_name))
+        return cursor.fetchone() is not None
+    
+    def get_full_tenant_info(self, database_name: str, branch_name: str,
+                            tenant_name: str) -> Optional[Dict[str, Any]]:
+        """Get full tenant information including database and branch details."""
+        cursor = self.conn.execute("""
+            SELECT 
+                t.*,
+                b.name as branch_name,
+                b.schema_version,
+                b.materialized as branch_materialized,
+                d.name as database_name,
+                d.materialized as database_materialized
+            FROM tenants t
+            JOIN branches b ON t.branch_id = b.id
+            JOIN databases d ON b.database_id = d.id
+            WHERE d.name = ? AND b.name = ? AND t.name = ?
+        """, (database_name, branch_name, tenant_name))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+    
+    # Utility methods
+    def copy_tenants_to_branch(self, source_branch_id: str, target_branch_id: str, 
+                               as_lazy: bool = True) -> int:
+        """Copy all tenants from source branch to target branch.
+        
+        Args:
+            source_branch_id: ID of source branch
+            target_branch_id: ID of target branch  
+            as_lazy: If True, copied tenants are marked as not materialized
+            
+        Returns:
+            Number of tenants copied
+        """
+        with self.conn:
+            # Get all tenants from source branch
+            cursor = self.conn.execute("""
+                SELECT name, metadata FROM tenants 
+                WHERE branch_id = ?
+            """, (source_branch_id,))
+            
+            tenants = cursor.fetchall()
+            
+            for tenant in tenants:
+                tenant_id = str(uuid.uuid4())
+                self.conn.execute("""
+                    INSERT INTO tenants (id, branch_id, name, materialized, metadata)
+                    VALUES (?, ?, ?, ?, ?)
+                """, (tenant_id, target_branch_id, tenant['name'], 
+                      not as_lazy, tenant['metadata']))
+            
+            return len(tenants)
+    
+    def close(self):
+        """Close the database connection."""
+        if self.conn:
+            self.conn.close()
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()

cinchdb/managers/branch.py

@@ -2,8 +2,9 @@
 
 import json
 import shutil
+import uuid
 from pathlib import Path
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from datetime import datetime, timezone
 
 from cinchdb.models import Branch
@@ -13,6 +14,8 @@ from cinchdb.core.path_utils import (
     list_branches,
 )
 from cinchdb.utils.name_validator import validate_name
+from cinchdb.infrastructure.metadata_db import MetadataDB
+from cinchdb.infrastructure.metadata_connection_pool import get_metadata_db
 
 
 class BranchManager:
@@ -28,6 +31,27 @@ class BranchManager:
         self.project_root = Path(project_root)
         self.database = database
         self.db_path = get_database_path(self.project_root, database)
+        
+        # Lazy-initialized pooled connection
+        self._metadata_db = None
+        self.database_id = None
+    
+    def _ensure_initialized(self) -> None:
+        """Ensure metadata connection and IDs are initialized."""
+        if self._metadata_db is None:
+            self._metadata_db = get_metadata_db(self.project_root)
+            
+            # Initialize database ID on first access
+            if self.database_id is None:
+                db_info = self._metadata_db.get_database(self.database)
+                if db_info:
+                    self.database_id = db_info['id']
+
+    @property
+    def metadata_db(self) -> MetadataDB:
+        """Get metadata database connection (lazy-initialized from pool)."""
+        self._ensure_initialized()
+        return self._metadata_db
 
     def list_branches(self) -> List[Branch]:
         """List all branches in the database.
@@ -67,30 +91,84 @@ class BranchManager:
         """
         # Validate new branch name
         validate_name(new_branch_name, "branch")
-
-        # Validate source branch exists
-        if source_branch not in list_branches(self.project_root, self.database):
+        
+        # Ensure initialization
+        self._ensure_initialized()
+        
+        if not self.database_id:
+            raise ValueError(f"Database '{self.database}' not found in metadata")
+
+        # Validate source branch exists in metadata
+        source_branch_info = self.metadata_db.get_branch(self.database_id, source_branch)
+        if not source_branch_info:
             raise ValueError(f"Source branch '{source_branch}' does not exist")
 
         # Validate new branch doesn't exist
-        if new_branch_name in list_branches(self.project_root, self.database):
+        existing_branch = self.metadata_db.get_branch(self.database_id, new_branch_name)
+        if existing_branch:
             raise ValueError(f"Branch '{new_branch_name}' already exists")
 
-        # Get paths
+        # Create branch ID
+        branch_id = str(uuid.uuid4())
+        
+        # Get source branch schema version
+        schema_version = source_branch_info['schema_version'] if source_branch_info else "v1.0.0"
+        
+        # Create branch in metadata
+        metadata = {
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "copied_from": source_branch,
+        }
+        self.metadata_db.create_branch(
+            branch_id, self.database_id, new_branch_name,
+            parent_branch=source_branch,
+            schema_version=schema_version,
+            metadata=metadata
+        )
+        
+        # Copy all tenant entries from source branch to new branch
+        # Tenants are branch-specific, so each branch needs its own tenant entries
+        source_tenants = self.metadata_db.list_tenants(source_branch_info['id'])
+        for tenant in source_tenants:
+            new_tenant_id = str(uuid.uuid4())
+            tenant_metadata = json.loads(tenant['metadata']) if tenant['metadata'] else {}
+            tenant_metadata['copied_from'] = source_branch
+            
+            # Create tenant in new branch, preserving materialization status and shard info
+            self.metadata_db.create_tenant(
+                new_tenant_id, branch_id, tenant['name'], tenant['shard'],
+                metadata=tenant_metadata
+            )
+            
+            # Preserve materialization status from source branch
+            if tenant['materialized']:
+                self.metadata_db.mark_tenant_materialized(new_tenant_id)
+        
+        # Ensure __empty__ tenant exists (in case source branch didn't have it)
+        if not any(t['name'] == '__empty__' for t in source_tenants):
+            import hashlib
+            empty_shard = hashlib.sha256("__empty__".encode('utf-8')).hexdigest()[:2]
+            empty_tenant_id = str(uuid.uuid4())
+            self.metadata_db.create_tenant(
+                empty_tenant_id, branch_id, "__empty__", empty_shard,
+                metadata={"system": True, "description": "Template for lazy tenants"}
+            )
+
+        # Copy entire branch directory (branches should copy ALL files including tenants)
         source_path = get_branch_path(self.project_root, self.database, source_branch)
         new_path = get_branch_path(self.project_root, self.database, new_branch_name)
-
-        # Copy entire branch directory
-        shutil.copytree(source_path, new_path)
-
-        # Update metadata for new branch
-        metadata = self.get_branch_metadata(new_branch_name)
-        metadata["parent_branch"] = source_branch
-        metadata["created_at"] = datetime.now(timezone.utc).isoformat()
-        self.update_branch_metadata(new_branch_name, metadata)
-
-        # New branch inherits all changes from source branch
-        # (changes.json is already copied by copytree, so nothing to do here)
+        
+        if source_path.exists():
+            shutil.copytree(source_path, new_path)
+            
+            # Update branch metadata file
+            fs_metadata = self.get_branch_metadata(new_branch_name)
+            fs_metadata["parent_branch"] = source_branch
+            fs_metadata["created_at"] = datetime.now(timezone.utc).isoformat()
+            self.update_branch_metadata(new_branch_name, fs_metadata)
+        
+        # Mark branch as materialized (always true now)
+        self.metadata_db.mark_branch_materialized(branch_id)
 
         return Branch(
             name=new_branch_name,
@@ -112,14 +190,31 @@ class BranchManager:
         # Can't delete main branch
         if branch_name == "main":
             raise ValueError("Cannot delete the main branch")
-
-        # Validate branch exists
-        if branch_name not in list_branches(self.project_root, self.database):
+        
+        # Ensure initialization
+        self._ensure_initialized()
+        
+        if not self.database_id:
+            raise ValueError(f"Database '{self.database}' not found in metadata")
+
+        # Check if branch exists in metadata
+        branch_info = self.metadata_db.get_branch(self.database_id, branch_name)
+        if not branch_info:
             raise ValueError(f"Branch '{branch_name}' does not exist")
+        
+        # NOTE: We delete from metadata first because it's better to have a scared, lost file than a zombie branch
+
+        # Delete from metadata (cascade deletes will handle tenants)
+        with self.metadata_db.conn:
+            self.metadata_db.conn.execute(
+                "DELETE FROM branches WHERE id = ?",
+                (branch_info['id'],)
+            )
 
-        # Delete branch directory
+        # Delete branch directory if it exists
         branch_path = get_branch_path(self.project_root, self.database, branch_name)
-        shutil.rmtree(branch_path)
+        if branch_path.exists():
+            shutil.rmtree(branch_path)
 
     def get_branch_metadata(self, branch_name: str) -> Dict[str, Any]:
         """Get metadata for a branch.
@@ -168,3 +263,4 @@ class BranchManager:
             True if branch exists, False otherwise
         """
         return branch_name in list_branches(self.project_root, self.database)
+    

cinchdb/managers/change_applier.py

@@ -64,6 +64,8 @@ class ChangeApplier:
     def apply_change(self, change_id: str) -> None:
         """Apply a single change to all tenants atomically with snapshot-based rollback.
 
+        For lazy tenants, skip applying changes - they will inherit changes from the __empty__ tenant later.
+
         Args:
             change_id: ID of the change to apply
 
@@ -81,20 +83,35 @@ class ChangeApplier:
             logger.info(f"Change {change_id} already applied")
             return
 
-        backup_dir = self._get_backup_dir(change.id)
-        tenants = self.tenant_manager.list_tenants()
+        # Ensure __empty__ tenant exists and is materialized
+        # This is critical for schema changes as it's the template for lazy tenants
+        self.tenant_manager._ensure_empty_tenant()
 
-        if not tenants:
-            # No tenants, just mark as applied
+        backup_dir = self._get_backup_dir(change.id)
+        # Include system tenants (like __empty__) when applying schema changes
+        all_tenants = self.tenant_manager.list_tenants(include_system=True)
+        
+        # Filter to only materialized tenants (those with actual .db files)
+        # Schema changes can only be applied to materialized tenants
+        # Lazy tenants will inherit the schema from __empty__ when materialized
+        materialized_tenants = []
+        for tenant in all_tenants:
+            # Always include __empty__ (schema template) or check if materialized
+            if tenant.name == "__empty__" or not self.tenant_manager.is_tenant_lazy(tenant.name):
+                materialized_tenants.append(tenant)
+        
+        if not materialized_tenants:
+            # No materialized tenants, just mark as applied
+            # The schema change will be in __empty__ for future lazy tenant materialization
             self.change_tracker.mark_change_applied(change_id)
             return
 
-        logger.info(f"Applying change {change_id} to {len(tenants)} tenants...")
+        logger.info(f"Applying change {change_id} to {len(materialized_tenants)} materialized tenants (out of {len(all_tenants)} total)...")
 
         try:
-            # Phase 1: Create snapshots
+            # Phase 1: Create snapshots (only for materialized tenants)
             logger.info("Creating database snapshots...")
-            self._create_snapshots(tenants, backup_dir)
+            self._create_snapshots(materialized_tenants, backup_dir)
 
             # Phase 2: Enter maintenance mode to block writes
             logger.info("Entering maintenance mode for schema update...")
@@ -104,7 +121,7 @@ class ChangeApplier:
                 # Track which tenants we've applied to
                 applied_tenants = []
 
-                for tenant in tenants:
+                for tenant in materialized_tenants:
                     try:
                         self._apply_change_to_tenant(change, tenant.name)
                         applied_tenants.append(tenant.name)
@@ -127,7 +144,7 @@ class ChangeApplier:
                 self._cleanup_snapshots(backup_dir)
 
                 logger.info(
-                    f"Schema update complete. Applied change {change_id} to {len(tenants)} tenants"
+                    f"Schema update complete. Applied change {change_id} to {len(materialized_tenants)} materialized tenants"
                 )
 
             except Exception:
@@ -136,12 +153,12 @@ class ChangeApplier:
                 raise
 
         except Exception as e:
-            # Rollback all tenants
+            # Rollback all materialized tenants
             logger.error(f"Change {change_id} failed: {e}")
-            logger.info("Rolling back all tenants to snapshot...")
+            logger.info("Rolling back all materialized tenants to snapshot...")
 
-            # Restore all tenants from snapshots
-            self._restore_all_snapshots(tenants, backup_dir)
+            # Restore all materialized tenants from snapshots
+            self._restore_all_snapshots(materialized_tenants, backup_dir)
 
             # Clean up backup directory
             self._cleanup_snapshots(backup_dir)