scan: never record its own database files (closes #115)

When the database lay under a scanned operand, the walk recorded the
database file, its -wal and -shm files and its .lock file like any other
file, so every rescan updated them and report paired them with empty
files. Once the database and the lock file are open, the scan now notes
their device and inode, and the walk passes over a file with one of
them, as an operand or below one, printing no line and counting
nothing. Matching by device and inode holds through a symlinked
directory, where comparing paths would not. A record an earlier scan
left for one of them is deleted as unverified. README's smoke-test note
on keeping the database out of the tree is gone, as it no longer holds.

Judgement call: walkRules, in exclude.go, carries the noted files to the walk.

Model: opus-5-5

scan_test.go

@@ -1171,7 +1171,7 @@ func syncOneFilesystem(t *testing.T, db *sql.DB, roots []string,
 	var initial []dirJob
 
 	for _, root := range roots {
-		for _, job := range seedRoot(ctx, root, events) {
+		for _, job := range seedRoot(ctx, root, walkRules{}, events) {
 			job.rootDev = devices[root]
 			initial = append(initial, job)
 		}
@@ -2501,3 +2501,99 @@ func TestUnderRoot(t *testing.T) {
 		}
 	}
 }
+
+// TestRunScanPassesOverDatabase scans a tree that holds the scan's own
+// database, reached directly and through a symlinked directory. The
+// walk passes over the database file, its -wal and -shm files and its
+// .lock file with no line and no count, and the record an earlier scan
+// left for the .lock file is deleted. A rescan of the unchanged tree
+// updates nothing, and report lists none of the database's files.
+func TestRunScanPassesOverDatabase(t *testing.T) {
+	for _, viaSymlink := range []bool{false, true} {
+		t.Run(fmt.Sprintf("via symlink %v", viaSymlink), func(t *testing.T) {
+			base := t.TempDir()
+			tree := filepath.Join(base, "real", "tree")
+			operand := tree
+
+			writeFile(t, tree, "a", pattern(1, 100))
+			writeFile(t, tree, "b", pattern(1, 100))
+			writeFile(t, tree, "empty1", nil)
+			writeFile(t, tree, "empty2", nil)
+
+			if viaSymlink {
+				err := os.Symlink(filepath.Join(base, "real"),
+					filepath.Join(base, "link"))
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				operand = filepath.Join(base, "link", "tree")
+			}
+
+			dbPath := filepath.Join(tree, "db.sqlite")
+			t.Setenv(databaseEnv, dbPath)
+
+			db, err := openScanDatabase(t.Context(), dbPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = applyChanges(t.Context(), db, []scanRec{
+				{path: filepath.Join(operand, "db.sqlite.lock")},
+			}, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			closeScanDatabase(t.Context(), db, dbPath)
+
+			assertScanSummary(t,
+				"4 files seen (4 added, 0 updated, 1 removed, 0 unchanged)",
+				operand)
+			assertScanSummary(t,
+				"4 files seen (0 added, 0 updated, 0 removed, 4 unchanged)",
+				operand)
+
+			report := runStdout(t, cmdReport)
+			if strings.Contains(report, "db.sqlite") ||
+				!strings.Contains(report, filepath.Join(operand, "empty2")) {
+				t.Errorf("report = %q, want the empty files and none of "+
+					"the database's files", report)
+			}
+		})
+	}
+}
+
+// TestRunScanPassesOverDatabaseOperands scans the database file and its
+// .lock file given as operands themselves: neither is recorded or
+// counted.
+func TestRunScanPassesOverDatabaseOperands(t *testing.T) {
+	dbPath := testDBPath(t)
+	t.Setenv(databaseEnv, dbPath)
+
+	// The first scan creates both files.
+	scanOK(t, t.TempDir())
+
+	assertScanSummary(t,
+		"0 files seen (0 added, 0 updated, 0 removed, 0 unchanged)",
+		dbPath, dbPath+".lock")
+}
+
+// assertScanSummary scans operands and fails the test unless the
+// summary line gives counts with nothing skipped, and the line naming
+// the database is the only one that names one of its files.
+func assertScanSummary(t *testing.T, counts string, operands ...string) {
+	t.Helper()
+
+	stderr := scanOK(t, operands...)
+
+	want := "scan: " + counts + ", 0 skipped\n"
+	if !strings.Contains(stderr, want) {
+		t.Errorf("scan %q: stderr = %q, want %q", operands, stderr, want)
+	}
+
+	if strings.Count(stderr, "db.sqlite") != 1 {
+		t.Errorf("scan %q: stderr = %q, want only the line naming the "+
+			"database to name one of its files", operands, stderr)
+	}
+}