Merge state refactoring

go/cmd/dolt/commands/merge.go

@@ -138,7 +138,7 @@ func abortMerge(ctx context.Context, doltEnv *env.DoltEnv) errhand.VerboseError
 	err := actions.CheckoutAllTables(ctx, doltEnv.DbData())
 
 	if err == nil {
-		err = doltEnv.RepoState.AbortMerge(doltEnv.FS)
+		err = doltEnv.AbortMerge(ctx)
 
 		if err == nil {
 			return nil
@@ -472,14 +472,8 @@ func mergedRootToWorking(ctx context.Context, squash bool, dEnv *env.DoltEnv, me
 		}
 	}
 
-	h2, err := cm2.HashOf()
-
-	if err != nil {
-		return errhand.BuildDError("error: failed to hash commit").AddCause(err).Build()
-	}
-
 	if !squash {
-		err = dEnv.RepoState.StartMerge(h2.String(), dEnv.FS)
+		err = dEnv.StartMerge(ctx, cm2)
 
 		if err != nil {
 			return errhand.BuildDError("Unable to update the repo state").AddCause(err).Build()

go/libraries/doltcore/doltdb/workingset.go

@@ -31,7 +31,6 @@ const (
 )
 
 type MergeState struct {
-	valueSt         types.Struct
 	commit          *Commit
 	preMergeWorking *RootValue
 }
@@ -71,6 +70,26 @@ func (ws WorkingSet) WithWorkingRoot(workingRoot *RootValue) *WorkingSet {
 	return &ws
 }
 
+func (ws WorkingSet) StartMerge(commit *Commit) *WorkingSet {
+	ws.mergeState = &MergeState{
+		commit:          commit,
+		preMergeWorking: ws.workingRoot,
+	}
+
+	return &ws
+}
+
+func (ws WorkingSet) AbortMerge() *WorkingSet {
+	ws.workingRoot = ws.mergeState.PreMergeWorkingRoot()
+	ws.mergeState = nil
+	return &ws
+}
+
+func (ws WorkingSet) ClearMerge() *WorkingSet {
+	ws.mergeState = nil
+	return &ws
+}
+
 func (ws *WorkingSet) WorkingRoot() *RootValue {
 	return ws.workingRoot
 }
@@ -83,6 +102,10 @@ func (ws *WorkingSet) MergeState() *MergeState {
 	return ws.mergeState
 }
 
+func (ws *WorkingSet) MergeActive() bool {
+	return ws.mergeState != nil
+}
+
 // NewWorkingSet creates a new WorkingSet object.
 func NewWorkingSet(ctx context.Context, name string, vrw types.ValueReadWriter, workingSetSt types.Struct) (*WorkingSet, error) {
 	// TODO: meta struct
@@ -177,6 +200,7 @@ func (ws *WorkingSet) writeValues(ctx context.Context, db *DoltDB) (
 		return types.Ref{}, nil, nil, err
 	}
 
+	// TODO: this is never nil
 	if ws.stagedRoot != nil {
 		var stagedRootRef types.Ref
 		stagedRootRef, err = db.writeRootValue(ctx, ws.stagedRoot)
@@ -187,12 +211,22 @@ func (ws *WorkingSet) writeValues(ctx context.Context, db *DoltDB) (
 	}
 
 	if ws.mergeState != nil {
-		// TODO: write nested merge state refs here?
 		var mergeStateRef types.Ref
-		mergeStateRef, err = db.writeRootValue(ctx, ws.stagedRoot)
+		preMergeWorking, err := db.writeRootValue(ctx, ws.mergeState.preMergeWorking)
 		if err != nil {
 			return types.Ref{}, nil, nil, err
 		}
+
+		mergeStateRefSt, err := datas.NewMergeState(ctx, preMergeWorking, ws.mergeState.commit.commitSt)
+		if err != nil {
+			return types.Ref{}, nil, nil, err
+		}
+
+		mergeStateRef, err = db.db.WriteValue(ctx, mergeStateRefSt)
+		if err != nil {
+			return types.Ref{}, nil, nil, err
+		}
+
 		mergeState = &mergeStateRef
 	}
 

go/libraries/doltcore/dtestutils/testcommands/command.go

@@ -276,10 +276,7 @@ func (m Merge) Exec(t *testing.T, dEnv *env.DoltEnv) error {
 			require.True(t, stats.Conflicts == 0)
 		}
 
-		h2, err := cm2.HashOf()
-		require.NoError(t, err)
-
-		err = dEnv.RepoState.StartMerge(h2.String(), dEnv.FS)
+		err = dEnv.StartMerge(context.Background(), cm2)
 		if err != nil {
 			return err
 		}

go/libraries/doltcore/env/actions/commit.go

@@ -176,7 +176,7 @@ func CommitStaged(ctx context.Context, workingRoot *doltdb.RootValue, dbData env
 		return "", err
 	}
 
-	err = rsw.ClearMerge()
+	err = rsw.ClearMerge(ctx)
 
 	if err != nil {
 		return "", err

go/libraries/doltcore/env/environment.go

@@ -463,28 +463,6 @@ type repoStateWriter struct {
 	*DoltEnv
 }
 
-func (r *repoStateWriter) SetStagedHash(ctx context.Context, h hash.Hash) error {
-	r.RepoState.staged = h.String()
-	err := r.RepoState.Save(r.FS)
-
-	if err != nil {
-		return ErrStateUpdate
-	}
-
-	return nil
-}
-
-func (r *repoStateWriter) SetWorkingHash(ctx context.Context, h hash.Hash) error {
-	r.RepoState.working = h.String()
-	err := r.RepoState.Save(r.FS)
-
-	if err != nil {
-		return ErrStateUpdate
-	}
-
-	return nil
-}
-
 func (r *repoStateWriter) SetCWBHeadRef(ctx context.Context, marshalableRef ref.MarshalableRef) error {
 	r.RepoState.Head = marshalableRef
 	err := r.RepoState.Save(r.FS)
@@ -496,16 +474,17 @@ func (r *repoStateWriter) SetCWBHeadRef(ctx context.Context, marshalableRef ref.
 	return nil
 }
 
-func (r *repoStateWriter) AbortMerge() error {
-	return r.RepoState.AbortMerge(r.FS)
+// TODO: kill merge methods
+func (r *repoStateWriter) AbortMerge(ctx context.Context) error {
+	return r.DoltEnv.AbortMerge(ctx)
 }
 
-func (r *repoStateWriter) ClearMerge() error {
-	return r.RepoState.ClearMerge(r.FS)
+func (r *repoStateWriter) ClearMerge(ctx context.Context) error {
+	return r.DoltEnv.ClearMerge(ctx)
 }
 
-func (r *repoStateWriter) StartMerge(commitStr string) error {
-	return r.RepoState.StartMerge(commitStr, r.FS)
+func (r *repoStateWriter) StartMerge(ctx context.Context, commit *doltdb.Commit) error {
+	return r.DoltEnv.StartMerge(ctx, commit)
 }
 
 func (dEnv *DoltEnv) RepoStateWriter() RepoStateWriter {
@@ -563,6 +542,7 @@ func (dEnv *DoltEnv) DbData() DbData {
 	}
 }
 
+// StagedRoot returns the staged root value in the current working set
 func (dEnv *DoltEnv) StagedRoot(ctx context.Context) (*doltdb.RootValue, error) {
 		workingSet, err := dEnv.WorkingSet(ctx)
 		if err != nil {
@@ -600,6 +580,48 @@ func (dEnv *DoltEnv) UpdateStagedRoot(ctx context.Context, newRoot *doltdb.RootV
 	return dEnv.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h)
 }
 
+func (dEnv *DoltEnv) AbortMerge(ctx context.Context) error {
+	ws, err := dEnv.WorkingSet(ctx)
+   if err != nil {
+		return err
+	}
+
+	h, err := ws.HashOf()
+	if err != nil {
+		return err
+	}
+
+	return dEnv.DoltDB.UpdateWorkingSet(ctx, ws.Ref(), ws.AbortMerge(), h)
+}
+
+func (dEnv *DoltEnv) ClearMerge(ctx context.Context) error {
+	ws, err := dEnv.WorkingSet(ctx)
+	if err != nil {
+		return err
+	}
+
+	h, err := ws.HashOf()
+	if err != nil {
+		return err
+	}
+
+	return dEnv.DoltDB.UpdateWorkingSet(ctx, ws.Ref(), ws.ClearMerge(), h)
+}
+
+func (dEnv *DoltEnv) StartMerge(ctx context.Context, commit *doltdb.Commit) error {
+	ws, err := dEnv.WorkingSet(ctx)
+	if err != nil {
+		return err
+	}
+
+	h, err := ws.HashOf()
+	if err != nil {
+		return err
+	}
+
+	return dEnv.DoltDB.UpdateWorkingSet(ctx, ws.Ref(), ws.StartMerge(commit), h)
+}
+
 // todo: move this out of env to actions
 func (dEnv *DoltEnv) PutTableToWorking(ctx context.Context, sch schema.Schema, rows types.Map, indexData types.Map, tableName string, autoVal types.Value) error {
 	root, err := dEnv.WorkingRoot(ctx)

go/libraries/doltcore/env/repo_state.go

@@ -42,9 +42,9 @@ type RepoStateWriter interface {
 	UpdateStagedRoot(ctx context.Context, newRoot *doltdb.RootValue) error
 	UpdateWorkingRoot(ctx context.Context, newRoot *doltdb.RootValue) error
 	SetCWBHeadRef(context.Context, ref.MarshalableRef) error
-	AbortMerge() error
-	ClearMerge() error
-	StartMerge(commitStr string) error
+	AbortMerge(ctx context.Context) error
+	ClearMerge(ctx context.Context) error
+	StartMerge(ctx context.Context, commit *doltdb.Commit) error
 }
 
 type DocsReadWriter interface {
@@ -164,21 +164,6 @@ func (rs *RepoState) CWBHeadSpec() *doltdb.CommitSpec {
 	return spec
 }
 
-func (rs *RepoState) StartMerge(commit string, fs filesys.Filesys) error {
-	rs.Merge = &MergeState{commit, rs.working}
-	return rs.Save(fs)
-}
-
-func (rs *RepoState) AbortMerge(fs filesys.Filesys) error {
-	rs.working = rs.Merge.PreMergeWorking
-	return rs.ClearMerge(fs)
-}
-
-func (rs *RepoState) ClearMerge(fs filesys.Filesys) error {
-	rs.Merge = nil
-	return rs.Save(fs)
-}
-
 func (rs *RepoState) AddRemote(r Remote) {
 	rs.Remotes[r.Name] = r
 }

go/libraries/doltcore/sqle/dfunctions/dolt_merge.go

@@ -158,7 +158,7 @@ func abortMerge(ctx *sql.Context, dbData env.DbData) error {
 		return err
 	}
 
-	err = dbData.Rsw.AbortMerge()
+	err = dbData.Rsw.AbortMerge(ctx)
 	if err != nil {
 		return err
 	}
@@ -311,14 +311,9 @@ func mergeRootToWorking(
 	cm2 *doltdb.Commit,
 	mergeStats map[string]*merge.MergeStats,
 ) error {
-	h2, err := cm2.HashOf()
-	if err != nil {
-		return err
-	}
-
 	workingRoot := mergedRoot
 	if !squash {
-		err = dbData.Rsw.StartMerge(h2.String())
+		err := dbData.Rsw.StartMerge(ctx, cm2)
 
 		if err != nil {
 			return err
@@ -326,7 +321,7 @@ func mergeRootToWorking(
 	}
 
 	// TODO: this should only update the session working root
-	err = env.UpdateWorkingRoot(ctx, dbData.Rsw, workingRoot)
+	err := env.UpdateWorkingRoot(ctx, dbData.Rsw, workingRoot)
 	if err != nil {
 		return err
 	}