dolt_stash stored procedure

go/cmd/dolt/cli/arg_parser_helpers.go

@@ -105,6 +105,13 @@ func CreateMergeArgParser() *argparser.ArgParser {
 	return ap
 }
 
+func CreateStashArgParser() *argparser.ArgParser {
+	ap := argparser.NewArgParserWithMaxArgs("stash", 3)
+	ap.SupportsFlag(IncludeUntrackedFlag, "u", "Untracked tables are also stashed.")
+	ap.SupportsFlag(AllFlag, "a", "All tables are stashed, including untracked and ignored tables.")
+	return ap
+}
+
 func CreateRebaseArgParser() *argparser.ArgParser {
 	ap := argparser.NewArgParserWithMaxArgs("rebase", 1)
 	ap.TooManyArgsErrorFunc = func(receivedArgs []string) error {

go/cmd/dolt/cli/flags.go

@@ -42,6 +42,7 @@ const (
 	GraphFlag            = "graph"
 	HardResetParam       = "hard"
 	HostFlag             = "host"
+	IncludeUntrackedFlag = "include-untracked"
 	InteractiveFlag      = "interactive"
 	ListFlag             = "list"
 	MergesFlag           = "merges"

go/cmd/dolt/commands/stashcmds/clear.go

@@ -17,6 +17,8 @@ package stashcmds
 import (
 	"context"
 
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands"
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
@@ -77,7 +79,7 @@ func (cmd StashClearCmd) Exec(ctx context.Context, commandStr string, args []str
 		return 1
 	}
 
-	err := dEnv.DoltDB(ctx).RemoveAllStashes(ctx)
+	err := dEnv.DoltDB(ctx).RemoveAllStashes(ctx, doltdb.DoltCliRef)
 	if err != nil {
 		return commands.HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
 	}

go/cmd/dolt/commands/stashcmds/drop.go

@@ -20,6 +20,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands"
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
@@ -95,12 +97,12 @@ func (cmd StashDropCmd) Exec(ctx context.Context, commandStr string, args []stri
 }
 
 func dropStashAtIdx(ctx context.Context, dEnv *env.DoltEnv, idx int) error {
-	stashHash, err := dEnv.DoltDB(ctx).GetStashHashAtIdx(ctx, idx)
+	stashHash, err := dEnv.DoltDB(ctx).GetStashHashAtIdx(ctx, idx, doltdb.DoltCliRef)
 	if err != nil {
 		return err
 	}
 
-	err = dEnv.DoltDB(ctx).RemoveStashAtIdx(ctx, idx)
+	err = dEnv.DoltDB(ctx).RemoveStashAtIdx(ctx, idx, doltdb.DoltCliRef)
 	if err != nil {
 		return err
 	}

go/cmd/dolt/commands/stashcmds/list.go

@@ -80,7 +80,7 @@ func (cmd StashListCmd) Exec(ctx context.Context, commandStr string, args []stri
 }
 
 func listStashes(ctx context.Context, dEnv *env.DoltEnv) error {
-	stashes, err := dEnv.DoltDB(ctx).GetStashes(ctx)
+	stashes, err := dEnv.DoltDB(ctx).GetCommandLineStashes(ctx)
 	if err != nil {
 		return err
 	}
@@ -90,7 +90,7 @@ func listStashes(ctx context.Context, dEnv *env.DoltEnv) error {
 		if err != nil {
 			return err
 		}
-		cli.Println(fmt.Sprintf("%s: WIP on %s: %s %s", stash.Name, stash.BranchName, commitHash.String(), stash.Description))
+		cli.Println(fmt.Sprintf("%s: WIP on %s: %s %s", stash.Name, stash.BranchReference, commitHash.String(), stash.Description))
 	}
 	return nil
 }

go/cmd/dolt/commands/stashcmds/pop.go

@@ -125,7 +125,7 @@ func (cmd StashPopCmd) Exec(ctx context.Context, commandStr string, args []strin
 }
 
 func applyStashAtIdx(ctx *sql.Context, dEnv *env.DoltEnv, curWorkingRoot doltdb.RootValue, idx int) (bool, error) {
-	stashRoot, headCommit, meta, err := dEnv.DoltDB(ctx).GetStashRootAndHeadCommitAtIdx(ctx, idx)
+	stashRoot, headCommit, meta, err := dEnv.DoltDB(ctx).GetStashRootAndHeadCommitAtIdx(ctx, idx, doltdb.DoltCliRef)
 	if err != nil {
 		return false, err
 	}

go/cmd/dolt/commands/stashcmds/stash.go

@@ -39,11 +39,6 @@ var StashCommands = cli.NewSubCommandHandlerWithUnspecified("stash", "Stash the
 	StashPopCmd{},
 })
 
-const (
-	IncludeUntrackedFlag = "include-untracked"
-	AllFlag              = "all"
-)
-
 var stashDocs = cli.CommandDocumentationContent{
 	ShortDesc: "Stash the changes in a dirty working directory away.",
 	LongDesc: `Use dolt stash when you want to record the current state of the working directory and the index, but want to go back to a clean working directory. 
@@ -78,8 +73,8 @@ func (cmd StashCmd) Docs() *cli.CommandDocumentation {
 
 func (cmd StashCmd) ArgParser() *argparser.ArgParser {
 	ap := argparser.NewArgParserWithMaxArgs(cmd.Name(), 0)
-	ap.SupportsFlag(IncludeUntrackedFlag, "u", "Untracked tables are also stashed.")
-	ap.SupportsFlag(AllFlag, "a", "All tables are stashed, including untracked and ignored tables.")
+	ap.SupportsFlag(cli.IncludeUntrackedFlag, "u", "Untracked tables are also stashed.")
+	ap.SupportsFlag(cli.AllFlag, "a", "All tables are stashed, including untracked and ignored tables.")
 	return ap
 }
 
@@ -144,7 +139,7 @@ func hasLocalChanges(ctx context.Context, dEnv *env.DoltEnv, roots doltdb.Roots,
 	}
 
 	// There are unstaged changes, is --all set? If so, nothing else matters. Stash them.
-	if apr.Contains(AllFlag) {
+	if apr.Contains(cli.AllFlag) {
 		return true, nil
 	}
 
@@ -159,7 +154,7 @@ func hasLocalChanges(ctx context.Context, dEnv *env.DoltEnv, roots doltdb.Roots,
 	}
 
 	// There are unignored, unstaged tables. Is --include-untracked set. If so, nothing else matters. Stash them.
-	if apr.Contains(IncludeUntrackedFlag) {
+	if apr.Contains(cli.IncludeUntrackedFlag) {
 		return true, nil
 	}
 
@@ -207,13 +202,13 @@ func stashChanges(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars
 	// stage untracked files to include them in the stash,
 	// but do not include them in added table set,
 	// because they should not be staged when popped.
-	if apr.Contains(IncludeUntrackedFlag) || apr.Contains(AllFlag) {
+	if apr.Contains(cli.IncludeUntrackedFlag) || apr.Contains(cli.AllFlag) {
 		allTblsToBeStashed, err = doltdb.UnionTableNames(ctx, roots.Staged, roots.Working)
 		if err != nil {
 			return err
 		}
 
-		roots, err = actions.StageTables(ctx, roots, allTblsToBeStashed, !apr.Contains(AllFlag))
+		roots, err = actions.StageTables(ctx, roots, allTblsToBeStashed, !apr.Contains(cli.AllFlag))
 		if err != nil {
 			return err
 		}
@@ -242,7 +237,7 @@ func stashChanges(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars
 		return err
 	}
 
-	err = dEnv.DoltDB(ctx).AddStash(ctx, commit, roots.Staged, datas.NewStashMeta(curBranchName, commitMeta.Description, doltdb.FlattenTableNames(addedTblsToStage)))
+	err = dEnv.DoltDB(ctx).AddStash(ctx, commit, roots.Staged, datas.NewStashMeta(curBranchName, commitMeta.Description, doltdb.FlattenTableNames(addedTblsToStage)), doltdb.DoltCliRef)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/doltdb/doltdb.go

@@ -2076,8 +2076,8 @@ func (ddb *DoltDB) GetBranchesByRootHash(ctx context.Context, rootHash hash.Hash
 // AddStash takes current branch head commit, stash root value and stash metadata to create a new stash.
 // It stores the new stash object in stash list Dataset, which can be created if it does not exist.
 // Otherwise, it updates the stash list Dataset as there can only be one stashes Dataset.
-func (ddb *DoltDB) AddStash(ctx context.Context, head *Commit, stash RootValue, meta *datas.StashMeta) error {
-	stashesDS, err := ddb.db.GetDataset(ctx, ref.NewStashRef().String())
+func (ddb *DoltDB) AddStash(ctx context.Context, head *Commit, stash RootValue, meta *datas.StashMeta, stashName string) error {
+	stashesDS, err := ddb.db.GetDataset(ctx, ref.NewStashRef(stashName).String())
 	if err != nil {
 		return err
 	}
@@ -2159,8 +2159,8 @@ func (ddb *DoltDB) GetStatistics(ctx context.Context) (prolly.Map, error) {
 // It removes a Stash message from stash list Dataset, which cannot be performed
 // by database Delete function. This function removes a single stash only and stash
 // list dataset does not get removed if there are no entries left.
-func (ddb *DoltDB) RemoveStashAtIdx(ctx context.Context, idx int) error {
-	stashesDS, err := ddb.db.GetDataset(ctx, ref.NewStashRef().String())
+func (ddb *DoltDB) RemoveStashAtIdx(ctx context.Context, idx int, stashName string) error {
+	stashesDS, err := ddb.db.GetDataset(ctx, ref.NewStashRef(stashName).String())
 	if err != nil {
 		return err
 	}
@@ -2186,7 +2186,7 @@ func (ddb *DoltDB) RemoveStashAtIdx(ctx context.Context, idx int) error {
 	}
 	// if the stash list is empty, remove the stash list Dataset from the database
 	if stashListCount == 0 {
-		return ddb.RemoveAllStashes(ctx)
+		return ddb.RemoveAllStashes(ctx, stashName)
 	}
 
 	stashesDS, err = ddb.db.UpdateStashList(ctx, stashesDS, stashListAddr)
@@ -2195,31 +2195,64 @@ func (ddb *DoltDB) RemoveStashAtIdx(ctx context.Context, idx int) error {
 
 // RemoveAllStashes removes the stash list Dataset from the database,
 // which equivalent to removing Stash entries from the stash list.
-func (ddb *DoltDB) RemoveAllStashes(ctx context.Context) error {
-	err := ddb.deleteRef(ctx, ref.NewStashRef(), nil, "")
+func (ddb *DoltDB) RemoveAllStashes(ctx context.Context, stashName string) error {
+	err := ddb.deleteRef(ctx, ref.NewStashRef(stashName), nil, "")
 	if err == ErrBranchNotFound {
 		return nil
 	}
 	return err
 }
 
+var stashRefFilter = map[ref.RefType]struct{}{ref.StashRefType: {}}
+
 // GetStashes returns array of Stash objects containing all stash entries in the stash list Dataset.
 func (ddb *DoltDB) GetStashes(ctx context.Context) ([]*Stash, error) {
-	stashesDS, err := ddb.db.GetDataset(ctx, ref.NewStashRef().String())
+	stashRefs, err := ddb.GetRefsOfType(ctx, stashRefFilter)
 	if err != nil {
 		return nil, err
 	}
+	var stashList []*Stash
+	for _, stash := range stashRefs {
+		reference := ref.NewStashRef(stash.String()).String()
+		stashDS, err := ddb.db.GetDataset(ctx, reference)
+		if err != nil {
+			return nil, err
+		}
+		newStashes, err := getStashList(ctx, stashDS, ddb.vrw, ddb.NodeStore(), reference)
+		if err != nil {
+			return nil, err
+		}
+		stashList = append(stashList, newStashes...)
+	}
 
-	if !stashesDS.HasHead() {
-		return []*Stash{}, nil
+	return stashList, nil
+}
+
+func (ddb *DoltDB) GetCommandLineStashes(ctx context.Context) ([]*Stash, error) {
+	var stashList []*Stash
+	reference := ref.NewStashRef(DoltCliRef).String()
+	stashDS, err := ddb.db.GetDataset(ctx, reference)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the refs/stashes/dolt-cli is empty, hasHead will return false.
+	// In this case we want to end early and return no stashes.
+	if !stashDS.HasHead() {
+		return nil, nil
+	}
+	newStashes, err := getStashList(ctx, stashDS, ddb.vrw, ddb.NodeStore(), reference)
+	if err != nil {
+		return nil, err
 	}
+	stashList = append(stashList, newStashes...)
 
-	return getStashList(ctx, stashesDS, ddb.vrw, ddb.NodeStore())
+	return stashList, nil
 }
 
 // GetStashHashAtIdx returns hash address only of the stash at given index.
-func (ddb *DoltDB) GetStashHashAtIdx(ctx context.Context, idx int) (hash.Hash, error) {
-	ds, err := ddb.db.GetDataset(ctx, ref.NewStashRef().String())
+func (ddb *DoltDB) GetStashHashAtIdx(ctx context.Context, idx int, stashName string) (hash.Hash, error) {
+	ds, err := ddb.db.GetDataset(ctx, ref.NewStashRef(stashName).String())
 	if err != nil {
 		return hash.Hash{}, err
 	}
@@ -2233,8 +2266,8 @@ func (ddb *DoltDB) GetStashHashAtIdx(ctx context.Context, idx int) (hash.Hash, e
 
 // GetStashRootAndHeadCommitAtIdx returns root value of stash working set and head commit of the branch that the stash was made on
 // of the stash at given index.
-func (ddb *DoltDB) GetStashRootAndHeadCommitAtIdx(ctx context.Context, idx int) (RootValue, *Commit, *datas.StashMeta, error) {
-	ds, err := ddb.db.GetDataset(ctx, ref.NewStashRef().String())
+func (ddb *DoltDB) GetStashRootAndHeadCommitAtIdx(ctx context.Context, idx int, stashName string) (RootValue, *Commit, *datas.StashMeta, error) {
+	ds, err := ddb.db.GetDataset(ctx, ref.NewStashRef(stashName).String())
 	if err != nil {
 		return nil, nil, nil, err
 	}

go/libraries/doltcore/doltdb/stash.go

@@ -26,14 +26,19 @@ import (
 )
 
 type Stash struct {
-	Name        string
-	BranchName  string
-	Description string
-	HeadCommit  *Commit
+	Name            string
+	BranchReference string
+	Description     string
+	HeadCommit      *Commit
+	StashReference  string
 }
 
+const (
+	DoltCliRef = "dolt-cli"
+)
+
 // getStashList returns array of Stash objects containing all stash entries in the stash list map.
-func getStashList(ctx context.Context, ds datas.Dataset, vrw types.ValueReadWriter, ns tree.NodeStore) ([]*Stash, error) {
+func getStashList(ctx context.Context, ds datas.Dataset, vrw types.ValueReadWriter, ns tree.NodeStore, reference string) ([]*Stash, error) {
 	v, ok := ds.MaybeHead()
 	if !ok {
 		return nil, errors.New("stashes not found")
@@ -73,8 +78,9 @@ func getStashList(ctx context.Context, ds datas.Dataset, vrw types.ValueReadWrit
 		}
 
 		s.HeadCommit = headCommit
-		s.BranchName = meta.BranchName
+		s.BranchReference = meta.BranchName
 		s.Description = meta.Description
+		s.StashReference = reference
 
 		sl[i] = &s
 	}

go/libraries/doltcore/doltdb/system_table.go

@@ -221,6 +221,7 @@ var getGeneratedSystemTables = func() []string {
 		GetRemotesTableName(),
 		GetHelpTableName(),
 		GetBackupsTableName(),
+		GetStashesTableName(),
 	}
 }
 
@@ -393,6 +394,10 @@ var GetBackupsTableName = func() string {
 	return BackupsTableName
 }
 
+var GetStashesTableName = func() string {
+	return StashesTableName
+}
+
 const (
 	// LogTableName is the log system table name
 	LogTableName = "dolt_log"
@@ -444,6 +449,9 @@ const (
 
 	// StatisticsTableName is the statistics system table name
 	StatisticsTableName = "dolt_statistics"
+
+	// StashesTableName is the stashes system table name
+	StashesTableName = "dolt_stashes"
 )
 
 const (

go/libraries/doltcore/ref/ref.go

@@ -197,7 +197,7 @@ func Parse(str string) (DoltRef, error) {
 			str = str[len(prefix):]
 			switch rType {
 			case StashRefType:
-				return NewStashRef(), nil
+				return NewStashRef(str), nil
 			default:
 				panic("unknown type " + rType)
 			}

go/libraries/doltcore/ref/stash_ref.go

@@ -18,18 +18,14 @@ import (
 	"strings"
 )
 
-// StashRefName is a dummy name, and there cannot be more than one stash ref.
-const StashRefName = "stashes"
-
 type StashRef struct {
 	stash string
 }
 
 var _ DoltRef = StashRef{}
 
-// NewStashRef creates a reference to a stashes list. There cannot be more than one stashRef.
-func NewStashRef() StashRef {
-	stashName := StashRefName
+// NewStashRef creates a reference to a stashes list.
+func NewStashRef(stashName string) StashRef {
 	if IsRef(stashName) {
 		prefix := PrefixForType(StashRefType)
 		if strings.HasPrefix(stashName, prefix) {

go/libraries/doltcore/sqle/database.go

@@ -582,6 +582,14 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
 		if !resolve.UseSearchPath || isDoltgresSystemTable {
 			dt, found = dtables.NewRemotesTable(ctx, db.ddb, lwrName), true
 		}
+	case doltdb.StashesTableName, doltdb.GetStashesTableName():
+		isDoltgresSystemTable, err := resolve.IsDoltgresSystemTable(ctx, tname, root)
+		if err != nil {
+			return nil, false, err
+		}
+		if !resolve.UseSearchPath || isDoltgresSystemTable {
+			dt, found = dtables.NewStashesTable(ctx, db.ddb, lwrName), true
+		}
 	case doltdb.CommitsTableName, doltdb.GetCommitsTableName():
 		isDoltgresSystemTable, err := resolve.IsDoltgresSystemTable(ctx, tname, root)
 		if err != nil {