Apply linter autofixes: internal/snapshot (refs #61)

2026-08-07 16:53:23 +00:00
parent bec964fc20
commit 1e05fa0dd7
11 changed files with 452 additions and 97 deletions
--- a/internal/snapshot/snapshot.go
+++ b/internal/snapshot/snapshot.go
@@ -37,6 +37,8 @@ import (
 	"bytes"
 	"context"
 	"database/sql"
+	"encoding/hex"
+	"errors"
 	"fmt"
 	"io"
 	"os/exec"
@@ -97,12 +99,13 @@ func (sm *SnapshotManager) CreateSnapshot(ctx context.Context, hostname, version
 func (sm *SnapshotManager) CreateSnapshotWithName(ctx context.Context, hostname, name, version, gitRevision string) (string, error) {
 	// Use short hostname (strip domain if present)
 	shortHostname := hostname
-	if idx := strings.Index(hostname, "."); idx != -1 {
-		shortHostname = hostname[:idx]
+	if before, _, ok := strings.Cut(hostname, "."); ok {
+		shortHostname = before
 	}

 	// Build snapshot ID with optional name
 	timestamp := time.Now().UTC().Format("2006-01-02T15:04:05Z")
+
 	var snapshotID string
 	if name != "" {
 		snapshotID = fmt.Sprintf("%s_%s_%s", shortHostname, name, timestamp)
@@ -128,12 +131,12 @@ func (sm *SnapshotManager) CreateSnapshotWithName(ctx context.Context, hostname,
 	err := sm.repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		return sm.repos.Snapshots.Create(ctx, tx, snapshot)
 	})
-
 	if err != nil {
 		return "", fmt.Errorf("creating snapshot: %w", err)
 	}

 	log.Info("Created snapshot", "snapshot_id", snapshotID)
+
 	return snapshotID, nil
 }

@@ -148,7 +151,6 @@ func (sm *SnapshotManager) UpdateSnapshotStats(ctx context.Context, snapshotID s
 			stats.BytesUploaded,
 		)
 	})
-
 	if err != nil {
 		return fmt.Errorf("updating snapshot stats: %w", err)
 	}
@@ -161,13 +163,14 @@ func (sm *SnapshotManager) UpdateSnapshotStats(ctx context.Context, snapshotID s
 func (sm *SnapshotManager) UpdateSnapshotStatsExtended(ctx context.Context, snapshotID string, stats ExtendedBackupStats) error {
 	return sm.repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		// First update basic stats
-		if err := sm.repos.Snapshots.UpdateCounts(ctx, tx, snapshotID,
+		err := sm.repos.Snapshots.UpdateCounts(ctx, tx, snapshotID,
 			int64(stats.FilesScanned),
 			int64(stats.ChunksCreated),
 			int64(stats.BlobsCreated),
 			stats.BytesScanned,
 			stats.BytesUploaded,
-		); err != nil {
+		)
+		if err != nil {
 			return err
 		}

@@ -190,18 +193,20 @@ func (sm *SnapshotManager) CompleteSnapshot(ctx context.Context, snapshotID stri
 		if err != nil {
 			return err
 		}
+
 		if added > 0 {
 			log.Info("Populated snapshot_blobs with dedup-referenced blobs",
 				"snapshot_id", snapshotID, "added", added)
 		}
+
 		return sm.repos.Snapshots.MarkComplete(ctx, tx, snapshotID)
 	})
-
 	if err != nil {
 		return fmt.Errorf("marking snapshot complete: %w", err)
 	}

 	log.Info("Completed snapshot", "snapshot_id", snapshotID)
+
 	return nil
 }

@@ -229,10 +234,13 @@ func (sm *SnapshotManager) ExportSnapshotMetadata(ctx context.Context, dbPath st
 	if err != nil {
 		return fmt.Errorf("creating temp dir: %w", err)
 	}
+
 	log.Debug("Created temporary directory", "path", tempDir)
 	defer func() {
 		log.Debug("Cleaning up temporary directory", "path", tempDir)
-		if err := sm.fs.RemoveAll(tempDir); err != nil {
+
+		err := sm.fs.RemoveAll(tempDir)
+		if err != nil {
 			log.Debug("Failed to remove temp dir", "path", tempDir, "error", err)
 		}
 	}()
@@ -258,6 +266,7 @@ func (sm *SnapshotManager) ExportSnapshotMetadata(ctx context.Context, dbPath st
 		"snapshot_id", snapshotID,
 		"db_size", len(finalData),
 		"manifest_size", len(blobManifest))
+
 	return nil
 }

@@ -268,17 +277,21 @@ func (sm *SnapshotManager) prepareExportDB(ctx context.Context, dbPath, snapshot
 	// The main database should be closed at this point
 	tempDBPath := filepath.Join(tempDir, "snapshot.db")
 	log.Debug("Copying database to temporary location", "source", dbPath, "destination", tempDBPath)
+
 	if err := sm.copyFile(dbPath, tempDBPath); err != nil {
 		return nil, "", fmt.Errorf("copying database: %w", err)
 	}
+
 	log.Debug("Database copy complete", "size", sm.getFileSize(tempDBPath))

 	// Step 2: Clean the temp database to only contain current snapshot data
 	log.Debug("Cleaning temporary database", "snapshot_id", snapshotID)
+
 	stats, err := sm.cleanSnapshotDB(ctx, tempDBPath, snapshotID)
 	if err != nil {
 		return nil, "", fmt.Errorf("cleaning snapshot database: %w", err)
 	}
+
 	log.Info("Temporary database cleanup complete",
 		"db_path", tempDBPath,
 		"size_after_clean", humanize.Bytes(uint64(sm.getFileSize(tempDBPath))),
@@ -294,6 +307,7 @@ func (sm *SnapshotManager) prepareExportDB(ctx context.Context, dbPath, snapshot
 	if err := sm.vacuumDatabase(tempDBPath); err != nil {
 		return nil, "", fmt.Errorf("vacuuming database: %w", err)
 	}
+
 	log.Debug("Database vacuumed", "size", humanize.Bytes(uint64(sm.getFileSize(tempDBPath))))

 	// Step 4: Compress and encrypt the binary database file
@@ -301,6 +315,7 @@ func (sm *SnapshotManager) prepareExportDB(ctx context.Context, dbPath, snapshot
 	if err := sm.compressFile(tempDBPath, compressedPath); err != nil {
 		return nil, "", fmt.Errorf("compressing database: %w", err)
 	}
+
 	log.Debug("Compression complete",
 		"original_size", humanize.Bytes(uint64(sm.getFileSize(tempDBPath))),
 		"compressed_size", humanize.Bytes(uint64(sm.getFileSize(compressedPath))))
@@ -327,9 +342,12 @@ func (sm *SnapshotManager) uploadSnapshotArtifacts(ctx context.Context, snapshot
 	dbKey := fmt.Sprintf("metadata/%s/db.zst.age", remoteKey)

 	dbUploadStart := time.Now()
-	if err := sm.storage.Put(ctx, dbKey, bytes.NewReader(dbData)); err != nil {
+
+	err := sm.storage.Put(ctx, dbKey, bytes.NewReader(dbData))
+	if err != nil {
 		return fmt.Errorf("uploading snapshot database: %w", err)
 	}
+
 	dbUploadDuration := time.Since(dbUploadStart)
 	dbUploadSpeed := float64(len(dbData)) * 8 / dbUploadDuration.Seconds() // bits per second
 	log.Info("Uploaded snapshot database",
@@ -341,9 +359,12 @@ func (sm *SnapshotManager) uploadSnapshotArtifacts(ctx context.Context, snapshot
 	// Upload blob manifest (compressed only, not encrypted)
 	manifestKey := fmt.Sprintf("metadata/%s/manifest.json.zst", remoteKey)
 	manifestUploadStart := time.Now()
-	if err := sm.storage.Put(ctx, manifestKey, bytes.NewReader(manifestData)); err != nil {
+
+	err = sm.storage.Put(ctx, manifestKey, bytes.NewReader(manifestData))
+	if err != nil {
 		return fmt.Errorf("uploading blob manifest: %w", err)
 	}
+
 	manifestUploadDuration := time.Since(manifestUploadStart)
 	manifestUploadSpeed := float64(len(manifestData)) * 8 / manifestUploadDuration.Seconds() // bits per second
 	log.Info("Uploaded blob manifest",
@@ -383,7 +404,8 @@ func (sm *SnapshotManager) cleanSnapshotDB(ctx context.Context, dbPath string, s
 		return nil, fmt.Errorf("opening temp database: %w", err)
 	}
 	defer func() {
-		if err := db.Close(); err != nil {
+		err := db.Close()
+		if err != nil {
 			log.Debug("Failed to close temp database", "error", err)
 		}
 	}()
@@ -394,7 +416,8 @@ func (sm *SnapshotManager) cleanSnapshotDB(ctx context.Context, dbPath string, s
 		return nil, fmt.Errorf("beginning transaction: %w", err)
 	}
 	defer func() {
-		if rbErr := tx.Rollback(); rbErr != nil && rbErr != sql.ErrTxDone {
+		rbErr := tx.Rollback()
+		if rbErr != nil && !errors.Is(rbErr, sql.ErrTxDone) {
 			log.Debug("Failed to rollback transaction", "error", rbErr)
 		}
 	}()
@@ -430,6 +453,7 @@ func (sm *SnapshotManager) cleanSnapshotDB(ctx context.Context, dbPath string, s

 	// Commit transaction
 	log.Debug("[Temp DB Cleanup] Committing cleanup transaction")
+
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("committing transaction: %w", err)
 	}
@@ -439,23 +463,30 @@ func (sm *SnapshotManager) cleanSnapshotDB(ctx context.Context, dbPath string, s

 	// Count files
 	var fileCount int
+
 	err = db.QueryRowWithLog(ctx, "SELECT COUNT(*) FROM files").Scan(&fileCount)
 	if err != nil {
 		return nil, fmt.Errorf("counting files: %w", err)
 	}
+
 	stats.FileCount = fileCount

 	// Count chunks
 	var chunkCount int
+
 	err = db.QueryRowWithLog(ctx, "SELECT COUNT(*) FROM chunks").Scan(&chunkCount)
 	if err != nil {
 		return nil, fmt.Errorf("counting chunks: %w", err)
 	}
+
 	stats.ChunkCount = chunkCount

 	// Count blobs and get sizes
-	var blobCount int
-	var compressedSize, uncompressedSize sql.NullInt64
+	var (
+		blobCount                        int
+		compressedSize, uncompressedSize sql.NullInt64
+	)
+
 	err = db.QueryRowWithLog(ctx, `
 		SELECT COUNT(*), COALESCE(SUM(compressed_size), 0), COALESCE(SUM(uncompressed_size), 0) 
 		FROM blobs 
@@ -464,6 +495,7 @@ func (sm *SnapshotManager) cleanSnapshotDB(ctx context.Context, dbPath string, s
 	if err != nil {
 		return nil, fmt.Errorf("counting blobs and sizes: %w", err)
 	}
+
 	stats.BlobCount = blobCount
 	stats.CompressedSize = compressedSize.Int64
 	stats.UncompressedSize = uncompressedSize.Int64
@@ -491,7 +523,8 @@ func (sm *SnapshotManager) compressFile(inputPath, outputPath string) error {
 		return fmt.Errorf("opening input file: %w", err)
 	}
 	defer func() {
-		if err := input.Close(); err != nil {
+		err := input.Close()
+		if err != nil {
 			log.Debug("Failed to close input file", "path", inputPath, "error", err)
 		}
 	}()
@@ -501,13 +534,15 @@ func (sm *SnapshotManager) compressFile(inputPath, outputPath string) error {
 		return fmt.Errorf("creating output file: %w", err)
 	}
 	defer func() {
-		if err := output.Close(); err != nil {
+		err := output.Close()
+		if err != nil {
 			log.Debug("Failed to close output file", "path", outputPath, "error", err)
 		}
 	}()

 	// Use blobgen for compression and encryption
 	log.Debug("Compressing and encrypting data")
+
 	writer, err := blobgen.NewWriter(output, sm.config.CompressionLevel, sm.config.AgeRecipients)
 	if err != nil {
 		return fmt.Errorf("creating blobgen writer: %w", err)
@@ -517,7 +552,8 @@ func (sm *SnapshotManager) compressFile(inputPath, outputPath string) error {
 	writerClosed := false
 	defer func() {
 		if !writerClosed {
-			if err := writer.Close(); err != nil {
+			err := writer.Close()
+			if err != nil {
 				log.Debug("Failed to close writer", "error", err)
 			}
 		}
@@ -531,9 +567,10 @@ func (sm *SnapshotManager) compressFile(inputPath, outputPath string) error {
 	if err := writer.Close(); err != nil {
 		return fmt.Errorf("closing writer: %w", err)
 	}
+
 	writerClosed = true

-	log.Debug("Compression complete", "hash", fmt.Sprintf("%x", writer.Sum256()))
+	log.Debug("Compression complete", "hash", hex.EncodeToString(writer.Sum256()))

 	return nil
 }
@@ -541,34 +578,42 @@ func (sm *SnapshotManager) compressFile(inputPath, outputPath string) error {
 // copyFile copies a file from src to dst
 func (sm *SnapshotManager) copyFile(src, dst string) error {
 	log.Debug("Opening source file for copy", "path", src)
+
 	sourceFile, err := sm.fs.Open(src)
 	if err != nil {
 		return err
 	}
 	defer func() {
 		log.Debug("Closing source file", "path", src)
-		if err := sourceFile.Close(); err != nil {
+
+		err := sourceFile.Close()
+		if err != nil {
 			log.Debug("Failed to close source file", "path", src, "error", err)
 		}
 	}()

 	log.Debug("Creating destination file", "path", dst)
+
 	destFile, err := sm.fs.Create(dst)
 	if err != nil {
 		return err
 	}
 	defer func() {
 		log.Debug("Closing destination file", "path", dst)
-		if err := destFile.Close(); err != nil {
+
+		err := destFile.Close()
+		if err != nil {
 			log.Debug("Failed to close destination file", "path", dst, "error", err)
 		}
 	}()

 	log.Debug("Copying file data")
+
 	n, err := io.Copy(destFile, sourceFile)
 	if err != nil {
 		return err
 	}
+
 	log.Debug("File copy complete", "bytes_copied", n)

 	return nil
@@ -576,7 +621,6 @@ func (sm *SnapshotManager) copyFile(src, dst string) error {

 // generateBlobManifest creates a compressed JSON list of all blobs in the snapshot
 func (sm *SnapshotManager) generateBlobManifest(ctx context.Context, dbPath string, snapshotID string) ([]byte, error) {
-
 	// Open the cleaned database using the database package
 	db, err := database.New(ctx, dbPath)
 	if err != nil {
@@ -589,10 +633,12 @@ func (sm *SnapshotManager) generateBlobManifest(ctx context.Context, dbPath stri

 	// Get all blobs for this snapshot
 	log.Debug("Querying blobs for snapshot", "snapshot_id", snapshotID)
+
 	blobHashes, err := repos.Snapshots.GetBlobHashes(ctx, snapshotID)
 	if err != nil {
 		return nil, fmt.Errorf("getting snapshot blobs: %w", err)
 	}
+
 	log.Debug("Found blobs", "count", len(blobHashes))

 	// Get blob details including sizes
@@ -603,8 +649,10 @@ func (sm *SnapshotManager) generateBlobManifest(ctx context.Context, dbPath stri
 		blob, err := repos.Blobs.GetByHash(ctx, hash)
 		if err != nil {
 			log.Warn("Failed to get blob details", "hash", hash, "error", err)
+
 			continue
 		}
+
 		if blob != nil {
 			blobs = append(blobs, BlobInfo{
 				Hash:           hash,
@@ -648,6 +696,7 @@ func (sm *SnapshotManager) getFileSize(path string) int64 {
 	if err != nil {
 		return -1
 	}
+
 	return info.Size()
 }

@@ -663,6 +712,7 @@ type BackupStats struct {
 // ExtendedBackupStats contains additional statistics for comprehensive tracking
 type ExtendedBackupStats struct {
 	BackupStats
+
 	BlobUncompressedSize int64 // Total uncompressed size of all referenced blobs
 	CompressionLevel     int   // Compression level used for this snapshot
 	UploadDurationMs     int64 // Total milliseconds spent uploading to S3
@@ -682,6 +732,7 @@ func (sm *SnapshotManager) CleanupIncompleteSnapshots(ctx context.Context, hostn

 	if len(incompleteSnapshots) == 0 {
 		log.Debug("No incomplete snapshots found")
+
 		return nil
 	}

@@ -692,14 +743,15 @@ func (sm *SnapshotManager) CleanupIncompleteSnapshots(ctx context.Context, hostn
 		// Check if metadata exists in storage (paths use the hashed
 		// remote key so we don't leak host info to the listing).
 		metadataKey := fmt.Sprintf("metadata/%s/db.zst", RemoteSnapshotKey(snapshot.ID.String()))
-		_, err := sm.storage.Stat(ctx, metadataKey)

+		_, err := sm.storage.Stat(ctx, metadataKey)
 		if err != nil {
 			// Metadata doesn't exist in S3 - this is an incomplete snapshot
 			log.Info("Cleaning up incomplete snapshot record", "snapshot_id", snapshot.ID, "started_at", snapshot.StartedAt)

 			// Delete the snapshot and all its associations
-			if err := sm.deleteSnapshot(ctx, snapshot.ID.String()); err != nil {
+			err := sm.deleteSnapshot(ctx, snapshot.ID.String())
+			if err != nil {
 				return fmt.Errorf("deleting incomplete snapshot %s: %w", snapshot.ID, err)
 			}

@@ -708,7 +760,9 @@ func (sm *SnapshotManager) CleanupIncompleteSnapshots(ctx context.Context, hostn
 			// Metadata exists - this snapshot was completed but database wasn't updated
 			// This shouldn't happen in normal operation, but mark it complete
 			log.Warn("Found snapshot with remote metadata but incomplete in database", "snapshot_id", snapshot.ID)
-			if err := sm.repos.Snapshots.MarkComplete(ctx, nil, snapshot.ID.String()); err != nil {
+
+			err := sm.repos.Snapshots.MarkComplete(ctx, nil, snapshot.ID.String())
+			if err != nil {
 				log.Error("Failed to mark snapshot as complete in database", "snapshot_id", snapshot.ID, "error", err)
 			}
 		}
@@ -720,28 +774,34 @@ func (sm *SnapshotManager) CleanupIncompleteSnapshots(ctx context.Context, hostn
 // deleteSnapshot removes a snapshot and all its associations from the database
 func (sm *SnapshotManager) deleteSnapshot(ctx context.Context, snapshotID string) error {
 	// Delete snapshot_files entries
-	if err := sm.repos.Snapshots.DeleteSnapshotFiles(ctx, snapshotID); err != nil {
+	err := sm.repos.Snapshots.DeleteSnapshotFiles(ctx, snapshotID)
+	if err != nil {
 		return fmt.Errorf("deleting snapshot files: %w", err)
 	}

 	// Delete snapshot_blobs entries
-	if err := sm.repos.Snapshots.DeleteSnapshotBlobs(ctx, snapshotID); err != nil {
+	err = sm.repos.Snapshots.DeleteSnapshotBlobs(ctx, snapshotID)
+	if err != nil {
 		return fmt.Errorf("deleting snapshot blobs: %w", err)
 	}

 	// Delete uploads entries (has foreign key to snapshots without CASCADE)
-	if err := sm.repos.Snapshots.DeleteSnapshotUploads(ctx, snapshotID); err != nil {
+	err = sm.repos.Snapshots.DeleteSnapshotUploads(ctx, snapshotID)
+	if err != nil {
 		return fmt.Errorf("deleting snapshot uploads: %w", err)
 	}

 	// Delete the snapshot itself
-	if err := sm.repos.Snapshots.Delete(ctx, snapshotID); err != nil {
+	err = sm.repos.Snapshots.Delete(ctx, snapshotID)
+	if err != nil {
 		return fmt.Errorf("deleting snapshot: %w", err)
 	}

 	// Clean up orphaned data
 	log.Debug("Cleaning up orphaned records in main database")
-	if err := sm.CleanupOrphanedData(ctx); err != nil {
+
+	err = sm.CleanupOrphanedData(ctx)
+	if err != nil {
 		return fmt.Errorf("cleaning up orphaned data: %w", err)
 	}

@@ -759,28 +819,36 @@ func (sm *SnapshotManager) CleanupOrphanedData(ctx context.Context) error {

 	// Delete orphaned files (files not in any snapshot)
 	log.Debug("Deleting orphaned file records from database")
-	if err := sm.repos.Files.DeleteOrphaned(ctx); err != nil {
+
+	err := sm.repos.Files.DeleteOrphaned(ctx)
+	if err != nil {
 		return fmt.Errorf("deleting orphaned files: %w", err)
 	}

 	// Delete orphaned blobs (blobs not in any snapshot)
 	// This will cascade delete blob_chunks for deleted blobs
 	log.Debug("Deleting orphaned blob records from database")
-	if err := sm.repos.Blobs.DeleteOrphaned(ctx); err != nil {
+
+	err = sm.repos.Blobs.DeleteOrphaned(ctx)
+	if err != nil {
 		return fmt.Errorf("deleting orphaned blobs: %w", err)
 	}

 	// Delete orphaned blob_chunks entries
 	// This handles cases where the blob still exists but chunks were deleted
 	log.Debug("Deleting orphaned blob_chunks associations from database")
-	if err := sm.repos.BlobChunks.DeleteOrphaned(ctx); err != nil {
+
+	err = sm.repos.BlobChunks.DeleteOrphaned(ctx)
+	if err != nil {
 		return fmt.Errorf("deleting orphaned blob_chunks: %w", err)
 	}

 	// Delete orphaned chunks (chunks not referenced by any file)
 	// This must come after cleaning up blob_chunks to avoid foreign key violations
 	log.Debug("Deleting orphaned chunk records from database")
-	if err := sm.repos.Chunks.DeleteOrphaned(ctx); err != nil {
+
+	err = sm.repos.Chunks.DeleteOrphaned(ctx)
+	if err != nil {
 		return fmt.Errorf("deleting orphaned chunks: %w", err)
 	}

@@ -793,21 +861,26 @@ func (sm *SnapshotManager) deleteOtherSnapshots(ctx context.Context, tx *sql.Tx,

 	// First delete uploads that reference other snapshots (no CASCADE DELETE on this FK)
 	database.LogSQL("Execute", "DELETE FROM uploads WHERE snapshot_id != ?", currentSnapshotID)
+
 	uploadResult, err := tx.ExecContext(ctx, "DELETE FROM uploads WHERE snapshot_id != ?", currentSnapshotID)
 	if err != nil {
 		return fmt.Errorf("deleting uploads for other snapshots: %w", err)
 	}
+
 	uploadsDeleted, _ := uploadResult.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted upload records", "count", uploadsDeleted)

 	// Now we can safely delete the snapshots
 	database.LogSQL("Execute", "DELETE FROM snapshots WHERE id != ?", currentSnapshotID)
+
 	result, err := tx.ExecContext(ctx, "DELETE FROM snapshots WHERE id != ?", currentSnapshotID)
 	if err != nil {
 		return fmt.Errorf("deleting other snapshots: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted snapshot records from database", "count", rowsAffected)
+
 	return nil
 }

@@ -816,22 +889,27 @@ func (sm *SnapshotManager) deleteOrphanedSnapshotAssociations(ctx context.Contex
 	// Delete orphaned snapshot_files
 	log.Debug("[Temp DB Cleanup] Deleting orphaned snapshot_files associations")
 	database.LogSQL("Execute", "DELETE FROM snapshot_files WHERE snapshot_id != ?", currentSnapshotID)
+
 	result, err := tx.ExecContext(ctx, "DELETE FROM snapshot_files WHERE snapshot_id != ?", currentSnapshotID)
 	if err != nil {
 		return fmt.Errorf("deleting orphaned snapshot_files: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted snapshot_files associations", "count", rowsAffected)

 	// Delete orphaned snapshot_blobs
 	log.Debug("[Temp DB Cleanup] Deleting orphaned snapshot_blobs associations")
 	database.LogSQL("Execute", "DELETE FROM snapshot_blobs WHERE snapshot_id != ?", currentSnapshotID)
+
 	result, err = tx.ExecContext(ctx, "DELETE FROM snapshot_blobs WHERE snapshot_id != ?", currentSnapshotID)
 	if err != nil {
 		return fmt.Errorf("deleting orphaned snapshot_blobs: %w", err)
 	}
+
 	rowsAffected, _ = result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted snapshot_blobs associations", "count", rowsAffected)
+
 	return nil
 }

@@ -839,6 +917,7 @@ func (sm *SnapshotManager) deleteOrphanedSnapshotAssociations(ctx context.Contex
 func (sm *SnapshotManager) deleteOrphanedFiles(ctx context.Context, tx *sql.Tx, currentSnapshotID string) error {
 	log.Debug("[Temp DB Cleanup] Deleting file records not referenced by current snapshot")
 	database.LogSQL("Execute", `DELETE FROM files WHERE NOT EXISTS (SELECT 1 FROM snapshot_files WHERE snapshot_files.file_id = files.id AND snapshot_files.snapshot_id = ?)`, currentSnapshotID)
+
 	result, err := tx.ExecContext(ctx, `
 		DELETE FROM files 
 		WHERE NOT EXISTS (
@@ -849,11 +928,13 @@ func (sm *SnapshotManager) deleteOrphanedFiles(ctx context.Context, tx *sql.Tx,
 	if err != nil {
 		return fmt.Errorf("deleting orphaned files: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted file records from database", "count", rowsAffected)

 	// Note: file_chunks will be deleted via CASCADE
 	log.Debug("[Temp DB Cleanup] file_chunks associations deleted via CASCADE")
+
 	return nil
 }

@@ -861,6 +942,7 @@ func (sm *SnapshotManager) deleteOrphanedFiles(ctx context.Context, tx *sql.Tx,
 func (sm *SnapshotManager) deleteOrphanedChunkToFileMappings(ctx context.Context, tx *sql.Tx) error {
 	log.Debug("[Temp DB Cleanup] Deleting orphaned chunk_files associations")
 	database.LogSQL("Execute", `DELETE FROM chunk_files WHERE NOT EXISTS (SELECT 1 FROM files WHERE files.id = chunk_files.file_id)`)
+
 	result, err := tx.ExecContext(ctx, `
 		DELETE FROM chunk_files 
 		WHERE NOT EXISTS (
@@ -870,8 +952,10 @@ func (sm *SnapshotManager) deleteOrphanedChunkToFileMappings(ctx context.Context
 	if err != nil {
 		return fmt.Errorf("deleting orphaned chunk_files: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted chunk_files associations", "count", rowsAffected)
+
 	return nil
 }

@@ -879,6 +963,7 @@ func (sm *SnapshotManager) deleteOrphanedChunkToFileMappings(ctx context.Context
 func (sm *SnapshotManager) deleteOrphanedBlobs(ctx context.Context, tx *sql.Tx, currentSnapshotID string) error {
 	log.Debug("[Temp DB Cleanup] Deleting blob records not referenced by current snapshot")
 	database.LogSQL("Execute", `DELETE FROM blobs WHERE NOT EXISTS (SELECT 1 FROM snapshot_blobs WHERE snapshot_blobs.blob_hash = blobs.blob_hash AND snapshot_blobs.snapshot_id = ?)`, currentSnapshotID)
+
 	result, err := tx.ExecContext(ctx, `
 		DELETE FROM blobs 
 		WHERE NOT EXISTS (
@@ -889,8 +974,10 @@ func (sm *SnapshotManager) deleteOrphanedBlobs(ctx context.Context, tx *sql.Tx,
 	if err != nil {
 		return fmt.Errorf("deleting orphaned blobs: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted blob records from database", "count", rowsAffected)
+
 	return nil
 }

@@ -898,6 +985,7 @@ func (sm *SnapshotManager) deleteOrphanedBlobs(ctx context.Context, tx *sql.Tx,
 func (sm *SnapshotManager) deleteOrphanedBlobToChunkMappings(ctx context.Context, tx *sql.Tx) error {
 	log.Debug("[Temp DB Cleanup] Deleting orphaned blob_chunks associations")
 	database.LogSQL("Execute", `DELETE FROM blob_chunks WHERE NOT EXISTS (SELECT 1 FROM blobs WHERE blobs.id = blob_chunks.blob_id)`)
+
 	result, err := tx.ExecContext(ctx, `
 		DELETE FROM blob_chunks 
 		WHERE NOT EXISTS (
@@ -907,14 +995,17 @@ func (sm *SnapshotManager) deleteOrphanedBlobToChunkMappings(ctx context.Context
 	if err != nil {
 		return fmt.Errorf("deleting orphaned blob_chunks: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted blob_chunks associations", "count", rowsAffected)
+
 	return nil
 }

 // deleteOrphanedChunks deletes chunks not referenced by any file or blob
 func (sm *SnapshotManager) deleteOrphanedChunks(ctx context.Context, tx *sql.Tx) error {
 	log.Debug("[Temp DB Cleanup] Deleting orphaned chunk records")
+
 	query := `
 		DELETE FROM chunks 
 		WHERE NOT EXISTS (
@@ -926,11 +1017,14 @@ func (sm *SnapshotManager) deleteOrphanedChunks(ctx context.Context, tx *sql.Tx)
 			WHERE blob_chunks.chunk_hash = chunks.chunk_hash
 		)`
 	database.LogSQL("Execute", query)
+
 	result, err := tx.ExecContext(ctx, query)
 	if err != nil {
 		return fmt.Errorf("deleting orphaned chunks: %w", err)
 	}
+
 	rowsAffected, _ := result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted chunk records from database", "count", rowsAffected)
+
 	return nil
 }