mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-04-19 19:21:44 -05:00
Code Issues Packages Projects Releases 156 Wiki Activity

Refactoring, halfway through

Browse Source
This commit is contained in:
Zach Musgrave
2021-06-11 15:53:31 -07:00
parent 10917ff5cb
commit db68c3a6c9
16 changed files with 220 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
go/cmd/dolt/commands/commit.go
View File

@@ -76,9 +76,13 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
// Check if the -all param is provided. Stage all tables if so.
allFlag := apr.Contains(cli.AllFlag)
var err error
workingRoot, err := dEnv.WorkingRoot(ctx)
if err != nil {
return HandleVErrAndExitCode(errhand.BuildDError("Couldn't get working root").AddCause(err).Build(), usage)
}
if allFlag {
err = actions.StageAllTables(ctx, dEnv.DbData())
err = actions.StageAllTables(ctx, workingRoot, dEnv.DbData())
}
if err != nil {
@@ -114,7 +118,7 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
dbData := dEnv.DbData()
_, err = actions.CommitStaged(ctx, dbData, actions.CommitStagedProps{
_, err = actions.CommitStaged(ctx, workingRoot, dbData, actions.CommitStagedProps{
Message: msg,
Date: t,
AllowEmpty: apr.Contains(cli.AllowEmptyFlag),
@@ -198,20 +202,25 @@ func buildInitalCommitMsg(ctx context.Context, dEnv *env.DoltEnv) string {
initialNoColor := color.NoColor
color.NoColor = true
currBranch := dEnv.RepoState.CWBHeadRef()
stagedTblDiffs, notStagedTblDiffs, _ := diff.GetStagedUnstagedTableDeltas(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
workingRoot, err := dEnv.WorkingRoot(ctx)
if err != nil {
panic(err)
}
stagedTblDiffs, notStagedTblDiffs, _ := diff.GetStagedUnstagedTableDeltas(ctx, dEnv.DoltDB, workingRoot, dEnv.RepoStateReader())
workingTblsInConflict, _, _, err := merge.GetTablesInConflict(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
if err != nil {
workingTblsInConflict = []string{}
}
stagedDocDiffs, notStagedDocDiffs, _ := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
stagedDocDiffs, notStagedDocDiffs, _ := diff.GetDocDiffs(ctx, dEnv.DoltDB, workingRoot, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
buf := bytes.NewBuffer([]byte{})
n := printStagedDiffs(buf, stagedTblDiffs, stagedDocDiffs, true)
n = printDiffsNotStaged(ctx, dEnv, buf, notStagedTblDiffs, notStagedDocDiffs, true, n, workingTblsInConflict)
currBranch := dEnv.RepoState.CWBHeadRef()
initialCommitMessage := "\n" + "# Please enter the commit message for your changes. Lines starting" + "\n" +
"# with '#' will be ignored, and an empty message aborts the commit." + "\n# On branch " + currBranch.GetPath() + "\n#" + "\n"

7
go/cmd/dolt/commands/merge.go
View File

@@ -185,7 +185,12 @@ func mergeCommitSpec(ctx context.Context, apr *argparser.ArgParseResults, dEnv *
cli.Println("Squash commit -- not updating HEAD")
}
tblNames, workingDiffs, err := env.MergeWouldStompChanges(ctx, cm2, dEnv.DbData())
workingRoot, err := dEnv.WorkingRoot(ctx)
if err != nil {
return nil
}
tblNames, workingDiffs, err := env.MergeWouldStompChanges(ctx, workingRoot, cm2, dEnv.DbData())
if err != nil {
return errhand.BuildDError("error: failed to determine mergability.").AddCause(err).Build()

13
go/cmd/dolt/commands/status.go
View File

@@ -66,10 +66,15 @@ func (cmd StatusCmd) createArgParser() *argparser.ArgParser {
// Exec executes the command
func (cmd StatusCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv) int {
ap := cmd.createArgParser()
help, _ := cli.HelpAndUsagePrinters(cli.GetCommandDocumentation(commandStr, statusDocs, ap))
help, usage := cli.HelpAndUsagePrinters(cli.GetCommandDocumentation(commandStr, statusDocs, ap))
cli.ParseArgsOrDie(ap, args, help)
staged, notStaged, err := diff.GetStagedUnstagedTableDeltas(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
workingRoot, err := dEnv.WorkingRoot(ctx)
if err != nil {
return HandleVErrAndExitCode(errhand.BuildDError("Couldn't get working root").AddCause(err).Build(), usage)
}
staged, notStaged, err := diff.GetStagedUnstagedTableDeltas(ctx, dEnv.DoltDB, workingRoot, dEnv.RepoStateReader())
if err != nil {
cli.PrintErrln(toStatusVErr(err).Verbose())
@@ -82,14 +87,14 @@ func (cmd StatusCmd) Exec(ctx context.Context, commandStr string, args []string,
return 1
}
stagedDocDiffs, notStagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
stagedDocDiffs, notStagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, workingRoot, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
if err != nil {
cli.PrintErrln(toStatusVErr(err).Verbose())
return 1
}
workingDocsInConflict, err := merge.GetDocsInConflict(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
workingDocsInConflict, err := merge.GetDocsInConflict(ctx, workingRoot, dEnv.DocsReadWriter())
if err != nil {
cli.PrintErrln(toStatusVErr(err).Verbose())

20
go/libraries/doltcore/diff/table_deltas.go
View File

@@ -106,17 +106,18 @@ func (nd *DocDiffs) Len() int {
}
// GetDocDiffs retrieves staged and unstaged DocDiffs.
func GetDocDiffs(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, drw env.DocsReadWriter) (*DocDiffs, *DocDiffs, error) {
func GetDocDiffs(
ctx context.Context,
ddb *doltdb.DoltDB,
workingRoot *doltdb.RootValue,
rsr env.RepoStateReader,
drw env.DocsReadWriter,
) (*DocDiffs, *DocDiffs, error) {
docsOnDisk, err := drw.GetDocsOnDisk()
if err != nil {
return nil, nil, err
}
workingRoot, err := env.WorkingRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, err
}
notStagedDocDiffs, err := NewDocDiffs(ctx, workingRoot, nil, docsOnDisk)
if err != nil {
return nil, nil, err
@@ -260,7 +261,7 @@ func GetTableDeltas(ctx context.Context, fromRoot, toRoot *doltdb.RootValue) (de
return deltas, nil
}
func GetStagedUnstagedTableDeltas(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (staged, unstaged []TableDelta, err error) {
func GetStagedUnstagedTableDeltas(ctx context.Context, ddb *doltdb.DoltDB, workingRoot *doltdb.RootValue, rsr env.RepoStateReader) (staged, unstaged []TableDelta, err error) {
headRoot, err := env.HeadRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, doltdb.RootValueUnreadable{RootType: doltdb.HeadRoot, Cause: err}
@@ -271,11 +272,6 @@ func GetStagedUnstagedTableDeltas(ctx context.Context, ddb *doltdb.DoltDB, rsr e
return nil, nil, doltdb.RootValueUnreadable{RootType: doltdb.StagedRoot, Cause: err}
}
workingRoot, err := env.WorkingRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, doltdb.RootValueUnreadable{RootType: doltdb.WorkingRoot, Cause: err}
}
staged, err = GetTableDeltas(ctx, headRoot, stagedRoot)
if err != nil {
return nil, nil, err

103
go/libraries/doltcore/env/actions/branch.go vendored
View File

@@ -209,71 +209,78 @@ func createBranch(ctx context.Context, dbData env.DbData, newBranch, startingPoi
}
// updateRootsForBranch writes the roots needed for a checkout and returns the updated work and staged hash.
func updateRootsForBranch(ctx context.Context, dbData env.DbData, dref ref.DoltRef, brName string) (wrkHash hash.Hash, stgHash hash.Hash, err error) {
hasRef, err := dbData.Ddb.HasRef(ctx, dref)
func updateRootsForBranch(
ctx context.Context,
dbData env.DbData,
branchRef ref.DoltRef,
brName string,
) (workingRoot *doltdb.RootValue, stagedRoot *doltdb.RootValue, err error) {
hasRef, err := dbData.Ddb.HasRef(ctx, branchRef)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
if !hasRef {
return hash.Hash{}, hash.Hash{}, doltdb.ErrBranchNotFound
return nil, nil, doltdb.ErrBranchNotFound
}
if ref.Equals(dbData.Rsr.CWBHeadRef(), dref) {
return hash.Hash{}, hash.Hash{}, doltdb.ErrAlreadyOnBranch
if ref.Equals(dbData.Rsr.CWBHeadRef(), branchRef) {
return nil, nil, doltdb.ErrAlreadyOnBranch
}
currRoots, err := getRoots(ctx, dbData.Ddb, dbData.Rsr, doltdb.HeadRoot, doltdb.WorkingRoot, doltdb.StagedRoot)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
cs, err := doltdb.NewCommitSpec(brName)
if err != nil {
return hash.Hash{}, hash.Hash{}, doltdb.RootValueUnreadable{RootType: doltdb.HeadRoot, Cause: err}
return nil, nil, doltdb.RootValueUnreadable{RootType: doltdb.HeadRoot, Cause: err}
}
cm, err := dbData.Ddb.Resolve(ctx, cs, nil)
if err != nil {
return hash.Hash{}, hash.Hash{}, doltdb.RootValueUnreadable{RootType: doltdb.HeadRoot, Cause: err}
return nil, nil, doltdb.RootValueUnreadable{RootType: doltdb.HeadRoot, Cause: err}
}
newRoot, err := cm.GetRootValue()
branchRoot, err := cm.GetRootValue()
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
conflicts := set.NewStrSet([]string{})
wrkTblHashes, err := moveModifiedTables(ctx, currRoots[doltdb.HeadRoot], newRoot, currRoots[doltdb.WorkingRoot], conflicts)
wrkTblHashes, err := moveModifiedTables(ctx, currRoots[doltdb.HeadRoot], branchRoot, currRoots[doltdb.WorkingRoot], conflicts)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
stgTblHashes, err := moveModifiedTables(ctx, currRoots[doltdb.HeadRoot], newRoot, currRoots[doltdb.StagedRoot], conflicts)
stgTblHashes, err := moveModifiedTables(ctx, currRoots[doltdb.HeadRoot], branchRoot, currRoots[doltdb.StagedRoot], conflicts)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
if conflicts.Size() > 0 {
return hash.Hash{}, hash.Hash{}, CheckoutWouldOverwrite{conflicts.AsSlice()}
return nil, nil, CheckoutWouldOverwrite{conflicts.AsSlice()}
}
wrkHash, err = writeRoot(ctx, dbData.Ddb, newRoot, wrkTblHashes)
workingRoot, err = writeRoot(ctx, dbData.Ddb, branchRoot, wrkTblHashes)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
stgHash, err = writeRoot(ctx, dbData.Ddb, newRoot, stgTblHashes)
stagedRoot, err = writeRoot(ctx, dbData.Ddb, branchRoot, stgTblHashes)
if err != nil {
return hash.Hash{}, hash.Hash{}, err
return nil, nil, err
}
return wrkHash, stgHash, nil
return workingRoot, stagedRoot, nil
}
func CheckoutBranch(ctx context.Context, dEnv *env.DoltEnv, brName string) error {
dbData := dEnv.DbData()
dref := ref.NewBranchRef(brName)
branchRef := ref.NewBranchRef(brName)
wrkHash, stgHash, err := updateRootsForBranch(ctx, dbData, dref, brName)
workingRoot, stagedRoot, err := updateRootsForBranch(ctx, dbData, branchRef, brName)
if err != nil {
return err
}
@@ -283,17 +290,23 @@ func CheckoutBranch(ctx context.Context, dEnv *env.DoltEnv, brName string) error
return err
}
err = dbData.Rsw.SetWorkingHash(ctx, wrkHash)
err = dbData.Rsw.SetCWBHeadRef(ctx, ref.MarshalableRef{Ref: branchRef})
if err != nil {
return err
}
err = dbData.Rsw.SetStagedHash(ctx, stgHash)
err = dEnv.UpdateWorkingRoot(ctx, workingRoot)
if err != nil {
return err
}
err = dbData.Rsw.SetCWBHeadRef(ctx, ref.MarshalableRef{Ref: dref})
// TODO: moved stage root into working set too
stagedHash, err := stagedRoot.HashOf()
if err != nil {
return err
}
err = dbData.Rsw.SetStagedHash(ctx, stagedHash)
if err != nil {
return err
}
@@ -301,29 +314,6 @@ func CheckoutBranch(ctx context.Context, dEnv *env.DoltEnv, brName string) error
return SaveDocsFromWorkingExcludingFSChanges(ctx, dEnv, unstagedDocs)
}
// CheckoutBranchWithoutDocs checkouts a branch without considering any working changes to the local docs. Used
// with DOLT_CHECKOUT.
func CheckoutBranchWithoutDocs(ctx context.Context, dbData env.DbData, brName string) error {
dref := ref.NewBranchRef(brName)
wrkHash, stgHash, err := updateRootsForBranch(ctx, dbData, dref, brName)
if err != nil {
return err
}
err = dbData.Rsw.SetWorkingHash(ctx, wrkHash)
if err != nil {
return err
}
err = dbData.Rsw.SetStagedHash(ctx, stgHash)
if err != nil {
return err
}
return dbData.Rsw.SetCWBHeadRef(ctx, ref.MarshalableRef{Ref: dref})
}
var emptyHash = hash.Hash{}
// moveModifiedTables handles working set changes during a branch change.
@@ -392,10 +382,10 @@ func moveModifiedTables(ctx context.Context, oldRoot, newRoot, changedRoot *dolt
return resultMap, nil
}
func writeRoot(ctx context.Context, ddb *doltdb.DoltDB, head *doltdb.RootValue, tblHashes map[string]hash.Hash) (hash.Hash, error) {
func writeRoot(ctx context.Context, ddb *doltdb.DoltDB, head *doltdb.RootValue, tblHashes map[string]hash.Hash) (*doltdb.RootValue, error) {
names, err := head.GetTableNames(ctx)
if err != nil {
return hash.Hash{}, err
return nil, err
}
var toDrop []string
@@ -407,7 +397,7 @@ func writeRoot(ctx context.Context, ddb *doltdb.DoltDB, head *doltdb.RootValue,
head, err = head.RemoveTables(ctx, toDrop...)
if err != nil {
return hash.Hash{}, err
return nil, err
}
for k, v := range tblHashes {
@@ -417,11 +407,16 @@ func writeRoot(ctx context.Context, ddb *doltdb.DoltDB, head *doltdb.RootValue,
head, err = head.SetTableHash(ctx, k, v)
if err != nil {
return hash.Hash{}, err
return nil, err
}
}
return ddb.WriteRootValue(ctx, head)
_, err = ddb.WriteRootValue(ctx, head)
if err != nil {
return nil, err
}
return head, nil
}
func IsBranch(ctx context.Context, ddb *doltdb.DoltDB, str string) (bool, error) {

22
go/libraries/doltcore/env/actions/commit.go vendored
View File

@@ -60,7 +60,7 @@ func GetNameAndEmail(cfg config.ReadableConfig) (string, string, error) {
}
// CommitStaged adds a new commit to HEAD with the given props. Returns the new commit's hash as a string and an error.
func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProps) (string, error) {
func CommitStaged(ctx context.Context, workingRoot *doltdb.RootValue, dbData env.DbData, props CommitStagedProps) (string, error) {
ddb := dbData.Ddb
rsr := dbData.Rsr
rsw := dbData.Rsw
@@ -70,7 +70,7 @@ func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProp
return "", doltdb.ErrEmptyCommitMessage
}
staged, notStaged, err := diff.GetStagedUnstagedTableDeltas(ctx, ddb, rsr)
staged, notStaged, err := diff.GetStagedUnstagedTableDeltas(ctx, ddb, workingRoot, rsr)
if err != nil {
return "", err
}
@@ -85,7 +85,7 @@ func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProp
}
if len(staged) == 0 && !rsr.IsMergeActive() && !props.AllowEmpty {
_, notStagedDocs, err := diff.GetDocDiffs(ctx, ddb, rsr, drw)
_, notStagedDocs, err := diff.GetDocDiffs(ctx, ddb, workingRoot, rsr, drw)
if err != nil {
return "", err
}
@@ -94,11 +94,7 @@ func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProp
var mergeCmSpec []*doltdb.CommitSpec
if rsr.IsMergeActive() {
root, err := env.WorkingRoot(ctx, ddb, rsr)
if err != nil {
return "", err
}
inConflict, err := root.TablesInConflict(ctx)
inConflict, err := workingRoot.TablesInConflict(ctx)
if err != nil {
return "", err
}
@@ -153,19 +149,13 @@ func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProp
return "", err
}
wrt, err := env.WorkingRoot(ctx, ddb, rsr)
workingRoot, err = workingRoot.UpdateSuperSchemasFromOther(ctx, stagedTblNames, srt)
if err != nil {
return "", err
}
wrt, err = wrt.UpdateSuperSchemasFromOther(ctx, stagedTblNames, srt)
if err != nil {
return "", err
}
_, err = env.UpdateWorkingRoot(ctx, ddb, rsw, wrt)
_, err = env.UpdateWorkingRoot(ctx, ddb, rsw, workingRoot)
if err != nil {
return "", err

4
go/libraries/doltcore/env/actions/docs.go vendored
View File

@@ -153,7 +153,9 @@ func getUpdatedWorkingAndStagedWithDocs(ctx context.Context, working, staged, he
// GetUnstagedDocs retrieves the unstaged docs (docs from the filesystem).
func GetUnstagedDocs(ctx context.Context, dbData env.DbData) (doltdocs.Docs, error) {
_, unstagedDocDiffs, err := diff.GetDocDiffs(ctx, dbData.Ddb, dbData.Rsr, dbData.Drw)
workingRoot, err := getWorkingRoot(ctx, dbData.Ddb, dbData.Rsr)
_, unstagedDocDiffs, err := diff.GetDocDiffs(ctx, dbData.Ddb, workingRoot, dbData.Rsr, dbData.Drw)
if err != nil {
return nil, err
}

15
go/libraries/doltcore/env/actions/reset.go vendored
View File

@@ -175,7 +175,7 @@ func ResetSoftTables(ctx context.Context, dbData env.DbData, apr *argparser.ArgP
return stagedRoot, nil
}
func ResetSoft(ctx context.Context, dbData env.DbData, tables []string, stagedRoot, headRoot *doltdb.RootValue) (*doltdb.RootValue, error) {
func ResetSoft(ctx context.Context, dbData env.DbData, tables []string, workingRoot, stagedRoot, headRoot *doltdb.RootValue) (*doltdb.RootValue, error) {
tables, err := getUnionedTables(ctx, tables, stagedRoot, headRoot)
if err != nil {
@@ -197,7 +197,7 @@ func ResetSoft(ctx context.Context, dbData env.DbData, tables []string, stagedRo
return nil, err
}
stagedRoot, err = resetDocs(ctx, dbData, headRoot, stagedRoot, docs)
stagedRoot, err = resetDocs(ctx, dbData, workingRoot, headRoot, stagedRoot, docs)
if err != nil {
return nil, err
}
@@ -257,23 +257,18 @@ func getUnionedTables(ctx context.Context, tables []string, stagedRoot, headRoot
}
// resetDocs resets the working and staged docs with docs from head.
func resetDocs(ctx context.Context, dbData env.DbData, headRoot *doltdb.RootValue, staged *doltdb.RootValue, docs doltdocs.Docs) (newStgRoot *doltdb.RootValue, err error) {
func resetDocs(ctx context.Context, dbData env.DbData, workingRoot, headRoot, staged *doltdb.RootValue, docs doltdocs.Docs) (newStgRoot *doltdb.RootValue, err error) {
docs, err = doltdocs.GetDocsFromRoot(ctx, headRoot, doltdocs.GetDocNamesFromDocs(docs)...)
if err != nil {
return nil, err
}
working, err := env.WorkingRoot(ctx, dbData.Ddb, dbData.Rsr)
workingRoot, err = doltdocs.UpdateRootWithDocs(ctx, workingRoot, docs)
if err != nil {
return nil, err
}
working, err = doltdocs.UpdateRootWithDocs(ctx, working, docs)
if err != nil {
return nil, err
}
_, err = env.UpdateWorkingRoot(ctx, dbData.Ddb, dbData.Rsw, working)
_, err = env.UpdateWorkingRoot(ctx, dbData.Ddb, dbData.Rsw, workingRoot)
if err != nil {
return nil, err
}

29
go/libraries/doltcore/env/actions/staged.go vendored
View File

@@ -19,6 +19,7 @@ import (
"errors"
"github.com/dolthub/dolt/go/libraries/doltcore/doltdocs"
"github.com/dolthub/dolt/go/libraries/doltcore/ref"
"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
"github.com/dolthub/dolt/go/libraries/doltcore/env"
@@ -51,13 +52,13 @@ func StageTables(ctx context.Context, dbData env.DbData, tbls []string) error {
err = stageTables(ctx, ddb, rsw, tables, staged, working)
if err != nil {
env.ResetWorkingDocsToStagedDocs(ctx, ddb, rsr, rsw)
env.ResetWorkingDocsToStagedDocs(ctx, ddb, working, rsr, rsw)
return err
}
return nil
}
func StageAllTables(ctx context.Context, dbData env.DbData) error {
func StageAllTables(ctx context.Context, working *doltdb.RootValue, dbData env.DbData) error {
ddb := dbData.Ddb
rsr := dbData.Rsr
rsw := dbData.Rsw
@@ -68,11 +69,6 @@ func StageAllTables(ctx context.Context, dbData env.DbData) error {
return err
}
working, err := env.WorkingRoot(ctx, ddb, rsr)
if err != nil {
return err
}
docs, err := drw.GetDocsOnDisk()
if err != nil {
return err
@@ -90,7 +86,7 @@ func StageAllTables(ctx context.Context, dbData env.DbData) error {
err = stageTables(ctx, ddb, rsw, tbls, staged, working)
if err != nil {
env.ResetWorkingDocsToStagedDocs(ctx, ddb, rsr, rsw)
env.ResetWorkingDocsToStagedDocs(ctx, ddb, working, rsr, rsw)
return err
}
@@ -217,7 +213,7 @@ func getRoots(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader,
case doltdb.StagedRoot:
root, err = env.StagedRoot(ctx, ddb, rsr)
case doltdb.WorkingRoot:
root, err = env.WorkingRoot(ctx, ddb, rsr)
root, err = getWorkingRoot(ctx, ddb, rsr)
case doltdb.HeadRoot:
root, err = env.HeadRoot(ctx, ddb, rsr)
default:
@@ -233,3 +229,18 @@ func getRoots(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader,
return roots, nil
}
// TODO: get rid of this
func getWorkingRoot(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (*doltdb.RootValue, error) {
wsRef, err := ref.WorkingSetRefForHead(rsr.CWBHeadRef())
if err != nil {
return nil, err
}
ws, err := ddb.ResolveWorkingSet(ctx, wsRef)
if err != nil {
return nil, err
}
return ws.RootValue(), nil
}

19
go/libraries/doltcore/env/dolt_docs.go vendored
View File

@@ -22,12 +22,13 @@ import (
// ResetWorkingDocsToStagedDocs resets the `dolt_docs` table on the working root to match the staged root.
// If the `dolt_docs` table does not exist on the staged root, it will be removed from the working root.
func ResetWorkingDocsToStagedDocs(ctx context.Context, ddb *doltdb.DoltDB, rsr RepoStateReader, rsw RepoStateWriter) error {
wrkRoot, err := WorkingRoot(ctx, ddb, rsr)
if err != nil {
return err
}
func ResetWorkingDocsToStagedDocs(
ctx context.Context,
ddb *doltdb.DoltDB,
workingRoot *doltdb.RootValue,
rsr RepoStateReader,
rsw RepoStateWriter,
) error {
stgRoot, err := StagedRoot(ctx, ddb, rsr)
if err != nil {
return err
@@ -38,13 +39,13 @@ func ResetWorkingDocsToStagedDocs(ctx context.Context, ddb *doltdb.DoltDB, rsr R
return err
}
_, wrkDocsFound, err := wrkRoot.GetTable(ctx, doltdb.DocTableName)
_, wrkDocsFound, err := workingRoot.GetTable(ctx, doltdb.DocTableName)
if err != nil {
return err
}
if wrkDocsFound && !stgDocsFound {
newWrkRoot, err := wrkRoot.RemoveTables(ctx, doltdb.DocTableName)
newWrkRoot, err := workingRoot.RemoveTables(ctx, doltdb.DocTableName)
if err != nil {
return err
}
@@ -53,7 +54,7 @@ func ResetWorkingDocsToStagedDocs(ctx context.Context, ddb *doltdb.DoltDB, rsr R
}
if stgDocsFound {
newWrkRoot, err := wrkRoot.PutTable(ctx, doltdb.DocTableName, stgDocTbl)
newWrkRoot, err := workingRoot.PutTable(ctx, doltdb.DocTableName, stgDocTbl)
if err != nil {
return err
}

35
go/libraries/doltcore/env/repo_state.go vendored
View File

@@ -202,11 +202,6 @@ func (rs *RepoState) GetMergeCommit() string {
return rs.Merge.Commit
}
// Returns the working root.
func WorkingRoot(ctx context.Context, ddb *doltdb.DoltDB, rsr RepoStateReader) (*doltdb.RootValue, error) {
return ddb.ReadRootValue(ctx, rsr.WorkingHash())
}
// Updates the working root.
func UpdateWorkingRoot(ctx context.Context, ddb *doltdb.DoltDB, rsw RepoStateWriter, newRoot *doltdb.RootValue) (hash.Hash, error) {
h, err := ddb.WriteRootValue(ctx, newRoot)
@@ -270,41 +265,13 @@ func UpdateStagedRootWithVErr(ddb *doltdb.DoltDB, rsw RepoStateWriter, updatedRo
return nil
}
func GetRoots(ctx context.Context, ddb *doltdb.DoltDB, rsr RepoStateReader) (working *doltdb.RootValue, staged *doltdb.RootValue, head *doltdb.RootValue, err error) {
working, err = WorkingRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, nil, err
}
staged, err = StagedRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, nil, err
}
head, err = HeadRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, nil, err
}
return working, staged, head, nil
}
func MergeWouldStompChanges(ctx context.Context, mergeCommit *doltdb.Commit, dbData DbData) ([]string, map[string]hash.Hash, error) {
func MergeWouldStompChanges(ctx context.Context, workingRoot *doltdb.RootValue, mergeCommit *doltdb.Commit, dbData DbData) ([]string, map[string]hash.Hash, error) {
headRoot, err := HeadRoot(ctx, dbData.Ddb, dbData.Rsr)
if err != nil {
return nil, nil, err
}
workingRoot, err := WorkingRoot(ctx, dbData.Ddb, dbData.Rsr)
if err != nil {
return nil, nil, err
}
mergeRoot, err := mergeCommit.GetRootValue()
if err != nil {

26
go/libraries/doltcore/merge/merge.go
View File

@@ -19,6 +19,7 @@ import (
"errors"
"fmt"
"github.com/dolthub/dolt/go/libraries/doltcore/ref"
"golang.org/x/sync/errgroup"
"github.com/dolthub/dolt/go/libraries/doltcore/diff"
@@ -840,6 +841,21 @@ func MergeRoots(ctx context.Context, ourRoot, theirRoot, ancRoot *doltdb.RootVal
return newRoot, tblToStats, nil
}
func getWorkingRoot(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (*doltdb.RootValue, error) {
wsRef, err := ref.WorkingSetRefForHead(rsr.CWBHeadRef())
if err != nil {
return nil, err
}
ws, err := ddb.ResolveWorkingSet(ctx, wsRef)
if err != nil {
return nil, err
}
return ws.RootValue(), nil
}
// TODO: pass in roots here instead
func GetTablesInConflict(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (workingInConflict, stagedInConflict, headInConflict []string, err error) {
var headRoot, stagedRoot, workingRoot *doltdb.RootValue
@@ -855,8 +871,7 @@ func GetTablesInConflict(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoSt
return nil, nil, nil, err
}
workingRoot, err = env.WorkingRoot(ctx, ddb, rsr)
workingRoot, err = getWorkingRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, nil, err
}
@@ -882,16 +897,11 @@ func GetTablesInConflict(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoSt
return workingInConflict, stagedInConflict, headInConflict, err
}
func GetDocsInConflict(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, drw env.DocsReadWriter) (*diff.DocDiffs, error) {
func GetDocsInConflict(ctx context.Context, workingRoot *doltdb.RootValue, drw env.DocsReadWriter) (*diff.DocDiffs, error) {
docs, err := drw.GetDocsOnDisk()
if err != nil {
return nil, err
}
workingRoot, err := env.WorkingRoot(ctx, ddb, rsr)
if err != nil {
return nil, err
}
return diff.NewDocDiffs(ctx, workingRoot, nil, docs)
}

2
go/libraries/doltcore/sqle/database.go
View File

@@ -280,7 +280,7 @@ func (db Database) GetTableInsensitiveWithRoot(ctx *sql.Context, root *doltdb.Ro
case doltdb.CommitAncestorsTableName:
dt, found = dtables.NewCommitAncestorsTable(ctx, db.ddb), true
case doltdb.StatusTableName:
dt, found = dtables.NewStatusTable(ctx, db.ddb, db.rsr, db.drw), true
dt, found = dtables.NewStatusTable(ctx, db.name, db.ddb, db.rsr, db.drw), true
}
if found {
return dt, found, nil

45
go/libraries/doltcore/sqle/dfunctions/dolt_checkout.go
View File

@@ -154,29 +154,32 @@ func checkoutBranch(ctx *sql.Context, dbData env.DbData, branchName string) erro
return ErrEmptyBranchName
}
err := actions.CheckoutBranchWithoutDocs(ctx, dbData, branchName)
return nil
if err != nil {
if err == doltdb.ErrBranchNotFound {
return fmt.Errorf("fatal: Branch '%s' not found.", branchName)
} else if doltdb.IsRootValUnreachable(err) {
rt := doltdb.GetUnreachableRootType(err)
return fmt.Errorf("error: unable to read the %s", rt.String())
} else if actions.IsCheckoutWouldOverwrite(err) {
tbls := actions.CheckoutWouldOverwriteTables(err)
msg := "error: Your local changes to the following tables would be overwritten by checkout: \n"
for _, tbl := range tbls {
msg = msg + tbl + "\n"
}
return errors.New(msg)
} else if err == doltdb.ErrAlreadyOnBranch {
return nil // No need to return an error if on the same branch
} else {
return fmt.Errorf("fatal: Unexpected error checking out branch '%s'", branchName)
}
}
// TODO: fix me
//err := actions.CheckoutBranch(ctx, dbData, branchName)
return updateHeadAndWorkingSessionVars(ctx, dbData)
// if err != nil {
// if err == doltdb.ErrBranchNotFound {
// return fmt.Errorf("fatal: Branch '%s' not found.", branchName)
// } else if doltdb.IsRootValUnreachable(err) {
// rt := doltdb.GetUnreachableRootType(err)
// return fmt.Errorf("error: unable to read the %s", rt.String())
// } else if actions.IsCheckoutWouldOverwrite(err) {
// tbls := actions.CheckoutWouldOverwriteTables(err)
// msg := "error: Your local changes to the following tables would be overwritten by checkout: \n"
// for _, tbl := range tbls {
// msg = msg + tbl + "\n"
// }
// return errors.New(msg)
// } else if err == doltdb.ErrAlreadyOnBranch {
// return nil // No need to return an error if on the same branch
// } else {
// return fmt.Errorf("fatal: Unexpected error checking out branch '%s'", branchName)
// }
// }
//
// return updateHeadAndWorkingSessionVars(ctx, dbData)
}
func checkoutTables(ctx *sql.Context, dbData env.DbData, tables []string) error {

27
go/libraries/doltcore/sqle/dfunctions/dolt_reset.go
View File

@@ -18,10 +18,11 @@ import (
"fmt"
"strings"
"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
"github.com/dolthub/dolt/go/libraries/doltcore/env"
"github.com/dolthub/go-mysql-server/sql"
"github.com/dolthub/dolt/go/cmd/dolt/cli"
"github.com/dolthub/dolt/go/libraries/doltcore/env"
"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
)
@@ -64,7 +65,9 @@ func (d DoltResetFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
}
// Get all the needed roots.
working, staged, head, err := env.GetRoots(ctx, dbData.Ddb, dbData.Rsr)
workingRoot, _ := dSess.GetRoot(dbName)
staged, head, err := GetRoots(ctx, dbData.Ddb, dbData.Rsr)
if err != nil {
return 1, err
}
@@ -78,7 +81,7 @@ func (d DoltResetFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
arg = apr.Arg(0)
}
h, err := actions.ResetHardTables(ctx, dbData, arg, working, staged, head)
h, err := actions.ResetHardTables(ctx, dbData, arg, workingRoot, staged, head)
if err != nil {
return 1, err
}
@@ -114,6 +117,24 @@ func (d DoltResetFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
return 0, nil
}
func GetRoots(ctx *sql.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (staged *doltdb.RootValue, head *doltdb.RootValue, err error) {
staged, err = env.StagedRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, err
}
// TODO: replace with session var
head, err = env.HeadRoot(ctx, ddb, rsr)
if err != nil {
return nil, nil, err
}
return staged, head, nil
}
func (d DoltResetFunc) Resolved() bool {
for _, child := range d.Children() {
if !child.Resolved() {

29
go/libraries/doltcore/sqle/dtables/status_table.go
View File

@@ -18,6 +18,7 @@ import (
"fmt"
"io"
dsqle "github.com/dolthub/dolt/go/libraries/doltcore/sqle"
"github.com/dolthub/go-mysql-server/sql"
"github.com/dolthub/dolt/go/libraries/doltcore/diff"
@@ -30,9 +31,10 @@ import (
// StatusTable is a sql.Table implementation that implements a system table which shows the dolt branches
type StatusTable struct {
ddb *doltdb.DoltDB
rsr env.RepoStateReader
drw env.DocsReadWriter
ddb *doltdb.DoltDB
rsr env.RepoStateReader
drw env.DocsReadWriter
dbName string
}
func (s StatusTable) Name() string {
@@ -60,8 +62,13 @@ func (s StatusTable) PartitionRows(context *sql.Context, _ sql.Partition) (sql.R
}
// NewStatusTable creates a StatusTable
func NewStatusTable(_ *sql.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, drw env.DocsReadWriter) sql.Table {
return &StatusTable{ddb: ddb, rsr: rsr, drw: drw}
func NewStatusTable(_ *sql.Context, dbName string, ddb *doltdb.DoltDB, rsr env.RepoStateReader, drw env.DocsReadWriter) sql.Table {
return &StatusTable{
ddb: ddb,
dbName: dbName,
rsr: rsr,
drw: drw,
}
}
// StatusIter is a sql.RowItr implementation which iterates over each commit as if it's a row in the table.
@@ -77,13 +84,19 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) {
rsr := st.rsr
drw := st.drw
stagedTables, unstagedTables, err := diff.GetStagedUnstagedTableDeltas(ctx, ddb, rsr)
sess := dsqle.DSessFromSess(ctx.Session)
workingRoot, ok := sess.GetRoot(st.dbName)
if !ok {
return nil, fmt.Errorf("No root found in session")
}
stagedTables, unstagedTables, err := diff.GetStagedUnstagedTableDeltas(ctx, ddb, workingRoot, rsr)
if err != nil {
return &StatusItr{}, err
}
stagedDocDiffs, unStagedDocDiffs, err := diff.GetDocDiffs(ctx, ddb, rsr, drw)
stagedDocDiffs, unStagedDocDiffs, err := diff.GetDocDiffs(ctx, ddb, workingRoot, rsr, drw)
if err != nil {
return &StatusItr{}, err
@@ -95,7 +108,7 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) {
return &StatusItr{}, err
}
workingDocsInConflict, err := merge.GetDocsInConflict(ctx, ddb, rsr, drw)
workingDocsInConflict, err := merge.GetDocsInConflict(ctx, workingRoot, drw)
if err != nil {
return &StatusItr{}, err