Record each file's size on disk and print it in trees (closes #147)

The files table gets a disk_size column: the file's allocated blocks,
st_blocks × 512, from the lstat the walk already does. scan writes it
with every record it writes. When a rescan finds a file with its size
and mtime unchanged but a different disk_size, it updates disk_size
alone, without reading the file. trees adds disk_size up per directory
and prints it as a column after size. On a compressed or sparse file it
is less than size, so two copies of one tree can differ.

Judgement calls: each row's disk_size is the dupe copy's, not the
first's. A file whose record gets only a new disk_size counts as
unchanged.

Model: opus-5-5

db.go

@@ -47,14 +47,15 @@ const dbFilePerm = 0o644
 const lockFilePerm = 0o600
 
 // createTableSQL is the schema applied to a fresh database. Paths are
-// BLOBs because Unix paths are raw bytes, not guaranteed UTF-8. mtime
-// holds whole Unix seconds and mtime_nsec the nanoseconds within that
-// second. head, tail and content each hold the raw 32 bytes of a
-// SHA-256.
+// BLOBs because Unix paths are raw bytes, not guaranteed UTF-8.
+// disk_size holds the bytes the file takes on disk. mtime holds whole
+// Unix seconds and mtime_nsec the nanoseconds within that second. head,
+// tail and content each hold the raw 32 bytes of a SHA-256.
 const createTableSQL = `
 CREATE TABLE files (
     path       BLOB PRIMARY KEY,
     size       INTEGER NOT NULL,
+    disk_size  INTEGER NOT NULL,
     mtime      INTEGER NOT NULL,
     mtime_nsec INTEGER NOT NULL,
     head       BLOB NOT NULL,
@@ -115,11 +116,13 @@ SELECT records FROM totals
 // upsertSQL inserts one file record, replacing any existing record for
 // the same path.
 const upsertSQL = `
-INSERT INTO files (path, size, mtime, mtime_nsec, head, tail, content)
-VALUES (?, ?, ?, ?, ?, ?, ?)
+INSERT INTO files (
+    path, size, disk_size, mtime, mtime_nsec, head, tail, content
+)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?)
 ON CONFLICT (path) DO UPDATE SET
-    size = excluded.size, mtime = excluded.mtime,
-    mtime_nsec = excluded.mtime_nsec,
+    size = excluded.size, disk_size = excluded.disk_size,
+    mtime = excluded.mtime, mtime_nsec = excluded.mtime_nsec,
     head = excluded.head, tail = excluded.tail,
     content = excluded.content
 `
@@ -536,8 +539,8 @@ func loadFileRows(ctx context.Context, db *sql.DB, total func(n int64),
 	total(n)
 
 	rows, err := tx.QueryContext(ctx,
-		"SELECT path, size, mtime, mtime_nsec, head, tail, content "+
-			"FROM files ORDER BY path")
+		"SELECT path, size, disk_size, mtime, mtime_nsec, head, tail, "+
+			"content FROM files ORDER BY path")
 	if err != nil {
 		return fmt.Errorf("read records: %w", err)
 	}
@@ -551,7 +554,8 @@ func loadFileRows(ctx context.Context, db *sql.DB, total func(n int64),
 			r                         scanRec
 		)
 
-		err = rows.Scan(&path, &r.size, &sec, &nsec, &head, &tail, &content)
+		err = rows.Scan(&path, &r.size, &r.diskSize, &sec, &nsec,
+			&head, &tail, &content)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
@@ -586,10 +590,11 @@ ORDER BY size DESC, head DESC, tail DESC, content DESC
 `
 
 // loadSignatureRows gives total the number of records, then streams
-// every record's signature and path to fn, without its mtime, in the
-// order of signatureRowsSQL. The count and the records are read in one
-// transaction, so they agree while a scan is committing. An error from
-// fn stops the reading and is returned as it is.
+// every record's signature and path to fn, without its mtime or its
+// disk_size, in the order of signatureRowsSQL. The count and the
+// records are read in one transaction, so they agree while a scan is
+// committing. An error from fn stops the reading and is returned as it
+// is.
 func loadSignatureRows(ctx context.Context, db *sql.DB,
 	total func(n int64), fn func(r scanRec) error,
 ) error {
@@ -724,15 +729,15 @@ func readDatabaseCounts(ctx context.Context,
 	return c, nil
 }
 
-// loadFileMeta streams every record's path, size and mtime to fn. Scan
-// change detection needs no hash values, and skipping the hash columns
-// keeps the scan's in-memory index small on multi-million-file
-// databases.
+// loadFileMeta streams every record's path, size, disk_size and mtime
+// to fn. Scan change detection needs no hash values, and skipping the
+// hash columns keeps the scan's in-memory index small on
+// multi-million-file databases.
 func loadFileMeta(ctx context.Context, db *sql.DB,
-	fn func(path string, size int64, mtime time.Time),
+	fn func(path string, m fileMeta),
 ) error {
 	rows, err := db.QueryContext(ctx,
-		"SELECT path, size, mtime, mtime_nsec FROM files")
+		"SELECT path, size, disk_size, mtime, mtime_nsec FROM files")
 	if err != nil {
 		return fmt.Errorf("read records: %w", err)
 	}
@@ -741,16 +746,19 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 
 	for rows.Next() {
 		var (
-			path            []byte
-			size, sec, nsec int64
+			path      []byte
+			m         fileMeta
+			sec, nsec int64
 		)
 
-		err = rows.Scan(&path, &size, &sec, &nsec)
+		err = rows.Scan(&path, &m.size, &m.diskSize, &sec, &nsec)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
 
-		fn(string(path), size, time.Unix(sec, nsec))
+		m.mtime = time.Unix(sec, nsec)
+
+		fn(string(path), m)
 	}
 
 	err = rows.Err()
@@ -768,21 +776,21 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 // WAL small and let concurrent reports observe progress.
 const updateBatchSize = 10000
 
-// applyChanges writes one scan's database changes — upserts for new and
-// changed files, deletes for vanished ones — in batched transactions.
-// Progress is rendered on prog (one increment per change).
+// applyChanges writes upserts for new and changed files and deletes for
+// vanished ones, in batched transactions. Progress is rendered on prog
+// (one increment per change).
 func applyChanges(ctx context.Context, db *sql.DB, upserts []scanRec,
 	deletes []string, prog *progress,
 ) error {
 	for batch := range slices.Chunk(upserts, updateBatchSize) {
-		err := applyBatch(ctx, db, batch, nil, prog)
+		err := applyBatch(ctx, db, batch, nil, nil, prog)
 		if err != nil {
 			return err
 		}
 	}
 
 	for batch := range slices.Chunk(deletes, updateBatchSize) {
-		err := applyBatch(ctx, db, nil, batch, prog)
+		err := applyBatch(ctx, db, nil, nil, batch, prog)
 		if err != nil {
 			return err
 		}
@@ -791,10 +799,26 @@ func applyChanges(ctx context.Context, db *sql.DB, upserts []scanRec,
 	return nil
 }
 
-// applyBatch commits one batch of upserts and deletes in a single
-// transaction.
+// applyDiskSizes writes the disk_size of each of recs into its record,
+// in batched transactions, and leaves the rest of the record alone.
+// Progress is rendered on prog (one increment per record).
+func applyDiskSizes(ctx context.Context, db *sql.DB, recs []fileRec,
+	prog *progress,
+) error {
+	for batch := range slices.Chunk(recs, updateBatchSize) {
+		err := applyBatch(ctx, db, nil, batch, nil, prog)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// applyBatch commits one batch of upserts, disk_size updates and
+// deletes in a single transaction.
 func applyBatch(ctx context.Context, db *sql.DB, upserts []scanRec,
-	deletes []string, prog *progress,
+	diskSizes []fileRec, deletes []string, prog *progress,
 ) error {
 	tx, err := db.BeginTx(ctx, nil)
 	if err != nil {
@@ -808,6 +832,11 @@ func applyBatch(ctx context.Context, db *sql.DB, upserts []scanRec,
 		return err
 	}
 
+	err = execDiskSizes(ctx, tx, diskSizes, prog)
+	if err != nil {
+		return err
+	}
+
 	err = execDeletes(ctx, tx, deletes, prog)
 	if err != nil {
 		return err
@@ -833,7 +862,7 @@ func execUpserts(ctx context.Context, tx *sql.Tx, upserts []scanRec,
 	defer func() { _ = st.Close() }()
 
 	for _, r := range upserts {
-		_, err = st.ExecContext(ctx, []byte(r.path), r.size,
+		_, err = st.ExecContext(ctx, []byte(r.path), r.size, r.diskSize,
 			r.mtime.Unix(), r.mtime.Nanosecond(),
 			r.head[:], r.tail[:], r.content[:])
 		if err != nil {
@@ -846,6 +875,31 @@ func execUpserts(ctx context.Context, tx *sql.Tx, upserts []scanRec,
 	return nil
 }
 
+// execDiskSizes sets the disk_size of the record of each of recs. It
+// does not touch size, so the totals triggers do not fire.
+func execDiskSizes(ctx context.Context, tx *sql.Tx, recs []fileRec,
+	prog *progress,
+) error {
+	st, err := tx.PrepareContext(ctx,
+		"UPDATE files SET disk_size = ? WHERE path = ?")
+	if err != nil {
+		return fmt.Errorf("prepare disk_size update: %w", err)
+	}
+
+	defer func() { _ = st.Close() }()
+
+	for _, r := range recs {
+		_, err = st.ExecContext(ctx, r.diskSize, []byte(r.path))
+		if err != nil {
+			return fmt.Errorf("update disk_size of %s: %w", r.path, err)
+		}
+
+		prog.increment()
+	}
+
+	return nil
+}
+
 // execDeletes removes the records for paths no longer present.
 func execDeletes(ctx context.Context, tx *sql.Tx, deletes []string,
 	prog *progress,