Count each file, byte and upload once in backup statistics (closes #225)

The scanner added a changed file's bytes again for each new chunk and
counted a file as unchanged for each chunk already stored. It now
counts files and bytes once, in the scan phase, and counts its own
uploads, so a --cron run, which has no progress reporter, records
them. The blob count no longer adds earlier paths' blobs again.

The snapshots row now stores the size of all files in total_size and
the referenced blobs' sizes in blob_size, blob_uncompressed_size and
compression_ratio, as docs/DATAMODEL.md says. Those sizes come from
one query, and a failed query fails the snapshot. DATAMODEL.md now
says chunk_count and blob_count count what the run added.

Removed the uncalled UpdateSnapshotStats.

Model: opus-5-5

internal/database/models.go

@@ -99,8 +99,8 @@ type Snapshot struct {
 	StartedAt          time.Time
 	CompletedAt        *time.Time // nil if still in progress
 	FileCount          int64
-	ChunkCount         int64
-	BlobCount          int64
+	ChunkCount         int64 // Chunks this snapshot stored that were not stored before
+	BlobCount          int64 // Blobs this snapshot created
 	TotalSize          int64 // Total size of all referenced files
 
 	// BlobSize is the total size of all referenced blobs (compressed and

internal/database/snapshots.go

@@ -127,6 +127,7 @@ func (r *SnapshotRepository) UpdateExtendedStats(
 	snapshotID string,
 	blobUncompressedSize int64,
 	compressionLevel int,
+	uploadBytes int64,
 	uploadDurationMs int64,
 ) error {
 	compressionRatio, err := r.extendedCompressionRatio(
@@ -141,7 +142,7 @@ func (r *SnapshotRepository) UpdateExtendedStats(
 		SET blob_uncompressed_size = ?,
 		    compression_ratio = ?,
 		    compression_level = ?,
-		    upload_bytes = blob_size,
+		    upload_bytes = ?,
 		    upload_duration_ms = ?
 		WHERE id = ?
 	`
@@ -149,11 +150,11 @@ func (r *SnapshotRepository) UpdateExtendedStats(
 	if tx != nil {
 		_, err = tx.ExecContext(ctx, query,
 			blobUncompressedSize, compressionRatio, compressionLevel,
-			uploadDurationMs, snapshotID)
+			uploadBytes, uploadDurationMs, snapshotID)
 	} else {
 		_, err = r.db.ExecWithLog(ctx, query,
 			blobUncompressedSize, compressionRatio, compressionLevel,
-			uploadDurationMs, snapshotID)
+			uploadBytes, uploadDurationMs, snapshotID)
 	}
 
 	if err != nil {
@@ -543,6 +544,30 @@ func (r *SnapshotRepository) GetSnapshotTotalCompressedSize(
 	return totalSize, nil
 }
 
+// GetSnapshotBlobSizes returns the total compressed and uncompressed sizes
+// of all blobs referenced by a snapshot.
+func (r *SnapshotRepository) GetSnapshotBlobSizes(
+	ctx context.Context, snapshotID string,
+) (int64, int64, error) {
+	query := `
+		SELECT COALESCE(SUM(b.compressed_size), 0),
+			COALESCE(SUM(b.uncompressed_size), 0)
+		FROM snapshot_blobs sb
+		JOIN blobs b ON sb.blob_hash = b.blob_hash
+		WHERE sb.snapshot_id = ?
+	`
+
+	var compressed, uncompressed int64
+
+	err := r.db.conn.QueryRowContext(ctx, query, snapshotID).Scan(
+		&compressed, &uncompressed)
+	if err != nil {
+		return 0, 0, fmt.Errorf("querying snapshot blob sizes: %w", err)
+	}
+
+	return compressed, uncompressed, nil
+}
+
 // GetSnapshotUncompressedChunkSize returns the sum of plaintext sizes of all unique
 // chunks referenced by a snapshot (via snapshot_files → file_chunks → chunks).
 func (r *SnapshotRepository) GetSnapshotUncompressedChunkSize(

internal/database/snapshots_test.go

@@ -145,6 +145,65 @@ func TestSnapshotRepositoryUpdateCounts(t *testing.T) {
 	}
 }
 
+// GetSnapshotBlobSizes totals the blobs the snapshot references, and only
+// those.
+func TestSnapshotRepositoryGetSnapshotBlobSizes(t *testing.T) {
+	t.Parallel()
+
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repos := database.NewRepositories(db)
+
+	snapshot := &database.Snapshot{
+		ID:             "2024-01-03T12:00:00Z",
+		Hostname:       testHostname,
+		VaultikVersion: testVersion,
+		StartedAt:      time.Now().Truncate(time.Second),
+	}
+
+	err := repos.Snapshots.Create(ctx, nil, snapshot)
+	if err != nil {
+		t.Fatalf("failed to create snapshot: %v", err)
+	}
+
+	blobs := []*database.Blob{
+		{Hash: "referenced-1", CompressedSize: 10, UncompressedSize: 100},
+		{Hash: "referenced-2", CompressedSize: 20, UncompressedSize: 200},
+		{Hash: "unreferenced", CompressedSize: 40, UncompressedSize: 400},
+	}
+
+	for _, blob := range blobs {
+		blob.ID = types.NewBlobID()
+		blob.CreatedTS = time.Now().Truncate(time.Second)
+
+		err = repos.Blobs.Create(ctx, nil, blob)
+		if err != nil {
+			t.Fatalf("failed to create blob %s: %v", blob.Hash, err)
+		}
+	}
+
+	for _, blob := range blobs[:2] {
+		err = repos.Snapshots.AddBlob(ctx, nil, snapshot.ID.String(),
+			blob.ID, blob.Hash)
+		if err != nil {
+			t.Fatalf("failed to add blob %s to snapshot: %v", blob.Hash, err)
+		}
+	}
+
+	compressed, uncompressed, err := repos.Snapshots.GetSnapshotBlobSizes(
+		ctx, snapshot.ID.String())
+	if err != nil {
+		t.Fatalf("failed to get snapshot blob sizes: %v", err)
+	}
+
+	if compressed != 30 || uncompressed != 300 {
+		t.Errorf("blob sizes: got %d and %d, want 30 and 300",
+			compressed, uncompressed)
+	}
+}
+
 func TestSnapshotRepositoryListRecent(t *testing.T) {
 	t.Parallel()