diff --git a/internal/storage/embeddeddolt/pull_settle_test.go b/internal/storage/embeddeddolt/pull_settle_test.go index d20aa25fe..ab7392c9b 100644 --- a/internal/storage/embeddeddolt/pull_settle_test.go +++ b/internal/storage/embeddeddolt/pull_settle_test.go @@ -64,9 +64,11 @@ var embeddedFKCascadeCases = []embeddedFKCascadeCase{ orphanQuery: "SELECT COUNT(*) FROM labels WHERE issue_id = 'fkc-x-%[1]s'", }, { + // comments.id lost its DB-side default in 0051 (bd-2rd37); inserts + // must supply an explicit id like the app does (bd-6dnrw.18). name: "comments", - insert: "INSERT INTO comments (issue_id, author, text, created_at) " + - "VALUES ('fkc-x-%[1]s', 'peer', 'late comment', NOW())", + insert: "INSERT INTO comments (id, issue_id, author, text, created_at) " + + "VALUES (UUID(), 'fkc-x-%[1]s', 'peer', 'late comment', NOW())", orphanQuery: "SELECT COUNT(*) FROM comments WHERE issue_id = 'fkc-x-%[1]s'", }, } @@ -262,3 +264,71 @@ func TestEmbeddedMergeAndSettleMetadataConflict(t *testing.T) { t.Errorf("expected metadata value 'bbb' (theirs), got %q", value) } } + +// TestEmbeddedMergeAndSettleDirtyWorkingSetSurvivesRefusedMerge pins the +// bd-578h9.2 fix: when DOLT_MERGE refuses to start because the working set +// is dirty, no merge state exists, so DOLT_MERGE('--abort') fails too — and +// the old abortMerge fell back to DOLT_RESET('--hard'), silently destroying +// the uncommitted rows the merge never touched. The hard reset is now gated +// on the working set having been clean before the merge ran. +func TestEmbeddedMergeAndSettleDirtyWorkingSetSurvivesRefusedMerge(t *testing.T) { + te := newTestEnv(t, "dirtysettle") + ctx := t.Context() + conn := openSettleConn(t, ctx, te) + + // Seed and commit a baseline, then diverge a peer branch so the merge + // has real work to do (a fast-forward can succeed on a dirty set). + if _, err := conn.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES ('dirty-base', 'base', '', '', '', '', 'open', 2, 'task')"); err != nil { + t.Fatalf("seed base issue: %v", err) + } + if _, err := conn.ExecContext(ctx, "CALL DOLT_COMMIT('-Am', 'seed base')"); err != nil { + t.Fatalf("commit seed: %v", err) + } + if _, err := conn.ExecContext(ctx, "CALL DOLT_BRANCH('dirtypeer', 'HEAD')"); err != nil { + t.Fatalf("create peer branch: %v", err) + } + if _, err := conn.ExecContext(ctx, "CALL DOLT_CHECKOUT('dirtypeer')"); err != nil { + t.Fatalf("checkout peer: %v", err) + } + if _, err := conn.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES ('dirty-peer', 'peer', '', '', '', '', 'open', 2, 'task')"); err != nil { + t.Fatalf("seed peer issue: %v", err) + } + if _, err := conn.ExecContext(ctx, "CALL DOLT_COMMIT('-Am', 'peer work')"); err != nil { + t.Fatalf("commit peer: %v", err) + } + // Diverge main too so the merge is a true three-way merge. + if _, err := conn.ExecContext(ctx, "CALL DOLT_CHECKOUT('main')"); err != nil { + t.Fatalf("checkout main: %v", err) + } + if _, err := conn.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES ('dirty-main', 'main', '', '', '', '', 'open', 2, 'task')"); err != nil { + t.Fatalf("seed main issue: %v", err) + } + if _, err := conn.ExecContext(ctx, "CALL DOLT_COMMIT('-Am', 'main work')"); err != nil { + t.Fatalf("commit main: %v", err) + } + + // The user's uncommitted work: present in the working set, never committed. + if _, err := conn.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES ('dirty-uncommitted', 'precious', '', '', '', '', 'open', 2, 'task')"); err != nil { + t.Fatalf("insert uncommitted issue: %v", err) + } + + mergeErr := versioncontrolops.MergeAndSettle(ctx, conn, "dirtypeer") + if mergeErr == nil { + t.Logf("note: this Dolt version merged over a dirty working set without refusing") + } else { + t.Logf("merge refused as expected: %v", mergeErr) + } + + var count int + if err := conn.QueryRowContext(ctx, + "SELECT COUNT(*) FROM issues WHERE id = 'dirty-uncommitted'").Scan(&count); err != nil { + t.Fatalf("count uncommitted issue: %v", err) + } + if count != 1 { + t.Fatalf("uncommitted working-set row was destroyed by the merge abort path (count=%d)", count) + } +} diff --git a/internal/storage/embeddeddolt/version_control.go b/internal/storage/embeddeddolt/version_control.go index 7b93cf8d9..1e8a53e4f 100644 --- a/internal/storage/embeddeddolt/version_control.go +++ b/internal/storage/embeddeddolt/version_control.go @@ -254,6 +254,12 @@ func (s *EmbeddedDoltStore) Push(ctx context.Context) error { } func (s *EmbeddedDoltStore) Pull(ctx context.Context) error { + // GH#2474 / bd-578h9.2: auto-commit pending changes before pull, matching + // server-mode pullFromRemote and PullFrom. Leftovers from a crashed + // command would otherwise make the merge refuse to start. + if _, err := s.CommitPending(ctx, "beads"); err != nil { + return fmt.Errorf("commit pending before pull: %w", err) + } preHead := s.preMergeHead(ctx) err := s.withPinnedDBConn(ctx, func(db versioncontrolops.DBConn) error { return versioncontrolops.Pull(ctx, db, defaultRemote, s.branch, remoteAuthUser()) @@ -280,6 +286,10 @@ func (s *EmbeddedDoltStore) PushRemote(ctx context.Context, remote string, force } func (s *EmbeddedDoltStore) PullRemote(ctx context.Context, remote string) error { + // GH#2474 / bd-578h9.2: see Pull. + if _, err := s.CommitPending(ctx, "beads"); err != nil { + return fmt.Errorf("commit pending before pull: %w", err) + } preHead := s.preMergeHead(ctx) err := s.withPinnedDBConn(ctx, func(db versioncontrolops.DBConn) error { return versioncontrolops.Pull(ctx, db, remote, s.branch, remoteAuthUser()) diff --git a/internal/storage/versioncontrolops/mergesettle.go b/internal/storage/versioncontrolops/mergesettle.go index cc2bbde4c..7209c67d3 100644 --- a/internal/storage/versioncontrolops/mergesettle.go +++ b/internal/storage/versioncontrolops/mergesettle.go @@ -33,6 +33,11 @@ import ( // rolling back, so the settle pass can repair it; SettleMerge's gates ensure // nothing unrepaired survives without an error. func MergeAndSettle(ctx context.Context, db DBConn, ref string) error { + // Capture pre-merge cleanliness before anything runs: abortMerge's + // hard-reset fallback is only safe when nothing uncommitted predates + // the merge (bd-578h9.2). + preMergeClean := workingSetClean(ctx, db) + if _, err := db.ExecContext(ctx, "SET @@dolt_allow_commit_conflicts = 1"); err != nil { return fmt.Errorf("set dolt_allow_commit_conflicts: %w", err) } @@ -45,7 +50,7 @@ func MergeAndSettle(ctx context.Context, db DBConn, ref string) error { // DOLT_PULL swallows "Already up to date." internally; we do the same. mergeErr = nil } - return SettleMerge(ctx, db, mergeErr) + return SettleMerge(ctx, db, mergeErr, preMergeClean) } // SettleMerge finishes a merge that ran on db with the session flags @@ -53,16 +58,17 @@ func MergeAndSettle(ctx context.Context, db DBConn, ref string) error { // cascade violations (bd-6dnrw.4), and leaves the settled working set in // place — or aborts the merge when anything needs the operator. mergeErr is // the merge statement's own error; it is surfaced whenever nothing was -// resolved or repaired. The decision logic mirrors server-mode -// settleMergeInTx exactly; the abort stands in for that path's transaction -// rollback, restoring the pre-merge working set (which the merge required to -// be clean) so a retry is possible. -func SettleMerge(ctx context.Context, db DBConn, mergeErr error) error { +// resolved or repaired. preMergeClean reports whether the working set was +// clean before the merge ran; it gates abortMerge's hard-reset fallback. +// The decision logic mirrors server-mode settleMergeInTx exactly; the abort +// stands in for that path's transaction rollback, restoring the pre-merge +// working set so a retry is possible. +func SettleMerge(ctx context.Context, db DBConn, mergeErr error, preMergeClean bool) error { // Check for merge conflicts regardless of whether the merge errored. // Some Dolt versions error on conflicts, others leave them in the working set. resolved, resolveErr := TryAutoResolveMergeConflicts(ctx, db) if resolveErr != nil { - abortMerge(ctx, db) + abortMerge(ctx, db, preMergeClean) if mergeErr != nil { return mergeErr } @@ -75,14 +81,14 @@ func SettleMerge(ctx context.Context, db DBConn, mergeErr error) error { // autocommits, so the abort below is what keeps them out of the database. repairedViol, hadViol, violErr := TryRepairFKCascadeViolations(ctx, db) if violErr != nil { - abortMerge(ctx, db) + abortMerge(ctx, db, preMergeClean) if mergeErr != nil { return mergeErr } return violErr } if hadViol && !repairedViol { - abortMerge(ctx, db) + abortMerge(ctx, db, preMergeClean) if mergeErr != nil { return mergeErr } @@ -91,7 +97,7 @@ func SettleMerge(ctx context.Context, db DBConn, mergeErr error) error { if mergeErr != nil && !resolved && !repairedViol { // Merge failed for a non-conflict reason, or conflicts include non-metadata tables. - abortMerge(ctx, db) + abortMerge(ctx, db, preMergeClean) return mergeErr } @@ -102,15 +108,28 @@ func SettleMerge(ctx context.Context, db DBConn, mergeErr error) error { // merge — the autocommit-mode stand-in for server mode's tx.Rollback(). // DOLT_MERGE('--abort') is the precise tool but only works while merge state // is active; a force-committed violation-only merge may have closed it, so -// fall back to a hard reset, which is equivalent here because DOLT_MERGE -// refuses to start on a dirty working set (nothing uncommitted can be lost). +// fall back to a hard reset — but only when the working set was clean before +// the merge ran. The most common reason --abort fails is a merge that +// REFUSED TO START on a dirty working set; hard-resetting there would +// destroy uncommitted data the merge never touched (bd-578h9.2). // Best-effort: the caller's error is what matters. -func abortMerge(ctx context.Context, db DBConn) { - if _, err := db.ExecContext(ctx, "CALL DOLT_MERGE('--abort')"); err != nil { +func abortMerge(ctx context.Context, db DBConn, preMergeClean bool) { + if _, err := db.ExecContext(ctx, "CALL DOLT_MERGE('--abort')"); err != nil && preMergeClean { _, _ = db.ExecContext(ctx, "CALL DOLT_RESET('--hard')") } } +// workingSetClean reports whether dolt_status is empty. Errors count as +// dirty so the hard-reset fallback stays conservative. +func workingSetClean(ctx context.Context, db DBConn) bool { + rows, err := db.QueryContext(ctx, "SELECT 1 FROM dolt_status LIMIT 1") + if err != nil { + return false + } + defer rows.Close() + return !rows.Next() && rows.Err() == nil +} + // TryAutoResolveMergeConflicts auto-resolves merge conflicts that are safe to // resolve without operator input, and returns (true, nil) only if ALL conflicts // were resolved. It handles three classes: