aws-inventory-manager 0.17.12__py3-none-any.whl

src/storage/schema.py

@@ -0,0 +1,339 @@
+"""SQLite schema definitions for AWS Inventory Manager."""
+
+SCHEMA_VERSION = "1.2.0"
+
+# Schema creation SQL
+SCHEMA_SQL = """
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_info (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+-- Core snapshots table
+CREATE TABLE IF NOT EXISTS snapshots (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    created_at TIMESTAMP NOT NULL,
+    account_id TEXT NOT NULL,
+    regions TEXT NOT NULL,
+    resource_count INTEGER DEFAULT 0,
+    total_resources_before_filter INTEGER,
+    service_counts TEXT,
+    metadata TEXT,
+    filters_applied TEXT,
+    schema_version TEXT DEFAULT '1.1',
+    inventory_name TEXT DEFAULT 'default',
+    is_active BOOLEAN DEFAULT 0
+);
+
+-- Resources table
+CREATE TABLE IF NOT EXISTS resources (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    snapshot_id INTEGER NOT NULL,
+    arn TEXT NOT NULL,
+    resource_type TEXT NOT NULL,
+    name TEXT NOT NULL,
+    region TEXT NOT NULL,
+    config_hash TEXT NOT NULL,
+    raw_config TEXT,
+    created_at TIMESTAMP,
+    source TEXT DEFAULT 'direct_api',
+    canonical_name TEXT,
+    normalized_name TEXT,
+    extracted_patterns TEXT,
+    normalization_method TEXT,
+    FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE,
+    UNIQUE(snapshot_id, arn)
+);
+
+-- Normalized tags for efficient querying
+CREATE TABLE IF NOT EXISTS resource_tags (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    resource_id INTEGER NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    FOREIGN KEY (resource_id) REFERENCES resources(id) ON DELETE CASCADE
+);
+
+-- Inventories table
+CREATE TABLE IF NOT EXISTS inventories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    account_id TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    include_tags TEXT,
+    exclude_tags TEXT,
+    active_snapshot_id INTEGER,
+    created_at TIMESTAMP NOT NULL,
+    last_updated TIMESTAMP NOT NULL,
+    FOREIGN KEY (active_snapshot_id) REFERENCES snapshots(id) ON DELETE SET NULL,
+    UNIQUE(name, account_id)
+);
+
+-- Link table for inventory snapshots (many-to-many)
+CREATE TABLE IF NOT EXISTS inventory_snapshots (
+    inventory_id INTEGER NOT NULL,
+    snapshot_id INTEGER NOT NULL,
+    PRIMARY KEY (inventory_id, snapshot_id),
+    FOREIGN KEY (inventory_id) REFERENCES inventories(id) ON DELETE CASCADE,
+    FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE
+);
+
+-- Audit operations table
+CREATE TABLE IF NOT EXISTS audit_operations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    operation_id TEXT UNIQUE NOT NULL,
+    baseline_snapshot TEXT NOT NULL,
+    timestamp TIMESTAMP NOT NULL,
+    aws_profile TEXT,
+    account_id TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    status TEXT NOT NULL,
+    total_resources INTEGER,
+    succeeded_count INTEGER,
+    failed_count INTEGER,
+    skipped_count INTEGER,
+    duration_seconds REAL,
+    filters TEXT
+);
+
+-- Audit records table
+CREATE TABLE IF NOT EXISTS audit_records (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    operation_id TEXT NOT NULL,
+    resource_arn TEXT NOT NULL,
+    resource_id TEXT,
+    resource_type TEXT NOT NULL,
+    region TEXT NOT NULL,
+    status TEXT NOT NULL,
+    error_code TEXT,
+    error_message TEXT,
+    protection_reason TEXT,
+    deletion_tier TEXT,
+    tags TEXT,
+    estimated_monthly_cost REAL,
+    FOREIGN KEY (operation_id) REFERENCES audit_operations(operation_id) ON DELETE CASCADE
+);
+
+-- Saved queries table (for web UI)
+CREATE TABLE IF NOT EXISTS saved_queries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    description TEXT,
+    sql_text TEXT NOT NULL,
+    category TEXT DEFAULT 'custom',
+    is_favorite BOOLEAN DEFAULT 0,
+    created_at TIMESTAMP NOT NULL,
+    last_run_at TIMESTAMP,
+    run_count INTEGER DEFAULT 0
+);
+
+-- Saved filters table (for resource explorer)
+CREATE TABLE IF NOT EXISTS saved_filters (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    description TEXT,
+    filter_config TEXT NOT NULL,
+    is_favorite BOOLEAN DEFAULT 0,
+    created_at TIMESTAMP NOT NULL,
+    last_used_at TIMESTAMP,
+    use_count INTEGER DEFAULT 0
+);
+
+-- Saved views table (for customizable resource views)
+CREATE TABLE IF NOT EXISTS saved_views (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    description TEXT,
+    view_config TEXT NOT NULL,
+    is_default BOOLEAN DEFAULT 0,
+    is_favorite BOOLEAN DEFAULT 0,
+    created_at TIMESTAMP NOT NULL,
+    last_used_at TIMESTAMP,
+    use_count INTEGER DEFAULT 0
+);
+
+-- Resource groups table (for baseline comparison)
+CREATE TABLE IF NOT EXISTS resource_groups (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    description TEXT,
+    source_snapshot TEXT,
+    resource_count INTEGER DEFAULT 0,
+    is_favorite BOOLEAN DEFAULT 0,
+    created_at TIMESTAMP NOT NULL,
+    last_updated TIMESTAMP NOT NULL
+);
+
+-- Resource group members table (normalized for efficient querying)
+CREATE TABLE IF NOT EXISTS resource_group_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    group_id INTEGER NOT NULL,
+    resource_name TEXT NOT NULL,
+    resource_type TEXT NOT NULL,
+    original_arn TEXT,
+    match_strategy TEXT DEFAULT 'physical_name',
+    FOREIGN KEY (group_id) REFERENCES resource_groups(id) ON DELETE CASCADE,
+    UNIQUE (group_id, resource_name, resource_type)
+);
+"""
+
+# Indexes for common queries (created separately for better error handling)
+# SQLite performance tips applied:
+# - Indexes on foreign keys for faster JOINs
+# - Composite indexes for common query patterns
+# - Covering indexes where possible
+INDEXES_SQL = """
+-- Resources indexes
+CREATE INDEX IF NOT EXISTS idx_resources_arn ON resources(arn);
+CREATE INDEX IF NOT EXISTS idx_resources_type ON resources(resource_type);
+CREATE INDEX IF NOT EXISTS idx_resources_region ON resources(region);
+CREATE INDEX IF NOT EXISTS idx_resources_created ON resources(created_at);
+CREATE INDEX IF NOT EXISTS idx_resources_snapshot ON resources(snapshot_id);
+CREATE INDEX IF NOT EXISTS idx_resources_type_region ON resources(resource_type, region);
+CREATE INDEX IF NOT EXISTS idx_resources_canonical_name_type ON resources(canonical_name, resource_type);
+CREATE INDEX IF NOT EXISTS idx_resources_normalized_name_type ON resources(normalized_name, resource_type);
+
+-- Tags indexes (for efficient tag queries)
+CREATE INDEX IF NOT EXISTS idx_tags_resource ON resource_tags(resource_id);
+CREATE INDEX IF NOT EXISTS idx_tags_key ON resource_tags(key);
+CREATE INDEX IF NOT EXISTS idx_tags_value ON resource_tags(value);
+CREATE INDEX IF NOT EXISTS idx_tags_kv ON resource_tags(key, value);
+
+-- Snapshots indexes
+CREATE INDEX IF NOT EXISTS idx_snapshots_account ON snapshots(account_id);
+CREATE INDEX IF NOT EXISTS idx_snapshots_created ON snapshots(created_at);
+CREATE INDEX IF NOT EXISTS idx_snapshots_name ON snapshots(name);
+CREATE INDEX IF NOT EXISTS idx_snapshots_account_created ON snapshots(account_id, created_at DESC);
+
+-- Inventories indexes
+CREATE INDEX IF NOT EXISTS idx_inventories_account ON inventories(account_id);
+CREATE INDEX IF NOT EXISTS idx_inventories_name_account ON inventories(name, account_id);
+
+-- Audit indexes (for history queries and filtering)
+CREATE INDEX IF NOT EXISTS idx_audit_ops_timestamp ON audit_operations(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_audit_ops_account ON audit_operations(account_id);
+CREATE INDEX IF NOT EXISTS idx_audit_ops_account_timestamp ON audit_operations(account_id, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_audit_records_operation ON audit_records(operation_id);
+CREATE INDEX IF NOT EXISTS idx_audit_records_arn ON audit_records(resource_arn);
+CREATE INDEX IF NOT EXISTS idx_audit_records_type ON audit_records(resource_type);
+CREATE INDEX IF NOT EXISTS idx_audit_records_region ON audit_records(region);
+CREATE INDEX IF NOT EXISTS idx_audit_records_status ON audit_records(status);
+
+-- Saved queries indexes
+CREATE INDEX IF NOT EXISTS idx_queries_category ON saved_queries(category);
+CREATE INDEX IF NOT EXISTS idx_queries_favorite ON saved_queries(is_favorite);
+CREATE INDEX IF NOT EXISTS idx_queries_last_run ON saved_queries(last_run_at DESC);
+
+-- Saved filters indexes
+CREATE INDEX IF NOT EXISTS idx_filters_favorite ON saved_filters(is_favorite);
+CREATE INDEX IF NOT EXISTS idx_filters_last_used ON saved_filters(last_used_at DESC);
+
+-- Saved views indexes
+CREATE INDEX IF NOT EXISTS idx_views_default ON saved_views(is_default);
+CREATE INDEX IF NOT EXISTS idx_views_favorite ON saved_views(is_favorite);
+CREATE INDEX IF NOT EXISTS idx_views_last_used ON saved_views(last_used_at DESC);
+
+-- Resource groups indexes
+CREATE INDEX IF NOT EXISTS idx_groups_name ON resource_groups(name);
+CREATE INDEX IF NOT EXISTS idx_groups_favorite ON resource_groups(is_favorite);
+CREATE INDEX IF NOT EXISTS idx_groups_created ON resource_groups(created_at DESC);
+
+-- Resource group members indexes
+CREATE INDEX IF NOT EXISTS idx_group_members_group ON resource_group_members(group_id);
+CREATE INDEX IF NOT EXISTS idx_group_members_name_type ON resource_group_members(resource_name, resource_type);
+CREATE INDEX IF NOT EXISTS idx_group_members_strategy ON resource_group_members(match_strategy);
+"""
+
+
+MIGRATIONS = {
+    "1.1.0": [
+        # Add canonical_name column to resources table
+        "ALTER TABLE resources ADD COLUMN canonical_name TEXT",
+        # Add match_strategy column to resource_group_members table
+        "ALTER TABLE resource_group_members ADD COLUMN match_strategy TEXT DEFAULT 'physical_name'",
+        # Backfill canonical_name from CloudFormation logical-id tag
+        """
+        UPDATE resources
+        SET canonical_name = (
+            SELECT value FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'aws:cloudformation:logical-id'
+        )
+        WHERE canonical_name IS NULL
+        """,
+        # Fallback to physical name for resources without CloudFormation tag
+        """
+        UPDATE resources
+        SET canonical_name = COALESCE(name, arn)
+        WHERE canonical_name IS NULL
+        """,
+    ],
+    "1.2.0": [
+        # Add normalized_name column for pattern-stripped names
+        "ALTER TABLE resources ADD COLUMN normalized_name TEXT",
+        # Add extracted_patterns column for storing what was stripped (JSON)
+        "ALTER TABLE resources ADD COLUMN extracted_patterns TEXT",
+        # Add normalization_method column for tracking how normalization was done
+        "ALTER TABLE resources ADD COLUMN normalization_method TEXT",
+        # Backfill normalized_name from CloudFormation logical-id tag
+        """
+        UPDATE resources
+        SET normalized_name = (
+            SELECT value FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'aws:cloudformation:logical-id'
+        ),
+        normalization_method = 'tag:logical-id'
+        WHERE normalized_name IS NULL
+        AND EXISTS (
+            SELECT 1 FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'aws:cloudformation:logical-id'
+        )
+        """,
+        # Backfill from Name tag
+        """
+        UPDATE resources
+        SET normalized_name = (
+            SELECT value FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'Name'
+        ),
+        normalization_method = 'tag:Name'
+        WHERE normalized_name IS NULL
+        AND EXISTS (
+            SELECT 1 FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'Name'
+        )
+        """,
+        # Fallback to physical name (pattern extraction needs Python, done on re-snapshot)
+        """
+        UPDATE resources
+        SET normalized_name = COALESCE(name, arn),
+            normalization_method = 'none'
+        WHERE normalized_name IS NULL
+        """,
+    ],
+}
+
+
+def get_schema_sql() -> str:
+    """Get the full schema SQL."""
+    return SCHEMA_SQL
+
+
+def get_indexes_sql() -> str:
+    """Get the indexes SQL."""
+    return INDEXES_SQL
+
+
+def get_migrations() -> dict:
+    """Get the migrations dictionary.
+
+    Returns:
+        Dict mapping version strings to lists of SQL statements
+    """
+    return MIGRATIONS

src/storage/snapshot_store.py

@@ -0,0 +1,363 @@
+"""Snapshot storage operations for SQLite backend."""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..matching import ResourceNormalizer
+from ..models.resource import Resource
+from ..models.snapshot import Snapshot
+from .database import Database, json_deserialize, json_serialize
+
+logger = logging.getLogger(__name__)
+
+
+def compute_canonical_name(name: str, tags: Optional[Dict[str, str]], arn: str) -> str:
+    """Compute canonical name for a resource.
+
+    Priority order:
+    1. aws:cloudformation:logical-id tag (stable across recreations)
+    2. Resource name
+    3. ARN as fallback
+
+    Args:
+        name: Resource physical name
+        tags: Resource tags
+        arn: Resource ARN
+
+    Returns:
+        Canonical name for matching
+    """
+    if tags and "aws:cloudformation:logical-id" in tags:
+        return tags["aws:cloudformation:logical-id"]
+    return name or arn
+
+
+class SnapshotStore:
+    """CRUD operations for snapshots in SQLite database."""
+
+    def __init__(self, db: Database):
+        """Initialize snapshot store.
+
+        Args:
+            db: Database connection manager
+        """
+        self.db = db
+
+    def save(self, snapshot: Snapshot) -> int:
+        """Save snapshot and all its resources to database.
+
+        Args:
+            snapshot: Snapshot to save
+
+        Returns:
+            Database ID of saved snapshot
+        """
+        # Create normalizer for computing normalized names
+        normalizer = ResourceNormalizer()
+
+        with self.db.transaction() as cursor:
+            # Insert snapshot
+            cursor.execute(
+                """
+                INSERT INTO snapshots (
+                    name, created_at, account_id, regions, resource_count,
+                    total_resources_before_filter, service_counts, metadata,
+                    filters_applied, schema_version, inventory_name, is_active
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    snapshot.name,
+                    snapshot.created_at.isoformat(),
+                    snapshot.account_id,
+                    json_serialize(snapshot.regions),
+                    snapshot.resource_count,
+                    snapshot.total_resources_before_filter,
+                    json_serialize(snapshot.service_counts),
+                    json_serialize(snapshot.metadata),
+                    json_serialize(snapshot.filters_applied),
+                    snapshot.schema_version,
+                    snapshot.inventory_name,
+                    snapshot.is_active,
+                ),
+            )
+            snapshot_id = cursor.lastrowid
+
+            # Insert resources
+            for resource in snapshot.resources:
+                # Compute canonical name (for backward compatibility)
+                canonical = compute_canonical_name(resource.name, resource.tags, resource.arn)
+
+                # Compute normalized name with pattern extraction
+                norm_result = normalizer.normalize_single(
+                    resource.name,
+                    resource.resource_type,
+                    resource.tags,
+                )
+
+                cursor.execute(
+                    """
+                    INSERT INTO resources (
+                        snapshot_id, arn, resource_type, name, region,
+                        config_hash, raw_config, created_at, source, canonical_name,
+                        normalized_name, extracted_patterns, normalization_method
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        snapshot_id,
+                        resource.arn,
+                        resource.resource_type,
+                        resource.name,
+                        resource.region,
+                        resource.config_hash,
+                        json_serialize(resource.raw_config),
+                        resource.created_at.isoformat() if resource.created_at else None,
+                        resource.source,
+                        canonical,
+                        norm_result.normalized_name,
+                        json_serialize(norm_result.extracted_patterns),
+                        norm_result.method,
+                    ),
+                )
+                resource_id = cursor.lastrowid
+
+                # Insert tags
+                if resource.tags:
+                    tag_data = [(resource_id, k, v) for k, v in resource.tags.items()]
+                    cursor.executemany(
+                        "INSERT INTO resource_tags (resource_id, key, value) VALUES (?, ?, ?)",
+                        tag_data,
+                    )
+
+            logger.debug(f"Saved snapshot '{snapshot.name}' with {len(snapshot.resources)} resources (id={snapshot_id})")
+            return snapshot_id
+
+    def load(self, name: str) -> Optional[Snapshot]:
+        """Load snapshot by name with all resources.
+
+        Args:
+            name: Snapshot name
+
+        Returns:
+            Snapshot object or None if not found
+        """
+        # Get snapshot
+        snapshot_row = self.db.fetchone("SELECT * FROM snapshots WHERE name = ?", (name,))
+        if not snapshot_row:
+            return None
+
+        snapshot_id = snapshot_row["id"]
+
+        # Get resources
+        resource_rows = self.db.fetchall(
+            "SELECT * FROM resources WHERE snapshot_id = ?",
+            (snapshot_id,),
+        )
+
+        # Get tags for all resources in one query
+        resource_ids = [r["id"] for r in resource_rows]
+        tags_by_resource: Dict[int, Dict[str, str]] = {}
+
+        if resource_ids:
+            placeholders = ",".join("?" * len(resource_ids))
+            tag_rows = self.db.fetchall(
+                f"SELECT resource_id, key, value FROM resource_tags WHERE resource_id IN ({placeholders})",
+                tuple(resource_ids),
+            )
+            for tag_row in tag_rows:
+                rid = tag_row["resource_id"]
+                if rid not in tags_by_resource:
+                    tags_by_resource[rid] = {}
+                tags_by_resource[rid][tag_row["key"]] = tag_row["value"]
+
+        # Build Resource objects
+        resources = []
+        for row in resource_rows:
+            created_at = None
+            if row["created_at"]:
+                try:
+                    created_at = datetime.fromisoformat(row["created_at"])
+                except ValueError:
+                    pass
+
+            resource = Resource(
+                arn=row["arn"],
+                resource_type=row["resource_type"],
+                name=row["name"],
+                region=row["region"],
+                config_hash=row["config_hash"],
+                raw_config=json_deserialize(row["raw_config"]),
+                tags=tags_by_resource.get(row["id"], {}),
+                created_at=created_at,
+                source=row["source"] or "direct_api",
+            )
+            resources.append(resource)
+
+        # Build Snapshot
+        created_at = datetime.fromisoformat(snapshot_row["created_at"])
+        if created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=timezone.utc)
+
+        snapshot = Snapshot(
+            name=snapshot_row["name"],
+            created_at=created_at,
+            account_id=snapshot_row["account_id"],
+            regions=json_deserialize(snapshot_row["regions"]) or [],
+            resources=resources,
+            is_active=bool(snapshot_row["is_active"]),
+            resource_count=snapshot_row["resource_count"],
+            total_resources_before_filter=snapshot_row.get("total_resources_before_filter"),
+            service_counts=json_deserialize(snapshot_row["service_counts"]) or {},
+            metadata=json_deserialize(snapshot_row["metadata"]) or {},
+            filters_applied=json_deserialize(snapshot_row["filters_applied"]),
+            inventory_name=snapshot_row["inventory_name"] or "default",
+            schema_version=snapshot_row["schema_version"] or "1.1",
+        )
+
+        logger.debug(f"Loaded snapshot '{name}' with {len(resources)} resources")
+        return snapshot
+
+    def list_all(self) -> List[Dict[str, Any]]:
+        """List all snapshots with metadata (no resources).
+
+        Returns:
+            List of snapshot metadata dictionaries
+        """
+        rows = self.db.fetchall(
+            """
+            SELECT name, created_at, account_id, regions, resource_count,
+                   service_counts, is_active, inventory_name
+            FROM snapshots
+            ORDER BY created_at DESC
+            """
+        )
+
+        results = []
+        for row in rows:
+            created_at = datetime.fromisoformat(row["created_at"])
+            results.append(
+                {
+                    "name": row["name"],
+                    "created_at": created_at,
+                    "account_id": row["account_id"],
+                    "regions": json_deserialize(row["regions"]) or [],
+                    "resource_count": row["resource_count"],
+                    "service_counts": json_deserialize(row["service_counts"]) or {},
+                    "is_active": bool(row["is_active"]),
+                    "inventory_name": row["inventory_name"],
+                }
+            )
+
+        return results
+
+    def delete(self, name: str) -> bool:
+        """Delete snapshot and cascade to resources.
+
+        Args:
+            name: Snapshot name to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        with self.db.transaction() as cursor:
+            cursor.execute("DELETE FROM snapshots WHERE name = ?", (name,))
+            deleted = cursor.rowcount > 0
+
+        if deleted:
+            logger.debug(f"Deleted snapshot '{name}'")
+        return deleted
+
+    def exists(self, name: str) -> bool:
+        """Check if snapshot exists.
+
+        Args:
+            name: Snapshot name
+
+        Returns:
+            True if exists
+        """
+        row = self.db.fetchone("SELECT 1 FROM snapshots WHERE name = ?", (name,))
+        return row is not None
+
+    def rename(self, old_name: str, new_name: str) -> bool:
+        """Rename a snapshot.
+
+        Args:
+            old_name: Current snapshot name
+            new_name: New snapshot name
+
+        Returns:
+            True if renamed, False if old_name not found
+
+        Raises:
+            ValueError: If new_name already exists
+        """
+        if not self.exists(old_name):
+            return False
+
+        if self.exists(new_name):
+            raise ValueError(f"Snapshot '{new_name}' already exists")
+
+        with self.db.transaction() as cursor:
+            cursor.execute(
+                "UPDATE snapshots SET name = ? WHERE name = ?",
+                (new_name, old_name),
+            )
+
+        logger.debug(f"Renamed snapshot '{old_name}' to '{new_name}'")
+        return True
+
+    def get_active(self) -> Optional[str]:
+        """Get name of active snapshot.
+
+        Returns:
+            Active snapshot name or None
+        """
+        row = self.db.fetchone("SELECT name FROM snapshots WHERE is_active = 1")
+        return row["name"] if row else None
+
+    def set_active(self, name: str) -> None:
+        """Set snapshot as active baseline.
+
+        Args:
+            name: Snapshot name to set as active
+        """
+        with self.db.transaction() as cursor:
+            # Clear previous active
+            cursor.execute("UPDATE snapshots SET is_active = 0 WHERE is_active = 1")
+            # Set new active
+            cursor.execute("UPDATE snapshots SET is_active = 1 WHERE name = ?", (name,))
+
+        logger.debug(f"Set active snapshot: '{name}'")
+
+    def get_id(self, name: str) -> Optional[int]:
+        """Get database ID for snapshot.
+
+        Args:
+            name: Snapshot name
+
+        Returns:
+            Database ID or None
+        """
+        row = self.db.fetchone("SELECT id FROM snapshots WHERE name = ?", (name,))
+        return row["id"] if row else None
+
+    def get_resource_count(self) -> int:
+        """Get total resource count across all snapshots.
+
+        Returns:
+            Total resource count
+        """
+        row = self.db.fetchone("SELECT COUNT(*) as count FROM resources")
+        return row["count"] if row else 0
+
+    def get_snapshot_count(self) -> int:
+        """Get total snapshot count.
+
+        Returns:
+            Snapshot count
+        """
+        row = self.db.fetchone("SELECT COUNT(*) as count FROM snapshots")
+        return row["count"] if row else 0