From 53559288fbb5bac85f6756b7e22985df9edd8ce3 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Wed, 22 Jan 2025 14:34:16 -0800 Subject: [PATCH 01/17] Avoid loading DB for commands where it's not necessary. --- go/cmd/dolt/commands/branch.go | 7 ++- go/cmd/dolt/commands/show.go | 4 ++ go/cmd/dolt/commands/sql.go | 12 ++++++ go/cmd/dolt/commands/utils.go | 24 ++++++++++- go/cmd/dolt/dolt.go | 46 +++++++++++++++++++- go/libraries/doltcore/env/environment.go | 16 ++++++- go/libraries/doltcore/env/multi_repo_env.go | 47 +++++++++++++++++---- 7 files changed, 143 insertions(+), 13 deletions(-) diff --git a/go/cmd/dolt/commands/branch.go b/go/cmd/dolt/commands/branch.go index c4377e75c03..2f6bd56d6a7 100644 --- a/go/cmd/dolt/commands/branch.go +++ b/go/cmd/dolt/commands/branch.go @@ -110,9 +110,10 @@ func (cmd BranchCmd) Exec(ctx context.Context, commandStr string, args []string, return status } + errorBuilder := errhand.BuildDError("error: failed to create query engine") queryEngine, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx) if err != nil { - return HandleVErrAndExitCode(errhand.BuildDError("error: failed to create query engine").AddCause(err).Build(), nil) + return HandleVErrAndExitCode(errorBuilder.AddCause(err).Build(), nil) } if closeFunc != nil { @@ -138,6 +139,10 @@ func (cmd BranchCmd) Exec(ctx context.Context, commandStr string, args []string, case apr.Contains(showCurrentFlag): return printCurrentBranch(sqlCtx, queryEngine) case apr.Contains(datasetsFlag): + dEnv.ReloadDB(ctx) + if HandleDEnvErrorsAndExitCode(errorBuilder, dEnv, usage) { + return 1 + } return printAllDatasets(ctx, dEnv) case apr.NArg() > 0: return createBranch(sqlCtx, queryEngine, apr, args, usage) diff --git a/go/cmd/dolt/commands/show.go b/go/cmd/dolt/commands/show.go index 00e66d093e8..da259c953f9 100644 --- a/go/cmd/dolt/commands/show.go +++ b/go/cmd/dolt/commands/show.go @@ -158,6 +158,10 @@ func (cmd ShowCmd) Exec(ctx context.Context, commandStr string, args []string, d cli.PrintErrln("`dolt show --no-pretty` or `dolt show (BRANCHNAME)` is not supported when using old LD_1 storage format.") return 1 } + dEnv.ReloadDB(ctx) + if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { + return 1 + } } specRefs := opts.specRefs diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go index 914141da163..6f7a5fb4fd3 100644 --- a/go/cmd/dolt/commands/sql.go +++ b/go/cmd/dolt/commands/sql.go @@ -218,12 +218,24 @@ func (cmd SqlCmd) Exec(ctx context.Context, commandStr string, args []string, dE if query, queryOK := apr.GetValue(QueryFlag); queryOK { if apr.Contains(saveFlag) { + dEnv.ReloadDB(ctx) + if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { + return 1 + } return execSaveQuery(sqlCtx, dEnv, queryist, apr, query, format, usage) } return queryMode(sqlCtx, queryist, apr, query, format, usage) } else if savedQueryName, exOk := apr.GetValue(executeFlag); exOk { + dEnv.ReloadDB(ctx) + if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { + return 1 + } return executeSavedQuery(sqlCtx, queryist, dEnv, savedQueryName, format, usage) } else if apr.Contains(listSavedFlag) { + dEnv.ReloadDB(ctx) + if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { + return 1 + } return listSavedQueries(sqlCtx, queryist, dEnv, format, usage) } else { // Run in either batch mode for piped input, or shell mode for interactive diff --git a/go/cmd/dolt/commands/utils.go b/go/cmd/dolt/commands/utils.go index f1b9a55eed1..4f45e35e4f6 100644 --- a/go/cmd/dolt/commands/utils.go +++ b/go/cmd/dolt/commands/utils.go @@ -126,8 +126,9 @@ func NewArgFreeCliContext(ctx context.Context, dEnv *env.DoltEnv, cwd filesys.Fi // SQL queries. ctx, cwdFS, mrEnv, and apr must all be non-nil. func BuildSqlEngineQueryist(ctx context.Context, cwdFS filesys.Filesys, mrEnv *env.MultiRepoEnv, creds *cli.UserPassword, apr *argparser.ArgParseResults) (cli.LateBindQueryist, errhand.VerboseError) { if ctx == nil || cwdFS == nil || mrEnv == nil || creds == nil || apr == nil { - errhand.VerboseErrorFromError(fmt.Errorf("Invariant violated. Nil argument provided to BuildSqlEngineQueryist")) + return nil, errhand.VerboseErrorFromError(fmt.Errorf("Invariant violated. Nil argument provided to BuildSqlEngineQueryist")) } + mrEnv.ReloadDBs(ctx) // We want to know if the user provided us the data-dir flag, but we want to use the abs value used to // create the DoltEnv. This is a little messy. @@ -865,6 +866,27 @@ func HandleVErrAndExitCode(verr errhand.VerboseError, usage cli.UsagePrinter) in return 0 } +func HandleDEnvErrorsAndExitCode(errorBuilder *errhand.DErrorBuilder, dEnv *env.DoltEnv, usage cli.UsagePrinter) bool { + errorCount := 0 + handleError := func(err error) { + if err != nil { + var verboseError errhand.VerboseError + if errorBuilder != nil { + verboseError = errorBuilder.AddCause(err).Build() + } else { + verboseError = errhand.VerboseErrorFromError(err) + } + HandleVErrAndExitCode(verboseError, usage) + errorCount++ + } + } + handleError(dEnv.CfgLoadErr) + handleError(dEnv.RSLoadErr) + handleError(dEnv.DBLoadError) + + return errorCount > 0 +} + // interpolateStoredProcedureCall returns an interpolated query to call |storedProcedureName| with the arguments // |args|. func interpolateStoredProcedureCall(storedProcedureName string, args []string) (string, error) { diff --git a/go/cmd/dolt/dolt.go b/go/cmd/dolt/dolt.go index 9c89eb4fdbd..f23f7365ebf 100644 --- a/go/cmd/dolt/dolt.go +++ b/go/cmd/dolt/dolt.go @@ -154,6 +154,32 @@ var commandsWithoutCliCtx = []cli.Command{ commands.ProfileCmd{}, commands.ArchiveCmd{}, commands.FsckCmd{}, + commands.ConfigCmd{}, +} + +// These commands have one of the following properties: +// - They require that the database does not exist +// - They never access the database +// - They only ever access the database through a CliContext. +// - They always call dEnv.ReloadDB() before accessing the database for the first time. +// In these cases, we can defer loading the database until it's actually needed. +var commandsWithoutDBLoad = []cli.Command{ + commands.InitCmd{}, + commands.CloneCmd{}, + commands.StatusCmd{}, + commands.LsCmd{}, + commands.AddCmd{}, + commands.DiffCmd{}, + commands.ResetCmd{}, + commands.CleanCmd{}, + commands.SqlCmd{VersionStr: doltversion.Version}, + commands.LogCmd{}, + commands.BranchCmd{}, + commands.MergeCmd{}, + commands.ShowCmd{}, + commands.CherryPickCmd{}, + commands.ConfigCmd{}, + credcmds.Commands, } var commandsWithoutGlobalArgSupport = []cli.Command{ @@ -186,6 +212,15 @@ func initCliContext(commandName string) bool { return true } +func eagerlyLoadDB(commandName string) bool { + for _, command := range commandsWithoutDBLoad { + if command.Name() == commandName { + return false + } + } + return true +} + func supportsGlobalArgs(commandName string) bool { for _, command := range commandsWithoutGlobalArgSupport { if command.Name() == commandName { @@ -474,7 +509,13 @@ func runMain() int { args = nil // This is the dEnv passed to sub-commands, and is used to create the multi-repo environment. - dEnv := env.Load(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) + var dEnv *env.DoltEnv + if eagerlyLoadDB(cfg.subCommand) { + dEnv = env.Load(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) + } else { + dEnv = env.LoadWithDeferredDB(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) + } + if dEnv.CfgLoadErr != nil { cli.PrintErrln(color.RedString("Failed to load the global config. %v", dEnv.CfgLoadErr)) return 1 @@ -536,6 +577,9 @@ func runMain() int { cli.PrintErrln("failed to load database names") return 1 } + if eagerlyLoadDB(cfg.subCommand) { + mrEnv.ReloadDBs(ctx) + } _ = mrEnv.Iter(func(dbName string, dEnv *env.DoltEnv) (stop bool, err error) { dsess.DefineSystemVariablesForDB(dbName) return false, nil diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index 69a2bb547e1..deefbf62054 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -170,7 +170,21 @@ func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, v // Load loads the DoltEnv for the .dolt directory determined by resolving the specified urlStr with the specified Filesys. func Load(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { dEnv := LoadWithoutDB(ctx, hdp, fs, version) + LoadDoltDB(ctx, fs, urlStr, dEnv) + return dEnv +} +func LoadWithDeferredDB(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { + dEnv := LoadWithoutDB(ctx, hdp, fs, version) + dEnv.urlStr = urlStr + return dEnv +} + +func (dEnv *DoltEnv) ReloadDB(ctx context.Context) { + LoadDoltDB(ctx, dEnv.FS, dEnv.urlStr, dEnv) +} + +func LoadDoltDB(ctx context.Context, fs filesys.Filesys, urlStr string, dEnv *DoltEnv) { ddb, dbLoadErr := doltdb.LoadDoltDB(ctx, types.Format_Default, urlStr, fs) dEnv.DoltDB = ddb @@ -218,8 +232,6 @@ func Load(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr s dEnv.RSLoadErr = err } } - - return dEnv } func GetDefaultInitBranch(cfg config.ReadableConfig) string { diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index 8055eafd0b5..820bdfaca28 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -187,7 +187,7 @@ func MultiEnvForDirectory( version = dEnv.Version } - newEnv := Load(ctx, GetCurrentUserHomeDir, newFs, doltdb.LocalDirDoltDB, version) + newEnv := LoadWithDeferredDB(ctx, GetCurrentUserHomeDir, newFs, doltdb.LocalDirDoltDB, version) if newEnv.Valid() { envSet[dbfactory.DirToDBName(dir)] = newEnv } else { @@ -205,8 +205,6 @@ func MultiEnvForDirectory( return false }) - enforceSingleFormat(envSet) - // if the current directory database is in our set, add it first so it will be the current database if env, ok := envSet[dbName]; ok && env.Valid() { mrEnv.addEnv(dbName, env) @@ -226,6 +224,31 @@ func MultiEnvForDirectory( return mrEnv, nil } +func (mrEnv *MultiRepoEnv) ReloadDBs( + ctx context.Context, +) { + for _, namedEnv := range mrEnv.envs { + dEnv := namedEnv.env + + if dEnv.DoltDB == nil { + dEnv.ReloadDB(ctx) + } + if !dEnv.Valid() { + dbErr := dEnv.DBLoadError + if dbErr != nil { + if !errors.Is(dbErr, doltdb.ErrMissingDoltDataDir) { + logrus.Warnf("failed to load database at %s with error: %s", dEnv.urlStr, dbErr.Error()) + } + } + cfgErr := dEnv.CfgLoadErr + if cfgErr != nil { + logrus.Warnf("failed to load database configuration at %s with error: %s", dEnv.urlStr, cfgErr.Error()) + } + } + } + mrEnv.envs = enforceSingleFormat(mrEnv.envs) +} + func (mrEnv *MultiRepoEnv) FileSystem() filesys.Filesys { return mrEnv.fs } @@ -327,9 +350,10 @@ func getRepoRootDir(path, pathSeparator string) string { // enforceSingleFormat enforces that constraint that all databases in // a multi-database environment have the same NomsBinFormat. // Databases are removed from the MultiRepoEnv to ensure this is true. -func enforceSingleFormat(envSet map[string]*DoltEnv) { +func enforceSingleFormat(envSet []NamedEnv) []NamedEnv { formats := set.NewEmptyStrSet() - for _, dEnv := range envSet { + for _, namedEnv := range envSet { + dEnv := namedEnv.env formats.Add(dEnv.DoltDB.Format().VersionString()) } @@ -339,17 +363,24 @@ func enforceSingleFormat(envSet map[string]*DoltEnv) { nbf = types.Format_Default.VersionString() } else { // otherwise, pick an arbitrary format - for _, dEnv := range envSet { + for _, namedEnv := range envSet { + dEnv := namedEnv.env nbf = dEnv.DoltDB.Format().VersionString() + break } } + prunedEnvs := make([]NamedEnv, 0, len(envSet)) template := "incompatible format for database '%s'; expected '%s', found '%s'" - for name, dEnv := range envSet { + for _, namedEnv := range envSet { + name := namedEnv.name + dEnv := namedEnv.env found := dEnv.DoltDB.Format().VersionString() if found != nbf { logrus.Infof(template, name, nbf, found) - delete(envSet, name) + } else { + prunedEnvs = append(prunedEnvs, namedEnv) } } + return prunedEnvs } From 1d4a82f0b7490ad70724390fbac510480278f289 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Wed, 22 Jan 2025 21:11:30 -0800 Subject: [PATCH 02/17] Make dEnv.DoltDB private and add an accessor function. --- go/cmd/dolt/cli/command.go | 4 +- go/cmd/dolt/commands/admin/setref.go | 2 +- go/cmd/dolt/commands/admin/showroot.go | 2 +- go/cmd/dolt/commands/archive.go | 4 +- go/cmd/dolt/commands/backup.go | 8 +- go/cmd/dolt/commands/branch.go | 6 +- go/cmd/dolt/commands/filter-branch.go | 2 +- go/cmd/dolt/commands/fsck.go | 2 +- go/cmd/dolt/commands/init_test.go | 4 +- go/cmd/dolt/commands/log_test.go | 8 +- go/cmd/dolt/commands/migrate.go | 6 +- go/cmd/dolt/commands/read_tables.go | 2 +- go/cmd/dolt/commands/schcmds/import.go | 2 +- go/cmd/dolt/commands/schcmds/update-tag.go | 2 +- go/cmd/dolt/commands/send_metrics.go | 4 +- go/cmd/dolt/commands/show.go | 8 +- go/cmd/dolt/commands/sql_test.go | 30 +++--- go/cmd/dolt/commands/sqlserver/server_test.go | 14 +-- go/cmd/dolt/commands/stashcmds/clear.go | 4 +- go/cmd/dolt/commands/stashcmds/drop.go | 6 +- go/cmd/dolt/commands/stashcmds/list.go | 4 +- go/cmd/dolt/commands/stashcmds/pop.go | 6 +- go/cmd/dolt/commands/stashcmds/stash.go | 6 +- go/cmd/dolt/commands/version.go | 2 +- go/cmd/dolt/dolt.go | 14 +-- .../doltcore/cherry_pick/cherry_pick.go | 2 +- go/libraries/doltcore/doltdb/doltdb.go | 2 +- .../doltcore/doltdb/feature_version_test.go | 2 +- go/libraries/doltcore/doltdb/gc_test.go | 10 +- .../dtestutils/testcommands/multienv.go | 24 ++--- go/libraries/doltcore/env/actions/branch.go | 4 +- go/libraries/doltcore/env/actions/clone.go | 16 +-- .../env/actions/commitwalk/commitwalk_test.go | 54 +++++----- .../doltcore/env/actions/infer_schema_test.go | 2 +- go/libraries/doltcore/env/actions/tag.go | 6 +- .../doltcore/env/actions/workspace.go | 6 +- go/libraries/doltcore/env/environment.go | 74 +++++++++---- go/libraries/doltcore/env/environment_test.go | 8 +- go/libraries/doltcore/env/memory.go | 6 +- go/libraries/doltcore/env/multi_repo_env.go | 8 +- go/libraries/doltcore/env/repo_state.go | 1 - .../doltcore/merge/integration_test.go | 10 +- .../merge/keyless_integration_test.go | 8 +- .../doltcore/merge/schema_integration_test.go | 20 ++-- .../doltcore/merge/schema_merge_test.go | 18 ++-- go/libraries/doltcore/migrate/environment.go | 16 ++- .../doltcore/migrate/integration_test.go | 54 +++++----- go/libraries/doltcore/mvdata/data_loc_test.go | 2 +- .../doltcore/mvdata/engine_table_writer.go | 2 +- go/libraries/doltcore/rebase/filter_branch.go | 6 +- .../doltcore/rebase/filter_branch_test.go | 4 +- .../schema/encoding/integration_test.go | 2 +- .../doltcore/schema/integration_test.go | 2 +- .../doltcore/sqle/alterschema_test.go | 12 +-- .../binlogreplication/binlog_primary_hooks.go | 2 +- .../doltcore/sqle/cluster/commithook_test.go | 11 +- .../doltcore/sqle/cluster/controller.go | 4 +- .../doltcore/sqle/cluster/initdbhook.go | 4 +- go/libraries/doltcore/sqle/common_test.go | 8 +- go/libraries/doltcore/sqle/database.go | 2 +- .../doltcore/sqle/database_provider.go | 6 +- .../sqle/dprocedures/dolt_checkout.go | 4 +- .../dprocedures/dolt_conflicts_resolve.go | 15 +-- .../doltcore/sqle/dprocedures/dolt_rebase.go | 2 +- go/libraries/doltcore/sqle/dsess/session.go | 2 +- .../sqle/dtables/query_catalog_table_test.go | 8 +- .../sqle/enginetest/dolt_engine_test.go | 2 +- .../doltcore/sqle/enginetest/dolt_harness.go | 4 +- .../sqle/enginetest/dolt_server_test.go | 4 +- .../sqle/enginetest/dolt_server_tests.go | 4 +- .../doltcore/sqle/index/dolt_index_test.go | 2 +- .../index/mergeable_indexes_setup_test.go | 2 +- .../database_revision_test.go | 6 +- .../integration_test/history_table_test.go | 6 +- .../sqle/integration_test/json_value_test.go | 2 +- .../sqle/integration_test/stockmarket_test.go | 28 ++--- .../doltcore/sqle/kvexec/count_agg_test.go | 2 +- .../doltcore/sqle/kvexec/lookup_join_test.go | 2 +- .../sqle/logictest/dolt/doltharness_test.go | 2 +- go/libraries/doltcore/sqle/replication.go | 2 +- .../doltcore/sqle/replication_test.go | 2 +- go/libraries/doltcore/sqle/sqlddl_test.go | 102 +++++++++--------- go/libraries/doltcore/sqle/sqldelete_test.go | 2 +- go/libraries/doltcore/sqle/sqlinsert_test.go | 2 +- go/libraries/doltcore/sqle/sqlpersist_test.go | 2 +- go/libraries/doltcore/sqle/sqlreplace_test.go | 2 +- go/libraries/doltcore/sqle/sqlselect_test.go | 18 ++-- go/libraries/doltcore/sqle/sqlupdate_test.go | 2 +- .../doltcore/sqle/statsnoms/database.go | 9 +- .../doltcore/sqle/table_editor_fk_test.go | 30 +++--- .../doltcore/sqle/table_editor_index_test.go | 6 +- go/libraries/doltcore/sqle/temp_table.go | 3 +- go/libraries/doltcore/sqle/testutil.go | 36 +++---- go/libraries/doltcore/sqle/views_test.go | 10 +- .../table/untyped/sqlexport/sqlwriter_test.go | 2 +- go/utils/remotesrv/main.go | 2 +- 96 files changed, 460 insertions(+), 439 deletions(-) diff --git a/go/cmd/dolt/cli/command.go b/go/cmd/dolt/cli/command.go index c1da7d44e7e..22cee4acec3 100644 --- a/go/cmd/dolt/cli/command.go +++ b/go/cmd/dolt/cli/command.go @@ -236,8 +236,8 @@ func (hc SubCommandHandler) handleCommand(ctx context.Context, commandStr string } fgc, ok := cmd.(FormatGatedCommand) - if ok && dEnv.DoltDB != nil && fgc.GatedForNBF(dEnv.DoltDB.Format()) { - vs := dEnv.DoltDB.Format().VersionString() + if ok && dEnv.DoltDB(ctx) != nil && fgc.GatedForNBF(dEnv.DoltDB(ctx).Format()) { + vs := dEnv.DoltDB(ctx).Format().VersionString() err := fmt.Sprintf("Dolt command '%s' is not supported in format %s", cmd.Name(), vs) PrintErrln(color.YellowString(err)) return 1 diff --git a/go/cmd/dolt/commands/admin/setref.go b/go/cmd/dolt/commands/admin/setref.go index 082955b1901..35250ad324a 100644 --- a/go/cmd/dolt/commands/admin/setref.go +++ b/go/cmd/dolt/commands/admin/setref.go @@ -88,7 +88,7 @@ func (cmd SetRefCmd) Exec(ctx context.Context, commandStr string, args []string, h := hash.Parse(apr.MustGetValue("to")) - err := dEnv.DoltDB.SetHead(ctx, r, h) + err := dEnv.DoltDB(ctx).SetHead(ctx, r, h) if err != nil { verr := errhand.BuildDError("error setting %s to %s", r.String(), h.String()).AddCause(err).Build() commands.HandleVErrAndExitCode(verr, usage) diff --git a/go/cmd/dolt/commands/admin/showroot.go b/go/cmd/dolt/commands/admin/showroot.go index 5adb08b5f3c..5cc07b574a3 100644 --- a/go/cmd/dolt/commands/admin/showroot.go +++ b/go/cmd/dolt/commands/admin/showroot.go @@ -66,7 +66,7 @@ func (cmd ShowRootCmd) Exec(ctx context.Context, commandStr string, args []strin cli.ParseArgsOrDie(ap, args, usage) - db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB) + db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB(ctx)) dss, err := db.Datasets(ctx) if err != nil { verr := errhand.BuildDError("failed to get database datasets").AddCause(err).Build() diff --git a/go/cmd/dolt/commands/archive.go b/go/cmd/dolt/commands/archive.go index 3ea7b3f9a94..8ec422e7348 100644 --- a/go/cmd/dolt/commands/archive.go +++ b/go/cmd/dolt/commands/archive.go @@ -85,7 +85,7 @@ func (cmd ArchiveCmd) Exec(ctx context.Context, commandStr string, args []string help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, docs, ap)) apr := cli.ParseArgsOrDie(ap, args, help) - db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB) + db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB(ctx)) cs := datas.ChunkStoreFromDatabase(db) if _, ok := cs.(*nbs.GenerationalNBS); !ok { cli.PrintErrln("archive command requires a GenerationalNBS") @@ -130,7 +130,7 @@ func (cmd ArchiveCmd) Exec(ctx context.Context, commandStr string, args []string groupings := nbs.NewChunkRelations() if apr.Contains(groupChunksFlag) { - err = historicalFuzzyMatching(ctx, hs, &groupings, dEnv.DoltDB) + err = historicalFuzzyMatching(ctx, hs, &groupings, dEnv.DoltDB(ctx)) if err != nil { cli.PrintErrln(err) return 1 diff --git a/go/cmd/dolt/commands/backup.go b/go/cmd/dolt/commands/backup.go index 0b6c42415ea..093296394e7 100644 --- a/go/cmd/dolt/commands/backup.go +++ b/go/cmd/dolt/commands/backup.go @@ -275,7 +275,7 @@ func backup(ctx context.Context, dEnv *env.DoltEnv, b env.Remote) errhand.Verbos return errhand.BuildDError("error: archive files present. Please revert them with the --revert flag before running this command.").Build() } - destDb, err := b.GetRemoteDB(ctx, dEnv.DoltDB.ValueReadWriter().Format(), dEnv) + destDb, err := b.GetRemoteDB(ctx, dEnv.DoltDB(ctx).ValueReadWriter().Format(), dEnv) if err != nil { return errhand.BuildDError("error: unable to open destination.").AddCause(err).Build() } @@ -283,7 +283,7 @@ func backup(ctx context.Context, dEnv *env.DoltEnv, b env.Remote) errhand.Verbos if err != nil { return errhand.BuildDError("error: ").AddCause(err).Build() } - err = actions.SyncRoots(ctx, dEnv.DoltDB, destDb, tmpDir, buildProgStarter(defaultLanguage), stopProgFuncs) + err = actions.SyncRoots(ctx, dEnv.DoltDB(ctx), destDb, tmpDir, buildProgStarter(defaultLanguage), stopProgFuncs) switch err { case nil: @@ -361,7 +361,7 @@ func restoreBackup(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar return errhand.VerboseErrorFromError(err) } - err = actions.SyncRoots(ctx, srcDb, existingDEnv.DoltDB, tmpDir, buildProgStarter(downloadLanguage), stopProgFuncs) + err = actions.SyncRoots(ctx, srcDb, existingDEnv.DoltDB(ctx), tmpDir, buildProgStarter(downloadLanguage), stopProgFuncs) if err != nil { return errhand.VerboseErrorFromError(err) } @@ -384,7 +384,7 @@ func restoreBackup(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar if err != nil { return errhand.VerboseErrorFromError(err) } - err = actions.SyncRoots(ctx, srcDb, clonedEnv.DoltDB, tmpDir, buildProgStarter(downloadLanguage), stopProgFuncs) + err = actions.SyncRoots(ctx, srcDb, clonedEnv.DoltDB(ctx), tmpDir, buildProgStarter(downloadLanguage), stopProgFuncs) if err != nil { // If we're cloning into a directory that already exists do not erase it. Otherwise // make best effort to delete the directory we created. diff --git a/go/cmd/dolt/commands/branch.go b/go/cmd/dolt/commands/branch.go index 2f6bd56d6a7..dfef6599cdc 100644 --- a/go/cmd/dolt/commands/branch.go +++ b/go/cmd/dolt/commands/branch.go @@ -264,7 +264,7 @@ func printCurrentBranch(sqlCtx *sql.Context, queryEngine cli.Queryist) int { } func printAllDatasets(ctx context.Context, dEnv *env.DoltEnv) int { - refs, err := dEnv.DoltDB.GetHeadRefs(ctx) + refs, err := dEnv.DoltDB(ctx).GetHeadRefs(ctx) if err != nil { return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), nil) } @@ -275,7 +275,7 @@ func printAllDatasets(ctx context.Context, dEnv *env.DoltEnv) int { cli.Println(" " + r.String()) } - branches, err := dEnv.DoltDB.GetBranches(ctx) + branches, err := dEnv.DoltDB(ctx).GetBranches(ctx) if err != nil { return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), nil) } @@ -289,7 +289,7 @@ func printAllDatasets(ctx context.Context, dEnv *env.DoltEnv) int { return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), nil) } - _, err = dEnv.DoltDB.ResolveWorkingSet(ctx, w) + _, err = dEnv.DoltDB(ctx).ResolveWorkingSet(ctx, w) if errors.Is(err, doltdb.ErrWorkingSetNotFound) { continue } else if err != nil { diff --git a/go/cmd/dolt/commands/filter-branch.go b/go/cmd/dolt/commands/filter-branch.go index 2161119f516..06af7dbe5c8 100644 --- a/go/cmd/dolt/commands/filter-branch.go +++ b/go/cmd/dolt/commands/filter-branch.go @@ -263,7 +263,7 @@ func getNerf(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgParseResu return nil, err } - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, headRef) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, headRef) if err != nil { return nil, err } diff --git a/go/cmd/dolt/commands/fsck.go b/go/cmd/dolt/commands/fsck.go index b7e4d85268c..7296a416128 100644 --- a/go/cmd/dolt/commands/fsck.go +++ b/go/cmd/dolt/commands/fsck.go @@ -72,7 +72,7 @@ func (cmd FsckCmd) Exec(ctx context.Context, commandStr string, args []string, d terminate = func() bool { defer close(progress) var err error - report, err = dEnv.DoltDB.FSCK(ctx, progress) + report, err = dEnv.DoltDB(ctx).FSCK(ctx, progress) if err != nil { cli.PrintErrln(err.Error()) return true diff --git a/go/cmd/dolt/commands/init_test.go b/go/cmd/dolt/commands/init_test.go index a287a414e36..50f78693014 100644 --- a/go/cmd/dolt/commands/init_test.go +++ b/go/cmd/dolt/commands/init_test.go @@ -75,7 +75,7 @@ func TestInit(t *testing.T) { cliCtx, _ := cli.NewCliContext(&apr, dEnv.Config, dEnv.FS, latebind) result := InitCmd{}.Exec(context.Background(), "dolt init", test.Args, dEnv, cliCtx) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() require.Equalf(t, test.ExpectSuccess, result == 0, "- Expected success: %t; result: %t;", test.ExpectSuccess, result == 0) @@ -95,7 +95,7 @@ func TestInitTwice(t *testing.T) { dEnv := createUninitializedEnv() result := InitCmd{}.Exec(context.Background(), "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) require.True(t, result == 0, "First init should succeed") - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() result = InitCmd{}.Exec(context.Background(), "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) require.True(t, result != 0, "Second init should fail") diff --git a/go/cmd/dolt/commands/log_test.go b/go/cmd/dolt/commands/log_test.go index 6712bf36031..93da82e83de 100644 --- a/go/cmd/dolt/commands/log_test.go +++ b/go/cmd/dolt/commands/log_test.go @@ -34,14 +34,14 @@ import ( func TestLog(t *testing.T) { dEnv := createUninitializedEnv() err := dEnv.InitRepo(context.Background(), types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if err != nil { t.Error("Failed to init repo") } cs, _ := doltdb.NewCommitSpec(env.DefaultInitBranch) - opt, _ := dEnv.DoltDB.Resolve(context.Background(), cs, nil) + opt, _ := dEnv.DoltDB(ctx).Resolve(context.Background(), cs, nil) commit, _ := opt.ToCommit() meta, _ := commit.GetCommitMeta(context.Background()) @@ -55,14 +55,14 @@ func TestLogSigterm(t *testing.T) { dEnv := createUninitializedEnv() err := dEnv.InitRepo(context.Background(), types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if err != nil { t.Error("Failed to init repo") } cs, _ := doltdb.NewCommitSpec(env.DefaultInitBranch) - optCmt, _ := dEnv.DoltDB.Resolve(context.Background(), cs, nil) + optCmt, _ := dEnv.DoltDB(ctx).Resolve(context.Background(), cs, nil) commit, _ := optCmt.ToCommit() cMeta, _ := commit.GetCommitMeta(context.Background()) cHash, _ := commit.HashOf() diff --git a/go/cmd/dolt/commands/migrate.go b/go/cmd/dolt/commands/migrate.go index df815c61088..8f0082d4212 100644 --- a/go/cmd/dolt/commands/migrate.go +++ b/go/cmd/dolt/commands/migrate.go @@ -89,7 +89,7 @@ func (cmd MigrateCmd) Exec(ctx context.Context, commandStr string, args []string return 0 // unreachable } -// MigrateDatabase migrates the NomsBinFormat of |dEnv.DoltDB|. +// MigrateDatabase migrates the NomsBinFormat of |dEnv.DoltDB(ctx)|. func MigrateDatabase(ctx context.Context, dEnv *env.DoltEnv, dropConflicts bool) error { menv, err := migrate.NewEnvironment(ctx, dEnv) if err != nil { @@ -97,7 +97,7 @@ func MigrateDatabase(ctx context.Context, dEnv *env.DoltEnv, dropConflicts bool) } menv.DropConflicts = dropConflicts - if curr := menv.Existing.DoltDB.Format(); types.IsFormat_DOLT(curr) { + if curr := menv.Existing.DoltDB(ctx).Format(); types.IsFormat_DOLT(curr) { cli.Println("database is already migrated") return nil } @@ -108,7 +108,7 @@ func MigrateDatabase(ctx context.Context, dEnv *env.DoltEnv, dropConflicts bool) } cli.Println("migrating database at tmp dir: ", p) - err = migrate.TraverseDAG(ctx, menv, menv.Existing.DoltDB, menv.Migration.DoltDB) + err = migrate.TraverseDAG(ctx, menv, menv.Existing.DoltDB(ctx), menv.Migration.DoltDB(ctx)) if err != nil { return err } diff --git a/go/cmd/dolt/commands/read_tables.go b/go/cmd/dolt/commands/read_tables.go index 6e3132ea5c0..60cfc84bbaa 100644 --- a/go/cmd/dolt/commands/read_tables.go +++ b/go/cmd/dolt/commands/read_tables.go @@ -190,7 +190,7 @@ func pullTableValue(ctx context.Context, dEnv *env.DoltEnv, srcDB *doltdb.DoltDB cli.Println("Retrieving", tblName) runProgFunc := buildProgStarter(language) wg, pullerEventCh := runProgFunc(newCtx) - err = dEnv.DoltDB.PullChunks(ctx, tmpDir, srcDB, []hash.Hash{tblHash}, pullerEventCh, nil) + err = dEnv.DoltDB(ctx).PullChunks(ctx, tmpDir, srcDB, []hash.Hash{tblHash}, pullerEventCh, nil) stopProgFuncs(cancelFunc, wg, pullerEventCh) if err != nil { return nil, errhand.BuildDError("Failed reading chunks for remote table '%s' at '%s'", tblName, commitStr).AddCause(err).Build() diff --git a/go/cmd/dolt/commands/schcmds/import.go b/go/cmd/dolt/commands/schcmds/import.go index 56c86d5fdfa..faacf492a5c 100644 --- a/go/cmd/dolt/commands/schcmds/import.go +++ b/go/cmd/dolt/commands/schcmds/import.go @@ -292,7 +292,7 @@ func importSchema(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars return verr } - sch, verr := inferSchemaFromFile(ctx, dEnv.DoltDB.ValueReadWriter().Format(), impArgs, root) + sch, verr := inferSchemaFromFile(ctx, dEnv.DoltDB(ctx).ValueReadWriter().Format(), impArgs, root) if verr != nil { return verr } diff --git a/go/cmd/dolt/commands/schcmds/update-tag.go b/go/cmd/dolt/commands/schcmds/update-tag.go index 8e886ea6c06..a4b8d72d08b 100644 --- a/go/cmd/dolt/commands/schcmds/update-tag.go +++ b/go/cmd/dolt/commands/schcmds/update-tag.go @@ -71,7 +71,7 @@ func (cmd UpdateTagCmd) Exec(ctx context.Context, commandStr string, args []stri help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, updateTagDocs, ap)) apr := cli.ParseArgsOrDie(ap, args, help) - if !types.IsFormat_DOLT(dEnv.DoltDB.Format()) { + if !types.IsFormat_DOLT(dEnv.DoltDB(ctx).Format()) { verr := errhand.BuildDError("update-tag is only available in storage format __DOLT__").Build() return commands.HandleVErrAndExitCode(verr, usage) } diff --git a/go/cmd/dolt/commands/send_metrics.go b/go/cmd/dolt/commands/send_metrics.go index bdadc74c44a..d79cdbc1f12 100644 --- a/go/cmd/dolt/commands/send_metrics.go +++ b/go/cmd/dolt/commands/send_metrics.go @@ -82,8 +82,8 @@ func (cmd SendMetricsCmd) ArgParser() *argparser.ArgParser { // Exec is the implementation of the command that flushes the events to the grpc service func (cmd SendMetricsCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int { - if dEnv.DoltDB != nil { // see go/cmd/dolt/dolt.go:interceptSendMetrics() - cli.PrintErrln("expected DoltEnv without DoltDB") + if dEnv.DoltDB(ctx) != nil { // see go/cmd/dolt/dolt.go:interceptSendMetrics() + cli.PrintErrln("expected DoltEnv without doltDB") return 1 } diff --git a/go/cmd/dolt/commands/show.go b/go/cmd/dolt/commands/show.go index da259c953f9..0e4ecc108b5 100644 --- a/go/cmd/dolt/commands/show.go +++ b/go/cmd/dolt/commands/show.go @@ -154,7 +154,7 @@ func (cmd ShowCmd) Exec(ctx context.Context, commandStr string, args []string, d return 1 } - if !opts.pretty && !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !opts.pretty && !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln("`dolt show --no-pretty` or `dolt show (BRANCHNAME)` is not supported when using old LD_1 storage format.") return 1 } @@ -190,7 +190,7 @@ func (cmd ShowCmd) Exec(ctx context.Context, commandStr string, args []string, d return 1 } - if !opts.pretty && !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !opts.pretty && !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln("`dolt show (NON_COMMIT_HASH)` is not supported when using old LD_1 storage format.") return 1 } @@ -240,7 +240,7 @@ func getValueFromRefSpec(ctx context.Context, dEnv *env.DoltEnv, specRef string) return nil, err } headRef, err := dEnv.RepoStateReader().CWBHeadRef() - optionalCommit, err := dEnv.DoltDB.Resolve(ctx, commitSpec, headRef) + optionalCommit, err := dEnv.DoltDB(ctx).Resolve(ctx, commitSpec, headRef) if err != nil { return nil, err } @@ -253,7 +253,7 @@ func getValueFromRefSpec(ctx context.Context, dEnv *env.DoltEnv, specRef string) if err != nil { return nil, err } - value, err := dEnv.DoltDB.ValueReadWriter().ReadValue(ctx, refHash) + value, err := dEnv.DoltDB(ctx).ValueReadWriter().ReadValue(ctx, refHash) if err != nil { return nil, err } diff --git a/go/cmd/dolt/commands/sql_test.go b/go/cmd/dolt/commands/sql_test.go index 240b3d32d0e..619b0940230 100644 --- a/go/cmd/dolt/commands/sql_test.go +++ b/go/cmd/dolt/commands/sql_test.go @@ -41,7 +41,7 @@ func TestSqlConsole(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -74,7 +74,7 @@ func TestSqlBatchMode(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -117,7 +117,7 @@ func TestSqlSelect(t *testing.T) { ctx := context.TODO() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -147,7 +147,7 @@ func TestSqlShow(t *testing.T) { ctx := context.TODO() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -181,7 +181,7 @@ func TestCreateTable(t *testing.T) { ctx := context.TODO() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() working, err := dEnv.WorkingRoot(context.Background()) assert.Nil(t, err, "Unexpected error") has, err := working.HasTable(context.Background(), doltdb.TableName{Name: tableName}) @@ -230,7 +230,7 @@ func TestShowTables(t *testing.T) { ctx := context.TODO() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -266,7 +266,7 @@ func TestAlterTable(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -297,7 +297,7 @@ func TestDropTable(t *testing.T) { ctx := context.TODO() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -418,7 +418,7 @@ func TestInsert(t *testing.T) { ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -436,7 +436,7 @@ func TestInsert(t *testing.T) { // Assert that all expected IDs exist after the insert for _, expectedid := range test.expectedIds { q := fmt.Sprintf("SELECT * FROM %s WHERE id = '%s'", tableName, expectedid.String()) - rows, err := sqle.ExecuteSelect(dEnv, root, q) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) assert.NoError(t, err) assert.True(t, len(rows) > 0) } @@ -502,7 +502,7 @@ func TestUpdate(t *testing.T) { ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -520,7 +520,7 @@ func TestUpdate(t *testing.T) { // Assert that all rows have been updated for i, expectedid := range test.expectedIds { q := fmt.Sprintf("SELECT * FROM %s WHERE id = '%s'", tableName, expectedid.String()) - rows, err := sqle.ExecuteSelect(dEnv, root, q) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) assert.NoError(t, err) assert.True(t, len(rows) > 0) assert.Equal(t, uint32(test.expectedAges[i]), rows[0][2]) @@ -580,7 +580,7 @@ func TestDelete(t *testing.T) { ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -598,7 +598,7 @@ func TestDelete(t *testing.T) { // Assert that all rows have been deleted for _, expectedid := range test.deletedIds { q := fmt.Sprintf("SELECT * FROM %s WHERE id = '%s'", tableName, expectedid.String()) - rows, err := sqle.ExecuteSelect(dEnv, root, q) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) assert.NoError(t, err) assert.True(t, len(rows) == 0) } @@ -610,7 +610,7 @@ func TestDelete(t *testing.T) { func TestCommitHooksNoErrors(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() sql.SystemVariables.SetGlobal(dsess.ReplicateToRemote, "unknown") hooks, err := sqle.GetCommitHooks(context.Background(), nil, dEnv, io.Discard) diff --git a/go/cmd/dolt/commands/sqlserver/server_test.go b/go/cmd/dolt/commands/sqlserver/server_test.go index 496cb324337..3bd0680a561 100644 --- a/go/cmd/dolt/commands/sqlserver/server_test.go +++ b/go/cmd/dolt/commands/sqlserver/server_test.go @@ -68,7 +68,7 @@ func TestServerArgs(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, dEnv.DoltDB.Close()) + assert.NoError(t, dEnv.DoltDB(ctx).Close()) }() go func() { StartServer(context.Background(), "0.0.0", "dolt sql-server", []string{ @@ -112,7 +112,7 @@ listener: dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, dEnv.DoltDB.Close()) + assert.NoError(t, dEnv.DoltDB(ctx).Close()) }() controller := svcs.NewController() go func() { @@ -137,7 +137,7 @@ func TestServerBadArgs(t *testing.T) { env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, env.DoltDB.Close()) + assert.NoError(t, env.DoltDB(ctx).Close()) }() tests := [][]string{ @@ -166,7 +166,7 @@ func TestServerGoodParams(t *testing.T) { env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, env.DoltDB.Close()) + assert.NoError(t, env.DoltDB(ctx).Close()) }() tests := []servercfg.ServerConfig{ @@ -208,7 +208,7 @@ func TestServerSelect(t *testing.T) { env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, env.DoltDB.Close()) + assert.NoError(t, env.DoltDB(ctx).Close()) }() serverConfig := DefaultCommandLineServerConfig().withLogLevel(servercfg.LogLevel_Fatal).WithPort(15300) @@ -270,7 +270,7 @@ func TestServerFailsIfPortInUse(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, dEnv.DoltDB.Close()) + assert.NoError(t, dEnv.DoltDB(ctx).Close()) }() var wg sync.WaitGroup @@ -307,7 +307,7 @@ func TestServerSetDefaultBranch(t *testing.T) { dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { - assert.NoError(t, dEnv.DoltDB.Close()) + assert.NoError(t, dEnv.DoltDB(ctx).Close()) }() serverConfig := DefaultCommandLineServerConfig().withLogLevel(servercfg.LogLevel_Fatal).WithPort(15302) diff --git a/go/cmd/dolt/commands/stashcmds/clear.go b/go/cmd/dolt/commands/stashcmds/clear.go index 4a2b7618ba5..5beb5b245fc 100644 --- a/go/cmd/dolt/commands/stashcmds/clear.go +++ b/go/cmd/dolt/commands/stashcmds/clear.go @@ -64,7 +64,7 @@ func (cmd StashClearCmd) EventType() eventsapi.ClientEventType { // Exec executes the command func (cmd StashClearCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int { - if !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln(ErrStashNotSupportedForOldFormat.Error()) return 1 } @@ -77,7 +77,7 @@ func (cmd StashClearCmd) Exec(ctx context.Context, commandStr string, args []str return 1 } - err := dEnv.DoltDB.RemoveAllStashes(ctx) + err := dEnv.DoltDB(ctx).RemoveAllStashes(ctx) if err != nil { return commands.HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage) } diff --git a/go/cmd/dolt/commands/stashcmds/drop.go b/go/cmd/dolt/commands/stashcmds/drop.go index e6e760b0365..3ab46dff04c 100644 --- a/go/cmd/dolt/commands/stashcmds/drop.go +++ b/go/cmd/dolt/commands/stashcmds/drop.go @@ -67,7 +67,7 @@ func (cmd StashDropCmd) EventType() eventsapi.ClientEventType { // Exec executes the command func (cmd StashDropCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int { - if !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln(ErrStashNotSupportedForOldFormat.Error()) return 1 } @@ -95,12 +95,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.GetStashHashAtIdx(ctx, idx) + stashHash, err := dEnv.DoltDB(ctx).GetStashHashAtIdx(ctx, idx) if err != nil { return err } - err = dEnv.DoltDB.RemoveStashAtIdx(ctx, idx) + err = dEnv.DoltDB(ctx).RemoveStashAtIdx(ctx, idx) if err != nil { return err } diff --git a/go/cmd/dolt/commands/stashcmds/list.go b/go/cmd/dolt/commands/stashcmds/list.go index 21fa04c9e05..965f2ca0d83 100644 --- a/go/cmd/dolt/commands/stashcmds/list.go +++ b/go/cmd/dolt/commands/stashcmds/list.go @@ -64,7 +64,7 @@ func (cmd StashListCmd) EventType() eventsapi.ClientEventType { // Exec executes the command func (cmd StashListCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int { - if !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln(ErrStashNotSupportedForOldFormat.Error()) return 1 } @@ -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.GetStashes(ctx) + stashes, err := dEnv.DoltDB(ctx).GetStashes(ctx) if err != nil { return err } diff --git a/go/cmd/dolt/commands/stashcmds/pop.go b/go/cmd/dolt/commands/stashcmds/pop.go index 3e5e4c2cade..b4baac50702 100644 --- a/go/cmd/dolt/commands/stashcmds/pop.go +++ b/go/cmd/dolt/commands/stashcmds/pop.go @@ -73,7 +73,7 @@ func (cmd StashPopCmd) EventType() eventsapi.ClientEventType { // Exec executes the command func (cmd StashPopCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int { - if !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln(ErrStashNotSupportedForOldFormat.Error()) return 1 } @@ -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.GetStashRootAndHeadCommitAtIdx(ctx, idx) + stashRoot, headCommit, meta, err := dEnv.DoltDB(ctx).GetStashRootAndHeadCommitAtIdx(ctx, idx) if err != nil { return false, err } @@ -142,7 +142,7 @@ func applyStashAtIdx(ctx *sql.Context, dEnv *env.DoltEnv, curWorkingRoot doltdb. if err != nil { return false, err } - optCmt, err := dEnv.DoltDB.Resolve(ctx, headCommitSpec, headRef) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, headCommitSpec, headRef) if err != nil { return false, err } diff --git a/go/cmd/dolt/commands/stashcmds/stash.go b/go/cmd/dolt/commands/stashcmds/stash.go index 288322c6bef..589252d0c73 100644 --- a/go/cmd/dolt/commands/stashcmds/stash.go +++ b/go/cmd/dolt/commands/stashcmds/stash.go @@ -94,7 +94,7 @@ func (cmd StashCmd) Exec(ctx context.Context, commandStr string, args []string, help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, stashDocs, ap)) apr := cli.ParseArgsOrDie(ap, args, help) - if !dEnv.DoltDB.Format().UsesFlatbuffers() { + if !dEnv.DoltDB(ctx).Format().UsesFlatbuffers() { cli.PrintErrln(ErrStashNotSupportedForOldFormat.Error()) return 1 } @@ -228,7 +228,7 @@ func stashChanges(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars if err != nil { return err } - optCmt, err := dEnv.DoltDB.Resolve(ctx, commitSpec, curHeadRef) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, commitSpec, curHeadRef) if err != nil { return err } @@ -242,7 +242,7 @@ func stashChanges(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars return err } - err = dEnv.DoltDB.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))) if err != nil { return err } diff --git a/go/cmd/dolt/commands/version.go b/go/cmd/dolt/commands/version.go index 1eef9b0a8c8..1e05f83c808 100644 --- a/go/cmd/dolt/commands/version.go +++ b/go/cmd/dolt/commands/version.go @@ -114,7 +114,7 @@ func (cmd VersionCmd) ExecWithArgParser(ctx context.Context, apr *argparser.ArgP if dEnv.HasDoltDir() && dEnv.RSLoadErr == nil && !cli.CheckEnvIsValid(dEnv) { return 2 } else if dEnv.HasDoltDir() && dEnv.RSLoadErr == nil { - nbf := dEnv.DoltDB.Format() + nbf := dEnv.DoltDB(ctx).Format() cli.Printf("database storage format: %s\n", dfunctions.GetStorageFormatDisplayString(nbf)) } } diff --git a/go/cmd/dolt/dolt.go b/go/cmd/dolt/dolt.go index f23f7365ebf..941639e4deb 100644 --- a/go/cmd/dolt/dolt.go +++ b/go/cmd/dolt/dolt.go @@ -639,8 +639,8 @@ or check the docs for questions about usage.`) } } - if csMetrics && dEnv.DoltDB != nil { - metricsSummary := dEnv.DoltDB.CSMetricsSummary() + if csMetrics && dEnv.DoltDB(ctx) != nil { + metricsSummary := dEnv.DoltDB(ctx).CSMetricsSummary() cli.Println("Command took", time.Since(start).Seconds()) cli.PrintErrln(metricsSummary) } @@ -778,18 +778,18 @@ If you're interested in running this command against a remote host, hit us up on } var lookForServer bool - if targetEnv.DoltDB != nil && targetEnv.IsAccessModeReadOnly() { - // If the loaded target environment has a DoltDB and we do not + if targetEnv.DoltDB(ctx) != nil && targetEnv.IsAccessModeReadOnly() { + // If the loaded target environment has a doltDB and we do not // have access to it, we look for a server. lookForServer = true - } else if targetEnv.DoltDB == nil { - // If the loaded environment itself does not have a DoltDB, we + } else if targetEnv.DoltDB(ctx) == nil { + // If the loaded environment itself does not have a doltDB, we // may want to look for a server. We do so if all of the // repositories in our MultiEnv are ReadOnly. This includes the // case where there are no repositories in our MultiEnv var allReposAreReadOnly bool = true mrEnv.Iter(func(name string, dEnv *env.DoltEnv) (stop bool, err error) { - if dEnv.DoltDB != nil { + if dEnv.DoltDB(ctx) != nil { allReposAreReadOnly = allReposAreReadOnly && dEnv.IsAccessModeReadOnly() } return !allReposAreReadOnly, nil diff --git a/go/libraries/doltcore/cherry_pick/cherry_pick.go b/go/libraries/doltcore/cherry_pick/cherry_pick.go index 534208dfa74..2e490b4a015 100644 --- a/go/libraries/doltcore/cherry_pick/cherry_pick.go +++ b/go/libraries/doltcore/cherry_pick/cherry_pick.go @@ -246,7 +246,7 @@ func cherryPick(ctx *sql.Context, dSess *dsess.DoltSession, roots doltdb.Roots, doltDB, ok := dSess.GetDoltDB(ctx, dbName) if !ok { - return nil, "", fmt.Errorf("failed to get DoltDB") + return nil, "", fmt.Errorf("failed to get doltDB") } dbData, ok := dSess.GetDbData(ctx, dbName) diff --git a/go/libraries/doltcore/doltdb/doltdb.go b/go/libraries/doltcore/doltdb/doltdb.go index 133d74ea7da..8a7718c408f 100644 --- a/go/libraries/doltcore/doltdb/doltdb.go +++ b/go/libraries/doltcore/doltdb/doltdb.go @@ -1837,7 +1837,7 @@ func (ddb *DoltDB) ChunkJournal() *nbs.ChunkJournal { func (ddb *DoltDB) TableFileStoreHasJournal(ctx context.Context) (bool, error) { tableFileStore, ok := datas.ChunkStoreFromDatabase(ddb.db).(chunks.TableFileStore) if !ok { - return false, errors.New("unsupported operation, DoltDB.TableFileStoreHasManifest on non-TableFileStore") + return false, errors.New("unsupported operation, doltDB.TableFileStoreHasManifest on non-TableFileStore") } _, tableFiles, _, err := tableFileStore.Sources(ctx) if err != nil { diff --git a/go/libraries/doltcore/doltdb/feature_version_test.go b/go/libraries/doltcore/doltdb/feature_version_test.go index 4069db86da0..b2e229440db 100644 --- a/go/libraries/doltcore/doltdb/feature_version_test.go +++ b/go/libraries/doltcore/doltdb/feature_version_test.go @@ -154,7 +154,7 @@ func TestFeatureVersion(t *testing.T) { doltdb.DoltFeatureVersion = oldVersion dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() doltdb.DoltFeatureVersion = DoltFeatureVersionCopy for _, cmd := range test.setup { diff --git a/go/libraries/doltcore/doltdb/gc_test.go b/go/libraries/doltcore/doltdb/gc_test.go index 414832ead9f..d5bfc425617 100644 --- a/go/libraries/doltcore/doltdb/gc_test.go +++ b/go/libraries/doltcore/doltdb/gc_test.go @@ -120,7 +120,7 @@ var gcSetupCommon = []testCommand{ func testGarbageCollection(t *testing.T, test gcTest) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, verr := commands.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, verr) @@ -132,21 +132,21 @@ func testGarbageCollection(t *testing.T, test gcTest) { var res interface{} for _, stage := range test.stages { - res = stage.preStageFunc(ctx, t, dEnv.DoltDB, res) + res = stage.preStageFunc(ctx, t, dEnv.DoltDB(ctx), res) for _, c := range stage.commands { exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx) require.Equal(t, 0, exitCode) } } - err := dEnv.DoltDB.GC(ctx, types.GCModeDefault, nil) + err := dEnv.DoltDB(ctx).GC(ctx, types.GCModeDefault, nil) require.NoError(t, err) - test.postGCFunc(ctx, t, dEnv.DoltDB, res) + test.postGCFunc(ctx, t, dEnv.DoltDB(ctx), res) working, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) // assert all out rows are present after gc - actual, err := sqle.ExecuteSelect(dEnv, working, test.query) + actual, err := sqle.ExecuteSelect(ctx, dEnv, working, test.query) require.NoError(t, err) assert.Equal(t, test.expected, actual) } diff --git a/go/libraries/doltcore/dtestutils/testcommands/multienv.go b/go/libraries/doltcore/dtestutils/testcommands/multienv.go index e573fd9ed39..a2fd8e7f82a 100644 --- a/go/libraries/doltcore/dtestutils/testcommands/multienv.go +++ b/go/libraries/doltcore/dtestutils/testcommands/multienv.go @@ -92,7 +92,7 @@ func (mr *MultiRepoTestSetup) homeProv() (string, error) { } func (mr *MultiRepoTestSetup) Close() { - for _, db := range mr.DoltDBs { + for _, db := range mr.DoltDB(ctx)s { err := db.Close() if err != nil { mr.Errhand(err) @@ -138,7 +138,7 @@ func (mr *MultiRepoTestSetup) NewDB(dbName string) { dEnv = env.Load(context.Background(), mr.homeProv, filesys.LocalFS, doltdb.LocalDirDoltDB, "test") mr.envs[dbName] = dEnv - mr.DoltDBs[dbName] = ddb + mr.DoltDB(ctx)s[dbName] = ddb mr.DbNames = append(mr.DbNames, dbName) mr.DbPaths[dbName] = repo } @@ -211,10 +211,10 @@ func (mr *MultiRepoTestSetup) CloneDB(fromRemote, dbName string) { } defer os.Chdir(wd) - ddb := dEnv.DoltDB + ddb := dEnv.DoltDB(ctx) mr.envs[dbName] = dEnv - mr.DoltDBs[dbName] = ddb + mr.DoltDB(ctx)s[dbName] = ddb mr.DbNames = append(mr.DbNames, dbName) mr.DbPaths[dbName] = cloneDir } @@ -228,7 +228,7 @@ func (mr *MultiRepoTestSetup) GetRemote(remoteName string) env.Remote { } func (mr *MultiRepoTestSetup) GetDB(dbName string) *doltdb.DoltDB { - db, ok := mr.DoltDBs[dbName] + db, ok := mr.DoltDB(ctx)s[dbName] if !ok { mr.Errhand("db not found") } @@ -275,7 +275,7 @@ func (mr *MultiRepoTestSetup) CommitWithWorkingSet(dbName string) *doltdb.Commit panic("couldn't get working set: " + err.Error()) } - commit, err := dEnv.DoltDB.CommitWithWorkingSet( + commit, err := dEnv.DoltDB(ctx).CommitWithWorkingSet( ctx, headRef, ws.Ref(), @@ -312,7 +312,7 @@ func createTestDataTable(ctx context.Context, ddb *doltdb.DoltDB) (*table.InMemT func (mr *MultiRepoTestSetup) CreateTable(ctx context.Context, dbName, tblName string) { dEnv := mr.envs[dbName] - imt, sch := createTestDataTable(ctx, dEnv.DoltDB) + imt, sch := createTestDataTable(ctx, dEnv.DoltDB(ctx)) rows := make([]row.Row, imt.NumRows()) for i := 0; i < imt.NumRows(); i++ { r, err := imt.GetRow(i) @@ -354,12 +354,12 @@ func (mr *MultiRepoTestSetup) PushToRemote(dbName, remoteName, branchName string if err != nil { mr.Errhand(fmt.Sprintf("Failed to push remote: %s", err.Error())) } - targets, remote, err := env.NewPushOpts(ctx, apr, dEnv.RepoStateReader(), dEnv.DoltDB, false, false, false, false) + targets, remote, err := env.NewPushOpts(ctx, apr, dEnv.RepoStateReader(), dEnv.DoltDB(ctx), false, false, false, false) if err != nil { mr.Errhand(fmt.Sprintf("Failed to push remote: %s", err.Error())) } - remoteDB, err := remote.GetRemoteDB(ctx, dEnv.DoltDB.ValueReadWriter().Format(), mr.envs[dbName]) + remoteDB, err := remote.GetRemoteDB(ctx, dEnv.DoltDB(ctx).ValueReadWriter().Format(), mr.envs[dbName]) if err != nil { mr.Errhand(actions.HandleInitRemoteStorageClientErr(remote.Name, remote.Url, err)) } @@ -374,7 +374,7 @@ func (mr *MultiRepoTestSetup) PushToRemote(dbName, remoteName, branchName string Remote: remote, Rsr: dEnv.RepoStateReader(), Rsw: dEnv.RepoStateWriter(), - SrcDb: dEnv.DoltDB, + SrcDb: dEnv.DoltDB(ctx), DestDb: remoteDB, TmpDir: tmpDir, } @@ -387,8 +387,8 @@ func (mr *MultiRepoTestSetup) PushToRemote(dbName, remoteName, branchName string // createTestTable creates a new test table with the name, schema, and rows given. func createTestTable(dEnv *env.DoltEnv, tableName string, sch schema.Schema) error { ctx := context.Background() - vrw := dEnv.DoltDB.ValueReadWriter() - ns := dEnv.DoltDB.NodeStore() + vrw := dEnv.DoltDB(ctx).ValueReadWriter() + ns := dEnv.DoltDB(ctx).NodeStore() idx, err := durable.NewEmptyPrimaryIndex(ctx, vrw, ns, sch) if err != nil { diff --git a/go/libraries/doltcore/env/actions/branch.go b/go/libraries/doltcore/env/actions/branch.go index 13a5f99db49..62cca4ba94d 100644 --- a/go/libraries/doltcore/env/actions/branch.go +++ b/go/libraries/doltcore/env/actions/branch.go @@ -69,7 +69,7 @@ func RenameBranch(ctx context.Context, dbData env.DbData, oldBranch, newBranch s } func CopyBranch(ctx context.Context, dEnv *env.DoltEnv, oldBranch, newBranch string, force bool) error { - return CopyBranchOnDB(ctx, dEnv.DoltDB, oldBranch, newBranch, force, nil) + return CopyBranchOnDB(ctx, dEnv.DoltDB(ctx), oldBranch, newBranch, force, nil) } func CopyBranchOnDB(ctx context.Context, ddb *doltdb.DoltDB, oldBranch, newBranch string, force bool, rsc *doltdb.ReplicationStatusController) error { @@ -382,7 +382,7 @@ func MaybeGetCommit(ctx context.Context, dEnv *env.DoltEnv, str string) (*doltdb if err != nil { return nil, err } - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, headRef) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, headRef) if err != nil && errors.Is(err, doltdb.ErrBranchNotFound) { return nil, nil } diff --git a/go/libraries/doltcore/env/actions/clone.go b/go/libraries/doltcore/env/actions/clone.go index d97b89b548d..04647b465bc 100644 --- a/go/libraries/doltcore/env/actions/clone.go +++ b/go/libraries/doltcore/env/actions/clone.go @@ -213,9 +213,9 @@ func CloneRemote(ctx context.Context, srcDB *doltdb.DoltDB, remoteName, branch s } // Retrieve existing working set, delete if it exists - ws, err := dEnv.DoltDB.ResolveWorkingSet(ctx, wsRef) + ws, err := dEnv.DoltDB(ctx).ResolveWorkingSet(ctx, wsRef) if ws != nil { - dEnv.DoltDB.DeleteWorkingSet(ctx, wsRef) + dEnv.DoltDB(ctx).DeleteWorkingSet(ctx, wsRef) } ws = doltdb.EmptyWorkingSet(wsRef) @@ -263,7 +263,7 @@ func fullClone(ctx context.Context, srcDB *doltdb.DoltDB, dEnv *env.DoltEnv, src clonePrint(eventCh) }() - err := srcDB.Clone(ctx, dEnv.DoltDB, eventCh) + err := srcDB.Clone(ctx, dEnv.DoltDB(ctx), eventCh) close(eventCh) wg.Wait() @@ -273,7 +273,7 @@ func fullClone(ctx context.Context, srcDB *doltdb.DoltDB, dEnv *env.DoltEnv, src } cs, _ := doltdb.NewCommitSpec(branch) - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, nil) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, nil) if err != nil { return nil, err } @@ -282,7 +282,7 @@ func fullClone(ctx context.Context, srcDB *doltdb.DoltDB, dEnv *env.DoltEnv, src return nil, doltdb.ErrGhostCommitEncountered } - err = dEnv.DoltDB.DeleteAllRefs(ctx) + err = dEnv.DoltDB(ctx).DeleteAllRefs(ctx) if err != nil { return nil, err } @@ -293,7 +293,7 @@ func fullClone(ctx context.Context, srcDB *doltdb.DoltDB, dEnv *env.DoltEnv, src br := refHash.Ref.(ref.BranchRef) if !singleBranch || br.GetPath() == branch { remoteRef := ref.NewRemoteRef(remoteName, br.GetPath()) - err = dEnv.DoltDB.SetHead(ctx, remoteRef, refHash.Hash) + err = dEnv.DoltDB(ctx).SetHead(ctx, remoteRef, refHash.Hash) if err != nil { return nil, fmt.Errorf("%w: %s; %s", ErrFailedToCreateRemoteRef, remoteRef.String(), err.Error()) @@ -301,14 +301,14 @@ func fullClone(ctx context.Context, srcDB *doltdb.DoltDB, dEnv *env.DoltEnv, src } if br.GetPath() == branch { // This is the only local branch after the clone is complete. - err = dEnv.DoltDB.SetHead(ctx, br, refHash.Hash) + err = dEnv.DoltDB(ctx).SetHead(ctx, br, refHash.Hash) if err != nil { return nil, fmt.Errorf("%w: %s; %s", ErrFailedToCreateLocalBranch, br.String(), err.Error()) } } } else if refHash.Ref.GetType() == ref.TagRefType { tr := refHash.Ref.(ref.TagRef) - err = dEnv.DoltDB.SetHead(ctx, tr, refHash.Hash) + err = dEnv.DoltDB(ctx).SetHead(ctx, tr, refHash.Hash) if err != nil { return nil, fmt.Errorf("%w: %s; %s", ErrFailedToCreateTagRef, tr.String(), err.Error()) } diff --git a/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go b/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go index 020d2bf9ca2..6217e20b03d 100644 --- a/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go +++ b/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go @@ -68,14 +68,14 @@ func TestGetDotDotRevisions(t *testing.T) { cs, err := doltdb.NewCommitSpec(env.DefaultInitBranch) require.NoError(t, err) - opt, err := dEnv.DoltDB.Resolve(context.Background(), cs, nil) + opt, err := dEnv.DoltDB(ctx).Resolve(context.Background(), cs, nil) require.NoError(t, err) commit, ok := opt.ToCommit() require.True(t, ok) rv, err := commit.GetRootValue(context.Background()) require.NoError(t, err) - r, rvh, err := dEnv.DoltDB.WriteRootValue(context.Background(), rv) + r, rvh, err := dEnv.DoltDB(ctx).WriteRootValue(context.Background(), rv) require.NoError(t, err) rv = r @@ -83,35 +83,35 @@ func TestGetDotDotRevisions(t *testing.T) { mainCommits := make([]*doltdb.Commit, 6) mainCommits[0] = commit for i := 1; i < 6; i++ { - mainCommits[i] = mustCreateCommit(t, dEnv.DoltDB, env.DefaultInitBranch, rvh, mainCommits[i-1]) + mainCommits[i] = mustCreateCommit(t, dEnv.DoltDB(ctx), env.DefaultInitBranch, rvh, mainCommits[i-1]) } // Create a feature branch. bref := ref.NewBranchRef("feature") - err = dEnv.DoltDB.NewBranchAtCommit(context.Background(), bref, mainCommits[5], nil) + err = dEnv.DoltDB(ctx).NewBranchAtCommit(context.Background(), bref, mainCommits[5], nil) require.NoError(t, err) // Create 3 commits on feature branch. featureCommits := []*doltdb.Commit{} featureCommits = append(featureCommits, mainCommits[5]) for i := 1; i < 4; i++ { - featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB, "feature", rvh, featureCommits[i-1])) + featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB(ctx), "feature", rvh, featureCommits[i-1])) } // Create 1 commit on main. - mainCommits = append(mainCommits, mustCreateCommit(t, dEnv.DoltDB, env.DefaultInitBranch, rvh, mainCommits[5])) + mainCommits = append(mainCommits, mustCreateCommit(t, dEnv.DoltDB(ctx), env.DefaultInitBranch, rvh, mainCommits[5])) // Merge main to feature branch. - featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB, "feature", rvh, featureCommits[3], mainCommits[6])) + featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB(ctx), "feature", rvh, featureCommits[3], mainCommits[6])) // Create 3 commits on feature branch. for i := 5; i < 8; i++ { - featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB, "feature", rvh, featureCommits[i-1])) + featureCommits = append(featureCommits, mustCreateCommit(t, dEnv.DoltDB(ctx), "feature", rvh, featureCommits[i-1])) } // Create 3 commits on main. for i := 7; i < 10; i++ { - mainCommits = append(mainCommits, mustCreateCommit(t, dEnv.DoltDB, env.DefaultInitBranch, rvh, mainCommits[i-1])) + mainCommits = append(mainCommits, mustCreateCommit(t, dEnv.DoltDB(ctx), env.DefaultInitBranch, rvh, mainCommits[i-1])) } // Branches look like this: @@ -124,7 +124,7 @@ func TestGetDotDotRevisions(t *testing.T) { mainHash := mustGetHash(t, mainCommits[6]) featurePreMergeHash := mustGetHash(t, featureCommits[3]) - res, err := GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featureHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 100) + res, err := GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featureHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 100) require.NoError(t, err) assert.Len(t, res, 7) @@ -136,25 +136,25 @@ func TestGetDotDotRevisions(t *testing.T) { assertEqualHashes(t, featureCommits[2], res[5]) assertEqualHashes(t, featureCommits[1], res[6]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{mainHash}, dEnv.DoltDB, []hash.Hash{featureHash}, 100) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{mainHash}, dEnv.DoltDB(ctx), []hash.Hash{featureHash}, 100) require.NoError(t, err) assert.Len(t, res, 0) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featureHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featureHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[7], res[0]) assertEqualHashes(t, featureCommits[6], res[1]) assertEqualHashes(t, featureCommits[5], res[2]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featurePreMergeHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featurePreMergeHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[3], res[0]) assertEqualHashes(t, featureCommits[2], res[1]) assertEqualHashes(t, featureCommits[1], res[2]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featurePreMergeHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featurePreMergeHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[3], res[0]) @@ -165,7 +165,7 @@ func TestGetDotDotRevisions(t *testing.T) { mergeBaseHash, err := merge.MergeBase(context.Background(), mainCommits[6], featureCommits[7]) require.NoError(t, err) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featureHash, mainHash}, dEnv.DoltDB, []hash.Hash{mergeBaseHash}, -1) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featureHash, mainHash}, dEnv.DoltDB(ctx), []hash.Hash{mergeBaseHash}, -1) require.NoError(t, err) assert.Len(t, res, 7) assertEqualHashes(t, featureCommits[7], res[0]) @@ -179,7 +179,7 @@ func TestGetDotDotRevisions(t *testing.T) { mergeBaseHash, err = merge.MergeBase(context.Background(), mainCommits[6], featureCommits[3]) require.NoError(t, err) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featurePreMergeHash, mainHash}, dEnv.DoltDB, []hash.Hash{mergeBaseHash}, -1) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featurePreMergeHash, mainHash}, dEnv.DoltDB(ctx), []hash.Hash{mergeBaseHash}, -1) require.NoError(t, err) assert.Len(t, res, 4) assertEqualHashes(t, featureCommits[3], res[0]) @@ -188,20 +188,20 @@ func TestGetDotDotRevisions(t *testing.T) { assertEqualHashes(t, featureCommits[1], res[3]) // Create a similar branch to "feature" on a forked repository and GetDotDotRevisions using that as well. - forkEnv := mustForkDB(t, dEnv.DoltDB, "feature", featureCommits[4]) + forkEnv := mustForkDB(t, dEnv.DoltDB(ctx), "feature", featureCommits[4]) // Create 3 commits on feature branch. for i := 5; i < 8; i++ { - featureCommits[i] = mustCreateCommit(t, forkEnv.DoltDB, "feature", rvh, featureCommits[i-1]) + featureCommits[i] = mustCreateCommit(t, forkEnv.DoltDB(ctx), "feature", rvh, featureCommits[i-1]) } featureHash = mustGetHash(t, featureCommits[7]) mainHash = mustGetHash(t, mainCommits[6]) featurePreMergeHash = mustGetHash(t, featureCommits[3]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featureHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 100) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featureHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 100) require.Error(t, err) - res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB, []hash.Hash{featureHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 100) + res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB(ctx), []hash.Hash{featureHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 100) require.NoError(t, err) assert.Len(t, res, 7) assertEqualHashes(t, featureCommits[7], res[0]) @@ -212,27 +212,27 @@ func TestGetDotDotRevisions(t *testing.T) { assertEqualHashes(t, featureCommits[2], res[5]) assertEqualHashes(t, featureCommits[1], res[6]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{mainHash}, dEnv.DoltDB, []hash.Hash{featureHash}, 100) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{mainHash}, dEnv.DoltDB(ctx), []hash.Hash{featureHash}, 100) require.Error(t, err) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{mainHash}, forkEnv.DoltDB, []hash.Hash{featureHash}, 100) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{mainHash}, forkEnv.DoltDB(ctx), []hash.Hash{featureHash}, 100) require.NoError(t, err) assert.Len(t, res, 0) - res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB, []hash.Hash{featureHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB(ctx), []hash.Hash{featureHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[7], res[0]) assertEqualHashes(t, featureCommits[6], res[1]) assertEqualHashes(t, featureCommits[5], res[2]) - res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB, []hash.Hash{featurePreMergeHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), dEnv.DoltDB(ctx), []hash.Hash{featurePreMergeHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[3], res[0]) assertEqualHashes(t, featureCommits[2], res[1]) assertEqualHashes(t, featureCommits[1], res[2]) - res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB, []hash.Hash{featurePreMergeHash}, dEnv.DoltDB, []hash.Hash{mainHash}, 3) + res, err = GetDotDotRevisions(context.Background(), forkEnv.DoltDB(ctx), []hash.Hash{featurePreMergeHash}, dEnv.DoltDB(ctx), []hash.Hash{mainHash}, 3) require.NoError(t, err) assert.Len(t, res, 3) assertEqualHashes(t, featureCommits[3], res[0]) @@ -286,12 +286,12 @@ func mustForkDB(t *testing.T, fromDB *doltdb.DoltDB, bn string, cm *doltdb.Commi for range ps { } }() - err = forkEnv.DoltDB.PullChunks(context.Background(), "", fromDB, []hash.Hash{h}, ps, nil) + err = forkEnv.DoltDB(ctx).PullChunks(context.Background(), "", fromDB, []hash.Hash{h}, ps, nil) if err == pull.ErrDBUpToDate { err = nil } require.NoError(t, err) - err = forkEnv.DoltDB.SetHead(context.Background(), ref.NewBranchRef(bn), h) + err = forkEnv.DoltDB(ctx).SetHead(context.Background(), ref.NewBranchRef(bn), h) require.NoError(t, err) return forkEnv } diff --git a/go/libraries/doltcore/env/actions/infer_schema_test.go b/go/libraries/doltcore/env/actions/infer_schema_test.go index 48e1c0bce17..e80d7849329 100644 --- a/go/libraries/doltcore/env/actions/infer_schema_test.go +++ b/go/libraries/doltcore/env/actions/infer_schema_test.go @@ -451,7 +451,7 @@ func TestInferSchema(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() wrCl, err := dEnv.FS.OpenForWrite(importFilePath, os.ModePerm) require.NoError(t, err) diff --git a/go/libraries/doltcore/env/actions/tag.go b/go/libraries/doltcore/env/actions/tag.go index 3dc7b40ab2a..11837c30cef 100644 --- a/go/libraries/doltcore/env/actions/tag.go +++ b/go/libraries/doltcore/env/actions/tag.go @@ -36,7 +36,7 @@ func CreateTag(ctx context.Context, dEnv *env.DoltEnv, tagName, startPoint strin if err != nil { return err } - return CreateTagOnDB(ctx, dEnv.DoltDB, tagName, startPoint, props, headRef) + return CreateTagOnDB(ctx, dEnv.DoltDB(ctx), tagName, startPoint, props, headRef) } func CreateTagOnDB(ctx context.Context, ddb *doltdb.DoltDB, tagName, startPoint string, props TagProps, headRef ref.DoltRef) error { @@ -97,7 +97,7 @@ func DeleteTagsOnDB(ctx context.Context, ddb *doltdb.DoltDB, tagNames ...string) return nil } -// IterResolvedTags iterates over tags in dEnv.DoltDB from newest to oldest, resolving the tag to a commit and calling cb(). +// IterResolvedTags iterates over tags in dEnv.DoltDB(ctx) from newest to oldest, resolving the tag to a commit and calling cb(). func IterResolvedTags(ctx context.Context, ddb *doltdb.DoltDB, cb func(tag *doltdb.Tag) (stop bool, err error)) error { tagRefs, err := ddb.GetTags(ctx) @@ -109,7 +109,7 @@ func IterResolvedTags(ctx context.Context, ddb *doltdb.DoltDB, cb func(tag *dolt for _, r := range tagRefs { tr, ok := r.(ref.TagRef) if !ok { - return fmt.Errorf("DoltDB.GetTags() returned non-tag DoltRef") + return fmt.Errorf("doltDB.GetTags() returned non-tag DoltRef") } tag, err := ddb.ResolveTag(ctx, tr) diff --git a/go/libraries/doltcore/env/actions/workspace.go b/go/libraries/doltcore/env/actions/workspace.go index 5f75976873f..6ec7aff8b54 100644 --- a/go/libraries/doltcore/env/actions/workspace.go +++ b/go/libraries/doltcore/env/actions/workspace.go @@ -32,7 +32,7 @@ func CreateWorkspace(ctx context.Context, dEnv *env.DoltEnv, name, startPoint st if err != nil { return nil } - return CreateWorkspaceOnDB(ctx, dEnv.DoltDB, name, startPoint, headRef) + return CreateWorkspaceOnDB(ctx, dEnv.DoltDB(ctx), name, startPoint, headRef) } func CreateWorkspaceOnDB(ctx context.Context, ddb *doltdb.DoltDB, name, startPoint string, headRef ref.DoltRef) error { @@ -81,7 +81,7 @@ func IsWorkspaceOnDB(ctx context.Context, ddb *doltdb.DoltDB, str string) (bool, } func IsWorkspace(ctx context.Context, dEnv *env.DoltEnv, str string) (bool, error) { - return IsWorkspaceOnDB(ctx, dEnv.DoltDB, str) + return IsWorkspaceOnDB(ctx, dEnv.DoltDB(ctx), str) } func DeleteWorkspace(ctx context.Context, dEnv *env.DoltEnv, workspaceName string, opts DeleteOptions) error { @@ -107,7 +107,7 @@ func DeleteWorkspace(ctx context.Context, dEnv *env.DoltEnv, workspaceName strin } func DeleteWorkspaceOnDB(ctx context.Context, dEnv *env.DoltEnv, dref ref.DoltRef, opts DeleteOptions) error { - ddb := dEnv.DoltDB + ddb := dEnv.DoltDB(ctx) hasRef, err := ddb.HasRef(ctx, dref) if err != nil { diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index deefbf62054..d66d2e1393e 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -87,7 +87,7 @@ type DoltEnv struct { RepoState *RepoState RSLoadErr error - DoltDB *doltdb.DoltDB + doltDB *doltdb.DoltDB DBLoadError error FS filesys.Filesys @@ -97,6 +97,34 @@ type DoltEnv struct { UserPassConfig *creds.DoltCredsForPass } +func NewDoltEnv(version string, config *DoltCliConfig, repoState *RepoState, doltDB *doltdb.DoltDB, fs filesys.Filesys) *DoltEnv { + return &DoltEnv{ + Version: version, + Config: config, + RepoState: repoState, + doltDB: doltDB, + FS: fs, + } +} + +func (dEnv *DoltEnv) DoltDB(ctx context.Context) *doltdb.DoltDB { + if dEnv.doltDB == nil { + LoadDoltDB(ctx, dEnv.FS, dEnv.urlStr, dEnv) + } + return dEnv.DoltDB(ctx) +} + +func (dEnv *DoltEnv) LoadDoltDBWithParams(ctx context.Context, nbf *types.NomsBinFormat, urlStr string, fs filesys.Filesys, params map[string]interface{}) error { + if dEnv.doltDB == nil { + ddb, err := doltdb.LoadDoltDBWithParams(ctx, types.Format_Default, urlStr, fs, params) + if err != nil { + return err + } + dEnv.doltDB = ddb + } + return nil +} + // IncompleteEnv returns a DoltEnv that is incomplete. There are cases where we want to know that the structure // of and database is correct on disk, but don't want to actually load the database. // @@ -107,7 +135,7 @@ func IncompleteEnv(FS filesys.Filesys) *DoltEnv { Config: nil, RepoState: nil, RSLoadErr: nil, - DoltDB: nil, + doltDB: nil, DBLoadError: nil, FS: FS, urlStr: "", @@ -187,7 +215,7 @@ func (dEnv *DoltEnv) ReloadDB(ctx context.Context) { func LoadDoltDB(ctx context.Context, fs filesys.Filesys, urlStr string, dEnv *DoltEnv) { ddb, dbLoadErr := doltdb.LoadDoltDB(ctx, types.Format_Default, urlStr, fs) - dEnv.DoltDB = ddb + dEnv.doltDB = ddb dEnv.DBLoadError = dbLoadErr dEnv.urlStr = urlStr @@ -268,7 +296,7 @@ func (dEnv *DoltEnv) initWorkingSetFromRepoState(ctx context.Context) error { return fmt.Errorf("Corrupt repo, invalid staged hash %s", stagedHash) } - stagedRoot, err = dEnv.DoltDB.ReadRootValue(ctx, stagedHash) + stagedRoot, err = dEnv.DoltDB(ctx).ReadRootValue(ctx, stagedHash) if err != nil { return err } @@ -281,13 +309,13 @@ func (dEnv *DoltEnv) initWorkingSetFromRepoState(ctx context.Context) error { return fmt.Errorf("Corrupt repo, invalid working hash %s", workingHash) } - workingRoot, err = dEnv.DoltDB.ReadRootValue(ctx, workingHash) + workingRoot, err = dEnv.DoltDB(ctx).ReadRootValue(ctx, workingHash) if err != nil { return err } } - mergeState, err := mergeStateToMergeState(ctx, dEnv.RepoState.merge, dEnv.DoltDB) + mergeState, err := mergeStateToMergeState(ctx, dEnv.RepoState.merge, dEnv.DoltDB(ctx)) if err != nil { return err } @@ -443,7 +471,7 @@ func (dEnv *DoltEnv) InitRepoWithNoData(ctx context.Context, nbf *types.NomsBinF return err } - dEnv.DoltDB, err = doltdb.LoadDoltDB(ctx, nbf, dEnv.urlStr, dEnv.FS) + dEnv.doltDB, err = doltdb.LoadDoltDB(ctx, nbf, dEnv.urlStr, dEnv.FS) return err } @@ -540,12 +568,12 @@ func (dEnv *DoltEnv) InitDBWithTime(ctx context.Context, nbf *types.NomsBinForma func (dEnv *DoltEnv) InitDBWithCommitMetaGenerator(ctx context.Context, nbf *types.NomsBinFormat, branchName string, commitMeta datas.CommitMetaGenerator) error { var err error - dEnv.DoltDB, err = doltdb.LoadDoltDB(ctx, nbf, dEnv.urlStr, dEnv.FS) + dEnv.doltDB, err = doltdb.LoadDoltDB(ctx, nbf, dEnv.urlStr, dEnv.FS) if err != nil { return err } - err = dEnv.DoltDB.WriteEmptyRepoWithCommitMetaGenerator(ctx, branchName, commitMeta) + err = dEnv.DoltDB(ctx).WriteEmptyRepoWithCommitMetaGenerator(ctx, branchName, commitMeta) if err != nil { return fmt.Errorf("%w: %v", doltdb.ErrNomsIO, err) } @@ -555,7 +583,7 @@ func (dEnv *DoltEnv) InitDBWithCommitMetaGenerator(ctx context.Context, nbf *typ // InitializeRepoState writes a default repo state to disk, consisting of a main branch and current root hash value. func (dEnv *DoltEnv) InitializeRepoState(ctx context.Context, branchName string) error { - commit, err := dEnv.DoltDB.ResolveCommitRef(ctx, ref.NewBranchRef(branchName)) + commit, err := dEnv.DoltDB(ctx).ResolveCommitRef(ctx, ref.NewBranchRef(branchName)) if err != nil { return err } @@ -663,7 +691,7 @@ func (dEnv *DoltEnv) WorkingRoot(ctx context.Context) (doltdb.RootValue, error) } func (dEnv *DoltEnv) WorkingSet(ctx context.Context) (*doltdb.WorkingSet, error) { - return WorkingSet(ctx, dEnv.DoltDB, dEnv.RepoStateReader()) + return WorkingSet(ctx, dEnv.DoltDB(ctx), dEnv.RepoStateReader()) } func WorkingSet(ctx context.Context, ddb *doltdb.DoltDB, rsr RepoStateReader) (*doltdb.WorkingSet, error) { @@ -709,7 +737,7 @@ func (dEnv *DoltEnv) UpdateWorkingRoot(ctx context.Context, newRoot doltdb.RootV wsRef = ws.Ref() } - return dEnv.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, dEnv.workingSetMeta(), nil) + return dEnv.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, dEnv.workingSetMeta(), nil) } // UpdateWorkingSet updates the working set for the current working branch to the value given. @@ -728,7 +756,7 @@ func (dEnv *DoltEnv) UpdateWorkingSet(ctx context.Context, ws *doltdb.WorkingSet } } - return dEnv.DoltDB.UpdateWorkingSet(ctx, ws.Ref(), ws, h, dEnv.workingSetMeta(), nil) + return dEnv.DoltDB(ctx).UpdateWorkingSet(ctx, ws.Ref(), ws, h, dEnv.workingSetMeta(), nil) } type repoStateReader struct { @@ -802,12 +830,12 @@ func (dEnv *DoltEnv) HeadRoot(ctx context.Context) (doltdb.RootValue, error) { } func (dEnv *DoltEnv) HeadCommit(ctx context.Context) (*doltdb.Commit, error) { - return dEnv.DoltDB.ResolveCommitRef(ctx, dEnv.RepoState.CWBHeadRef()) + return dEnv.DoltDB(ctx).ResolveCommitRef(ctx, dEnv.RepoState.CWBHeadRef()) } func (dEnv *DoltEnv) DbData() DbData { return DbData{ - Ddb: dEnv.DoltDB, + Ddb: dEnv.DoltDB(ctx), Rsw: dEnv.RepoStateWriter(), Rsr: dEnv.RepoStateReader(), } @@ -848,7 +876,7 @@ func (dEnv *DoltEnv) UpdateStagedRoot(ctx context.Context, newRoot doltdb.RootVa wsRef = ws.Ref() } - return dEnv.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, dEnv.workingSetMeta(), nil) + return dEnv.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, dEnv.workingSetMeta(), nil) } func (dEnv *DoltEnv) AbortMerge(ctx context.Context) error { @@ -862,7 +890,7 @@ func (dEnv *DoltEnv) AbortMerge(ctx context.Context) error { return err } - return dEnv.DoltDB.UpdateWorkingSet(ctx, ws.Ref(), ws.AbortMerge(), h, dEnv.workingSetMeta(), nil) + return dEnv.DoltDB(ctx).UpdateWorkingSet(ctx, ws.Ref(), ws.AbortMerge(), h, dEnv.workingSetMeta(), nil) } func (dEnv *DoltEnv) workingSetMeta() *datas.WorkingSetMeta { @@ -1008,7 +1036,7 @@ func (dEnv *DoltEnv) RemoveRemote(ctx context.Context, name string) error { return ErrRemoteNotFound } - ddb := dEnv.DoltDB + ddb := dEnv.DoltDB(ctx) refs, err := ddb.GetRemoteRefs(ctx) if err != nil { return fmt.Errorf("%w: %s", ErrFailedToReadFromDb, err.Error()) @@ -1102,7 +1130,7 @@ func (dEnv *DoltEnv) FindCreds(credsDir, pubKeyOrId string) (string, error) { func (dEnv *DoltEnv) FindRef(ctx context.Context, refStr string) (ref.DoltRef, error) { localRef := ref.NewBranchRef(refStr) - if hasRef, err := dEnv.DoltDB.HasRef(ctx, localRef); err != nil { + if hasRef, err := dEnv.DoltDB(ctx).HasRef(ctx, localRef); err != nil { return nil, err } else if hasRef { return localRef, nil @@ -1121,7 +1149,7 @@ func (dEnv *DoltEnv) FindRef(ctx context.Context, refStr string) (ref.DoltRef, e return nil, err } - if hasRef, err = dEnv.DoltDB.HasRef(ctx, remoteRef); err != nil { + if hasRef, err = dEnv.DoltDB(ctx).HasRef(ctx, remoteRef); err != nil { return nil, err } else if hasRef { return remoteRef, nil @@ -1234,7 +1262,7 @@ func (dEnv *DoltEnv) DbEaFactory() editor.DbEaFactory { if err != nil { return nil } - return editor.NewDbEaFactory(tmpDir, dEnv.DoltDB.ValueReadWriter()) + return editor.NewDbEaFactory(tmpDir, dEnv.DoltDB(ctx).ValueReadWriter()) } func (dEnv *DoltEnv) BulkDbEaFactory() editor.DbEaFactory { @@ -1242,9 +1270,9 @@ func (dEnv *DoltEnv) BulkDbEaFactory() editor.DbEaFactory { if err != nil { return nil } - return editor.NewBulkImportTEAFactory(dEnv.DoltDB.ValueReadWriter(), tmpDir) + return editor.NewBulkImportTEAFactory(dEnv.DoltDB(ctx).ValueReadWriter(), tmpDir) } func (dEnv *DoltEnv) IsAccessModeReadOnly() bool { - return dEnv.DoltDB.AccessMode() == chunks.ExclusiveAccessMode_ReadOnly + return dEnv.DoltDB(ctx).AccessMode() == chunks.ExclusiveAccessMode_ReadOnly } diff --git a/go/libraries/doltcore/env/environment_test.go b/go/libraries/doltcore/env/environment_test.go index fcc942607bc..8ce4aba8ce1 100644 --- a/go/libraries/doltcore/env/environment_test.go +++ b/go/libraries/doltcore/env/environment_test.go @@ -148,7 +148,7 @@ func TestInitRepo(t *testing.T) { dEnv, _ := createTestEnv(false, false) err := dEnv.InitRepo(context.Background(), types.Format_Default, "aoeu aoeu", "aoeu@aoeu.org", DefaultInitBranch) require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() _, err = dEnv.WorkingRoot(context.Background()) require.NoError(t, err) @@ -173,7 +173,7 @@ func TestMigrateWorkingSet(t *testing.T) { err = dEnv.InitRepo(context.Background(), types.Format_Default, "aoeu aoeu", "aoeu@aoeu.org", DefaultInitBranch) require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ws, err := dEnv.WorkingSet(context.Background()) require.NoError(t, err) @@ -183,7 +183,7 @@ func TestMigrateWorkingSet(t *testing.T) { // We don't have a merge in progress, so we'll just fake one. We're only interested in seeing the fields loaded and // persisted to the working set - commit, err := dEnv.DoltDB.ResolveCommitRef(context.Background(), dEnv.RepoState.CWBHeadRef()) + commit, err := dEnv.DoltDB(ctx).ResolveCommitRef(context.Background(), dEnv.RepoState.CWBHeadRef()) require.NoError(t, err) ws.StartMerge(commit, "HEAD") @@ -207,7 +207,7 @@ func TestMigrateWorkingSet(t *testing.T) { } // Clear the working set - require.NoError(t, dEnv.DoltDB.DeleteWorkingSet(context.Background(), ws.Ref())) + require.NoError(t, dEnv.DoltDB(ctx).DeleteWorkingSet(context.Background(), ws.Ref())) // Make sure it's gone _, err = dEnv.WorkingSet(context.Background()) diff --git a/go/libraries/doltcore/env/memory.go b/go/libraries/doltcore/env/memory.go index 4c2ed8f5768..a2202933209 100644 --- a/go/libraries/doltcore/env/memory.go +++ b/go/libraries/doltcore/env/memory.go @@ -145,7 +145,7 @@ func (m MemoryRepoState) UpdateStagedRoot(ctx context.Context, newRoot doltdb.Ro wsRef = ws.Ref() } - return m.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, m.workingSetMeta(), nil) + return m.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, m.workingSetMeta(), nil) } func (m MemoryRepoState) UpdateWorkingRoot(ctx context.Context, newRoot doltdb.RootValue) error { @@ -175,7 +175,7 @@ func (m MemoryRepoState) UpdateWorkingRoot(ctx context.Context, newRoot doltdb.R wsRef = ws.Ref() } - return m.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, m.workingSetMeta(), nil) + return m.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, m.workingSetMeta(), nil) } func (m MemoryRepoState) WorkingSet(ctx context.Context) (*doltdb.WorkingSet, error) { @@ -188,7 +188,7 @@ func (m MemoryRepoState) WorkingSet(ctx context.Context) (*doltdb.WorkingSet, er return nil, err } - workingSet, err := m.DoltDB.ResolveWorkingSet(ctx, workingSetRef) + workingSet, err := m.DoltDB(ctx).ResolveWorkingSet(ctx, workingSetRef) if err != nil { return nil, err } diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index 820bdfaca28..9e6f09426fa 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -230,7 +230,7 @@ func (mrEnv *MultiRepoEnv) ReloadDBs( for _, namedEnv := range mrEnv.envs { dEnv := namedEnv.env - if dEnv.DoltDB == nil { + if dEnv.DoltDB(ctx) == nil { dEnv.ReloadDB(ctx) } if !dEnv.Valid() { @@ -354,7 +354,7 @@ func enforceSingleFormat(envSet []NamedEnv) []NamedEnv { formats := set.NewEmptyStrSet() for _, namedEnv := range envSet { dEnv := namedEnv.env - formats.Add(dEnv.DoltDB.Format().VersionString()) + formats.Add(dEnv.DoltDB(ctx).Format().VersionString()) } var nbf string @@ -365,7 +365,7 @@ func enforceSingleFormat(envSet []NamedEnv) []NamedEnv { // otherwise, pick an arbitrary format for _, namedEnv := range envSet { dEnv := namedEnv.env - nbf = dEnv.DoltDB.Format().VersionString() + nbf = dEnv.DoltDB(ctx).Format().VersionString() break } } @@ -375,7 +375,7 @@ func enforceSingleFormat(envSet []NamedEnv) []NamedEnv { for _, namedEnv := range envSet { name := namedEnv.name dEnv := namedEnv.env - found := dEnv.DoltDB.Format().VersionString() + found := dEnv.DoltDB(ctx).Format().VersionString() if found != nbf { logrus.Infof(template, name, nbf, found) } else { diff --git a/go/libraries/doltcore/env/repo_state.go b/go/libraries/doltcore/env/repo_state.go index 5e7b5259ac0..0bce2f0bff5 100644 --- a/go/libraries/doltcore/env/repo_state.go +++ b/go/libraries/doltcore/env/repo_state.go @@ -56,7 +56,6 @@ type RepoStateReadWriter interface { type RemoteDbProvider interface { GetRemoteDB(ctx context.Context, format *types.NomsBinFormat, r Remote, withCaching bool) (*doltdb.DoltDB, error) } - type DbData struct { Ddb *doltdb.DoltDB Rsw RepoStateWriter diff --git a/go/libraries/doltcore/merge/integration_test.go b/go/libraries/doltcore/merge/integration_test.go index 65fd012be1d..e290d02547d 100644 --- a/go/libraries/doltcore/merge/integration_test.go +++ b/go/libraries/doltcore/merge/integration_test.go @@ -122,7 +122,7 @@ func TestMerge(t *testing.T) { t.Run(test.name, func(t *testing.T) { ctx := context.Background() dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tc := range setupCommon { exit := tc.exec(t, ctx, dEnv) @@ -135,7 +135,7 @@ func TestMerge(t *testing.T) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - actRows, err := sqle.ExecuteSelect(dEnv, root, test.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, test.query) require.NoError(t, err) require.Equal(t, len(test.expected), len(actRows)) @@ -244,7 +244,7 @@ func TestMergeConflicts(t *testing.T) { t.Run(test.name, func(t *testing.T) { ctx := context.Background() dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tc := range setupCommon { exit := tc.exec(t, ctx, dEnv) @@ -263,7 +263,7 @@ func TestMergeConflicts(t *testing.T) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - actRows, err := sqle.ExecuteSelect(dEnv, root, test.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, test.query) require.NoError(t, err) require.Equal(t, len(test.expected), len(actRows)) @@ -293,7 +293,7 @@ const ( func TestMergeConcurrency(t *testing.T) { ctx := context.Background() dEnv := setupConcurrencyTest(t, ctx) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() _, eng := engineFromEnvironment(ctx, dEnv) eg, ctx := errgroup.WithContext(ctx) diff --git a/go/libraries/doltcore/merge/keyless_integration_test.go b/go/libraries/doltcore/merge/keyless_integration_test.go index e7652f80a20..658ad163d39 100644 --- a/go/libraries/doltcore/merge/keyless_integration_test.go +++ b/go/libraries/doltcore/merge/keyless_integration_test.go @@ -106,7 +106,7 @@ func TestKeylessMerge(t *testing.T) { t.Run(test.name, func(t *testing.T) { ctx := context.Background() dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) @@ -265,7 +265,7 @@ func TestKeylessMergeConflicts(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() setupTest(t, ctx, dEnv, test.setup) root, err := dEnv.WorkingRoot(ctx) @@ -279,7 +279,7 @@ func TestKeylessMergeConflicts(t *testing.T) { t.Run(test.name+"_resolved_ours", func(t *testing.T) { dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() setupTest(t, ctx, dEnv, test.setup) cliCtx, verr := cmd.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) @@ -299,7 +299,7 @@ func TestKeylessMergeConflicts(t *testing.T) { }) t.Run(test.name+"_resolved_theirs", func(t *testing.T) { dEnv := dtu.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() setupTest(t, ctx, dEnv, test.setup) cliCtx, verr := cmd.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) diff --git a/go/libraries/doltcore/merge/schema_integration_test.go b/go/libraries/doltcore/merge/schema_integration_test.go index 04db04f971f..63033fe64b9 100644 --- a/go/libraries/doltcore/merge/schema_integration_test.go +++ b/go/libraries/doltcore/merge/schema_integration_test.go @@ -541,12 +541,12 @@ func newColTypeInfo(name string, tag uint64, typeInfo typeinfo.TypeInfo, partOfP return c } -func fkCollection(fks ...doltdb.ForeignKey) *doltdb.ForeignKeyCollection { - fkc, err := doltdb.NewForeignKeyCollection(fks...) - if err != nil { - panic(err) - } - return fkc +func fkCollection(fks ...DoltDB(ctx).ForeignKey) *doltdb.ForeignKeyCollection { +fkc, err := doltdb.NewForeignKeyCollection(fks...) +if err != nil { +panic(err) +} +return fkc } func testMergeSchemas(t *testing.T, test mergeSchemaTest) { @@ -556,7 +556,7 @@ func testMergeSchemas(t *testing.T, test mergeSchemaTest) { } dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() cliCtx, _ := commands.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) @@ -604,7 +604,7 @@ func testMergeSchemasWithConflicts(t *testing.T, test mergeSchemaConflictTest) { } dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() for _, c := range setupCommon { exit := c.exec(t, ctx, dEnv) @@ -665,7 +665,7 @@ func testMergeSchemasWithConflicts(t *testing.T, test mergeSchemaConflictTest) { func testMergeForeignKeys(t *testing.T, test mergeForeignKeyTest) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() for _, c := range setupForeignKeyTests { exit := c.exec(t, ctx, dEnv) @@ -697,7 +697,7 @@ func testMergeForeignKeys(t *testing.T, test mergeForeignKeyTest) { require.NoError(t, err) otherRoot := otherWS.WorkingRoot() - opts := editor.TestEditorOptions(dEnv.DoltDB.ValueReadWriter()) + opts := editor.TestEditorOptions(dEnv.DoltDB(ctx).ValueReadWriter()) mo := merge.MergeOpts{IsCherryPick: false} result, err := merge.MergeRoots(sql.NewContext(ctx), mainRoot, otherRoot, ancRoot, mainWS, otherWS, opts, mo) assert.NoError(t, err) diff --git a/go/libraries/doltcore/merge/schema_merge_test.go b/go/libraries/doltcore/merge/schema_merge_test.go index 8eae1d67622..e4738680fbb 100644 --- a/go/libraries/doltcore/merge/schema_merge_test.go +++ b/go/libraries/doltcore/merge/schema_merge_test.go @@ -1788,23 +1788,23 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool func setupSchemaMergeTest(t *testing.T, test schemaMergeTest) (anc, left, right, merged doltdb.RootValue) { denv := dtestutils.CreateTestEnv() var eo editor.Options - eo = eo.WithDeaf(editor.NewInMemDeaf(denv.DoltDB.ValueReadWriter())) - anc = makeRootWithTable(t, denv.DoltDB, eo, test.ancestor) + eo = eo.WithDeaf(editor.NewInMemDeaf(denv.DoltDB(ctx).ValueReadWriter())) + anc = makeRootWithTable(t, denv.DoltDB(ctx), eo, test.ancestor) assert.NotNil(t, anc) if test.left != nil { - left = makeRootWithTable(t, denv.DoltDB, eo, *test.left) + left = makeRootWithTable(t, denv.DoltDB(ctx), eo, *test.left) assert.NotNil(t, left) } else { - left = makeEmptyRoot(t, denv.DoltDB, eo) + left = makeEmptyRoot(t, denv.DoltDB(ctx), eo) } if test.right != nil { - right = makeRootWithTable(t, denv.DoltDB, eo, *test.right) + right = makeRootWithTable(t, denv.DoltDB(ctx), eo, *test.right) assert.NotNil(t, right) } else { - right = makeEmptyRoot(t, denv.DoltDB, eo) + right = makeEmptyRoot(t, denv.DoltDB(ctx), eo) } if !test.conflict { - merged = makeRootWithTable(t, denv.DoltDB, eo, test.merged) + merged = makeRootWithTable(t, denv.DoltDB(ctx), eo, test.merged) assert.NotNil(t, merged) } return @@ -1828,8 +1828,8 @@ func tbl(ns namedSchema, rows ...sql.Row) *table { func sch(definition string) namedSchema { denv := dtestutils.CreateTestEnv() - vrw := denv.DoltDB.ValueReadWriter() - ns := denv.DoltDB.NodeStore() + vrw := denv.DoltDB(ctx).ValueReadWriter() + ns := denv.DoltDB(ctx).NodeStore() ctx := context.Background() root, _ := doltdb.EmptyRootValue(ctx, vrw, ns) eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, denv) diff --git a/go/libraries/doltcore/migrate/environment.go b/go/libraries/doltcore/migrate/environment.go index b4cb6984c63..16f739c0aec 100644 --- a/go/libraries/doltcore/migrate/environment.go +++ b/go/libraries/doltcore/migrate/environment.go @@ -73,15 +73,13 @@ func NewEnvironment(ctx context.Context, existing *env.DoltEnv) (Environment, er return Environment{}, err } - migration := &env.DoltEnv{ - Version: existing.Version, - Config: config, - RepoState: existing.RepoState, - DoltDB: mdb, - FS: mfs, - //urlStr: urlStr, - //hdp: hdp, - } + migration := env.NewDoltEnv( + existing.Version, + config, + existing.RepoState, + mdb, + mfs, + ) return Environment{ Migration: migration, diff --git a/go/libraries/doltcore/migrate/integration_test.go b/go/libraries/doltcore/migrate/integration_test.go index ea385447889..17726d62424 100644 --- a/go/libraries/doltcore/migrate/integration_test.go +++ b/go/libraries/doltcore/migrate/integration_test.go @@ -153,7 +153,7 @@ func TestMigration(t *testing.T) { root, err := postEnv.WorkingRoot(ctx) require.NoError(t, err) for _, a := range test.asserts { - actual, err := sqle.ExecuteSelect(postEnv, root, a.query) + actual, err := sqle.ExecuteSelect(ctx, postEnv, root, a.query) assert.NoError(t, err) assert.Equal(t, a.expected, actual) } @@ -217,41 +217,41 @@ func runMigration(t *testing.T, ctx context.Context, preEnv *env.DoltEnv) (postE Config: preEnv.Config, RepoState: preEnv.RepoState, FS: preEnv.FS, - DoltDB: ddb, + doltDB: ddb, } - err = migrate.TraverseDAG(ctx, migrate.Environment{}, preEnv.DoltDB, postEnv.DoltDB) + err = migrate.TraverseDAG(ctx, migrate.Environment{}, preEnv.DoltDB(ctx), postEnv.DoltDB(ctx)) assert.NoError(t, err) return } func initTestMigrationDB(ctx context.Context) (*doltdb.DoltDB, error) { - var db datas.Database - storage := &chunks.MemoryStorage{} - cs := storage.NewViewWithFormat("__DOLT__") - vrw := types.NewValueStore(cs) - ns := tree.NewNodeStore(cs) - db = datas.NewTypesDatabase(vrw, ns) +var db datas.Database +storage := &chunks.MemoryStorage{} +cs := storage.NewViewWithFormat("__DOLT__") +vrw := types.NewValueStore(cs) +ns := tree.NewNodeStore(cs) +db = datas.NewTypesDatabase(vrw, ns) - name, email := "user", "user@fake.horse" - meta, err := datas.NewCommitMeta(name, email, "test migration") - if err != nil { - return nil, err - } +name, email := "user", "user@fake.horse" +meta, err := datas.NewCommitMeta(name, email, "test migration") +if err != nil { +return nil, err +} - rv, err := doltdb.EmptyRootValue(ctx, vrw, ns) - if err != nil { - return nil, err - } +rv, err := doltdb.EmptyRootValue(ctx, vrw, ns) +if err != nil { +return nil, err +} - ds, err := db.GetDataset(ctx, ref.NewInternalRef("migration").String()) - if err != nil { - return nil, err - } +ds, err := db.GetDataset(ctx, ref.NewInternalRef("migration").String()) +if err != nil { +return nil, err +} - _, err = db.Commit(ctx, ds, rv.NomsValue(), datas.CommitOptions{Meta: meta}) - if err != nil { - return nil, err - } - return doltdb.DoltDBFromCS(cs, ""), nil +_, err = db.Commit(ctx, ds, rv.NomsValue(), datas.CommitOptions{Meta: meta}) +if err != nil { +return nil, err +} +return doltdb.DoltDB(ctx)FromCS(cs, ""), nil } diff --git a/go/libraries/doltcore/mvdata/data_loc_test.go b/go/libraries/doltcore/mvdata/data_loc_test.go index aad5b9bddf3..212edd10305 100644 --- a/go/libraries/doltcore/mvdata/data_loc_test.go +++ b/go/libraries/doltcore/mvdata/data_loc_test.go @@ -195,7 +195,7 @@ func TestCreateRdWr(t *testing.T) { } dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(context.Background()) require.NoError(t, err) dEnv.FS.WriteFile(testSchemaFileName, []byte(testSchema), os.ModePerm) diff --git a/go/libraries/doltcore/mvdata/engine_table_writer.go b/go/libraries/doltcore/mvdata/engine_table_writer.go index dc91cac6e7a..9c1236395d6 100644 --- a/go/libraries/doltcore/mvdata/engine_table_writer.go +++ b/go/libraries/doltcore/mvdata/engine_table_writer.go @@ -61,7 +61,7 @@ type SqlEngineTableWriter struct { } func NewSqlEngineTableWriter(ctx context.Context, dEnv *env.DoltEnv, createTableSchema, rowOperationSchema schema.Schema, options *MoverOptions, statsCB noms.StatsCB) (*SqlEngineTableWriter, error) { - // TODO: Assert that dEnv.DoltDB.AccessMode() != ReadOnly? + // TODO: Assert that dEnv.DoltDB(ctx).AccessMode() != ReadOnly? mrEnv, err := env.MultiEnvForDirectory(ctx, dEnv.Config.WriteableConfig(), dEnv.FS, dEnv.Version, dEnv) if err != nil { diff --git a/go/libraries/doltcore/rebase/filter_branch.go b/go/libraries/doltcore/rebase/filter_branch.go index 10d7d61360f..af7bd39bd41 100644 --- a/go/libraries/doltcore/rebase/filter_branch.go +++ b/go/libraries/doltcore/rebase/filter_branch.go @@ -73,11 +73,11 @@ type CommitReplayer interface { // AllBranchesAndTags rewrites the history of all branches and tags in the repo using the |replay| function. func AllBranchesAndTags(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted bool, commitReplayer CommitReplayer, rootReplayer RootReplayer, nerf NeedsRebaseFn) error { - branches, err := dEnv.DoltDB.GetBranches(ctx) + branches, err := dEnv.DoltDB(ctx).GetBranches(ctx) if err != nil { return err } - tags, err := dEnv.DoltDB.GetTags(ctx) + tags, err := dEnv.DoltDB(ctx).GetTags(ctx) if err != nil { return err } @@ -86,7 +86,7 @@ func AllBranchesAndTags(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted // AllBranches rewrites the history of all branches in the repo using the |replay| function. func AllBranches(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted bool, commitReplayer CommitReplayer, rootReplayer RootReplayer, nerf NeedsRebaseFn) error { - branches, err := dEnv.DoltDB.GetBranches(ctx) + branches, err := dEnv.DoltDB(ctx).GetBranches(ctx) if err != nil { return err } diff --git a/go/libraries/doltcore/rebase/filter_branch_test.go b/go/libraries/doltcore/rebase/filter_branch_test.go index d8f6d5a0585..fbc263f8f41 100644 --- a/go/libraries/doltcore/rebase/filter_branch_test.go +++ b/go/libraries/doltcore/rebase/filter_branch_test.go @@ -216,7 +216,7 @@ func setupFilterBranchTests(t *testing.T) *env.DoltEnv { func testFilterBranch(t *testing.T, test filterBranchTest) { ctx := context.Background() dEnv := setupFilterBranchTests(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, err := cmd.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) require.NoError(t, err) @@ -235,7 +235,7 @@ func testFilterBranch(t *testing.T, test filterBranchTest) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - actRows, err := sqle.ExecuteSelect(dEnv, root, a.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, a.query) require.NoError(t, err) require.Equal(t, a.rows, actRows) }) diff --git a/go/libraries/doltcore/schema/encoding/integration_test.go b/go/libraries/doltcore/schema/encoding/integration_test.go index 84137b7becf..935ea5471db 100644 --- a/go/libraries/doltcore/schema/encoding/integration_test.go +++ b/go/libraries/doltcore/schema/encoding/integration_test.go @@ -71,7 +71,7 @@ func testSchemaSerializationFlatbuffers(t *testing.T, sch schema.Schema) { func parseSchemaString(t *testing.T, s string) schema.Schema { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) eng, db, err := engine.NewSqlEngineForEnv(ctx, dEnv) diff --git a/go/libraries/doltcore/schema/integration_test.go b/go/libraries/doltcore/schema/integration_test.go index cd3f5d4bb19..a3fd58275d1 100644 --- a/go/libraries/doltcore/schema/integration_test.go +++ b/go/libraries/doltcore/schema/integration_test.go @@ -185,5 +185,5 @@ func runTestSql(t *testing.T, ctx context.Context, setup []string) (*doltdb.Dolt } root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - return dEnv.DoltDB, root + return dEnv.DoltDB(ctx), root } diff --git a/go/libraries/doltcore/sqle/alterschema_test.go b/go/libraries/doltcore/sqle/alterschema_test.go index fe9807c4570..be221e1adad 100644 --- a/go/libraries/doltcore/sqle/alterschema_test.go +++ b/go/libraries/doltcore/sqle/alterschema_test.go @@ -84,12 +84,12 @@ func TestRenameTable(t *testing.T) { t.Run(tt.description, func(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) // setup tests - root, err = ExecuteSql(dEnv, root, setup) + root, err = ExecuteSql(ctx, dEnv, root, setup) require.NoError(t, err) schemas, err := doltdb.GetAllSchemas(ctx, root) @@ -229,7 +229,7 @@ func TestAddColumnToTable(t *testing.T) { ctx := context.Background() dEnv, err := makePeopleTable(ctx, dtestutils.CreateTestEnv()) require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) @@ -435,9 +435,9 @@ func TestDropPks(t *testing.T) { childFkName := "fk" t.Run(tt.name, func(t *testing.T) { - dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() ctx := context.Background() + dEnv := dtestutils.CreateTestEnv() + defer dEnv.DoltDB(ctx).Close() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} @@ -749,7 +749,7 @@ func TestModifyColumn(t *testing.T) { ctx := context.Background() dEnv, err := makePeopleTable(ctx, dtestutils.CreateTestEnv()) require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) assert.NoError(t, err) diff --git a/go/libraries/doltcore/sqle/binlogreplication/binlog_primary_hooks.go b/go/libraries/doltcore/sqle/binlogreplication/binlog_primary_hooks.go index dc179059c8d..dd60d290626 100644 --- a/go/libraries/doltcore/sqle/binlogreplication/binlog_primary_hooks.go +++ b/go/libraries/doltcore/sqle/binlogreplication/binlog_primary_hooks.go @@ -45,7 +45,7 @@ func NewBinlogInitDatabaseHook(_ context.Context, listeners []doltdb.DatabaseUpd // After creating the database, try to replicate any existing data. // This is only needed when dolt_undrop() has been used to restore a dropped database. - err = replicateExistingData(ctx, denv.DoltDB, BinlogBranch, listener, name) + err = replicateExistingData(ctx, denv.DoltDB(ctx), BinlogBranch, listener, name) if err != nil { logrus.Errorf("error replicating data from newly created database: %s", err.Error()) return err diff --git a/go/libraries/doltcore/sqle/cluster/commithook_test.go b/go/libraries/doltcore/sqle/cluster/commithook_test.go index 7075a2f372e..d1135094298 100644 --- a/go/libraries/doltcore/sqle/cluster/commithook_test.go +++ b/go/libraries/doltcore/sqle/cluster/commithook_test.go @@ -28,16 +28,17 @@ import ( func TestCommitHookStartsNotCaughtUp(t *testing.T) { srcEnv := dtestutils.CreateTestEnv() t.Cleanup(func() { - srcEnv.DoltDB.Close() + srcEnv.DoltDB(ctx).Close() }) destEnv := dtestutils.CreateTestEnv() t.Cleanup(func() { - destEnv.DoltDB.Close() + destEnv.DoltDB(ctx).Close() }) - hook := newCommitHook(logrus.StandardLogger(), "origin", "https://localhost:50051/mydb", "mydb", RolePrimary, func(context.Context) (*doltdb.DoltDB, error) { - return destEnv.DoltDB, nil - }, srcEnv.DoltDB, t.TempDir()) + hook := newCommitHook(logrus.StandardLogger(), "origin", "https://localhost:50051/mydb", "mydb", RolePrimary, func(context.Context) (*doltdb.DoltDB, error) + { + return destEnv.DoltDB(ctx), nil + }, srcEnv.DoltDB(ctx), t.TempDir()) require.False(t, hook.isCaughtUp()) } diff --git a/go/libraries/doltcore/sqle/cluster/controller.go b/go/libraries/doltcore/sqle/cluster/controller.go index 3845a1e9fa8..3212dc393b6 100644 --- a/go/libraries/doltcore/sqle/cluster/controller.go +++ b/go/libraries/doltcore/sqle/cluster/controller.go @@ -314,8 +314,8 @@ func (c *Controller) applyCommitHooks(ctx context.Context, name string, bt *sql. } commitHook := newCommitHook(c.lgr, r.Name(), remote.Url, name, c.role, func(ctx context.Context) (*doltdb.DoltDB, error) { return remote.GetRemoteDB(ctx, types.Format_Default, dialprovider) - }, denv.DoltDB, ttfdir) - denv.DoltDB.PrependCommitHook(ctx, commitHook) + }, denv.DoltDB(ctx), ttfdir) + denv.DoltDB(ctx).PrependCommitHook(ctx, commitHook) if err := commitHook.Run(bt); err != nil { return nil, err } diff --git a/go/libraries/doltcore/sqle/cluster/initdbhook.go b/go/libraries/doltcore/sqle/cluster/initdbhook.go index 1d386392d82..7c9071f669f 100644 --- a/go/libraries/doltcore/sqle/cluster/initdbhook.go +++ b/go/libraries/doltcore/sqle/cluster/initdbhook.go @@ -83,8 +83,8 @@ func NewInitDatabaseHook(controller *Controller, bt *sql.BackgroundThreads) sqle // XXX: An error here means we are not replicating to every standby. return err } - commitHook := newCommitHook(controller.lgr, r.Name(), remoteUrls[i], name, role, remoteDBs[i], denv.DoltDB, ttfdir) - denv.DoltDB.PrependCommitHook(ctx, commitHook) + commitHook := newCommitHook(controller.lgr, r.Name(), remoteUrls[i], name, role, remoteDBs[i], denv.DoltDB(ctx), ttfdir) + denv.DoltDB(ctx).PrependCommitHook(ctx, commitHook) controller.registerCommitHook(commitHook) if err := commitHook.Run(bt); err != nil { // XXX: An error here means we are not replicating to every standby. diff --git a/go/libraries/doltcore/sqle/common_test.go b/go/libraries/doltcore/sqle/common_test.go index 3e889ece5fc..7b3b6361f55 100644 --- a/go/libraries/doltcore/sqle/common_test.go +++ b/go/libraries/doltcore/sqle/common_test.go @@ -178,8 +178,8 @@ func CreateTestTable(t *testing.T, dEnv *env.DoltEnv, tableName string, sch sche ctx := context.Background() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - vrw := dEnv.DoltDB.ValueReadWriter() - ns := dEnv.DoltDB.NodeStore() + vrw := dEnv.DoltDB(ctx).ValueReadWriter() + ns := dEnv.DoltDB(ctx).NodeStore() rows, err := durable.NewEmptyPrimaryIndex(ctx, vrw, ns, sch) require.NoError(t, err) @@ -189,7 +189,7 @@ func CreateTestTable(t *testing.T, dEnv *env.DoltEnv, tableName string, sch sche require.NoError(t, err) err = dEnv.UpdateWorkingRoot(ctx, root) require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, queries) + root, err = ExecuteSql(ctx, dEnv, root, queries) require.NoError(t, err) err = dEnv.UpdateWorkingRoot(ctx, root) require.NoError(t, err) @@ -199,7 +199,7 @@ func ExecuteSetupSQL(ctx context.Context, queries string) SetupFn { return func(t *testing.T, dEnv *env.DoltEnv) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, queries) + root, err = ExecuteSql(ctx, dEnv, root, queries) require.NoError(t, err) err = dEnv.UpdateWorkingRoot(ctx, root) require.NoError(t, err) diff --git a/go/libraries/doltcore/sqle/database.go b/go/libraries/doltcore/sqle/database.go index 390f2e0c384..639bac29bcf 100644 --- a/go/libraries/doltcore/sqle/database.go +++ b/go/libraries/doltcore/sqle/database.go @@ -222,7 +222,7 @@ func (db Database) RequestedName() string { return db.requestedName } -// GetDoltDB gets the underlying DoltDB of the Database +// GetDoltDB gets the underlying doltDB of the Database func (db Database) GetDoltDB() *doltdb.DoltDB { return db.ddb } diff --git a/go/libraries/doltcore/sqle/database_provider.go b/go/libraries/doltcore/sqle/database_provider.go index bda772aad43..218b506bc18 100644 --- a/go/libraries/doltcore/sqle/database_provider.go +++ b/go/libraries/doltcore/sqle/database_provider.go @@ -633,7 +633,7 @@ func ConfigureReplicationDatabaseHook(ctx *sql.Context, p *DoltDatabaseProvider, // TODO: params for AWS, others that need them r := env.NewRemote(remoteName, remoteUrl, nil) - err := r.Prepare(ctx, newEnv.DoltDB.Format(), p.remoteDialer) + err := r.Prepare(ctx, newEnv.DoltDB(ctx).Format(), p.remoteDialer) if err != nil { return err } @@ -649,11 +649,11 @@ func ConfigureReplicationDatabaseHook(ctx *sql.Context, p *DoltDatabaseProvider, return err } - newEnv.DoltDB.SetCommitHooks(ctx, commitHooks) + newEnv.DoltDB(ctx).SetCommitHooks(ctx, commitHooks) // After setting hooks on the newly created DB, we need to do the first push manually branchRef := ref.NewBranchRef(p.defaultBranch) - return newEnv.DoltDB.ExecuteCommitHooks(ctx, branchRef.String()) + return newEnv.DoltDB(ctx).ExecuteCommitHooks(ctx, branchRef.String()) } // CloneDatabaseFromRemote implements DoltDatabaseProvider interface diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_checkout.go b/go/libraries/doltcore/sqle/dprocedures/dolt_checkout.go index 6a5efa96fd3..1ba25636d21 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_checkout.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_checkout.go @@ -156,7 +156,7 @@ func doDoltCheckout(ctx *sql.Context, args []string) (statusCode int, successMes // HEAD and check out the branch again. // // TODO: This is all quite racey, but so is the - // handling in DoltDB, etc. + // handling in doltDB, etc. err = createWorkingSetForLocalBranch(ctx, dbData.Ddb, branchName) if err != nil { return 1, "", err @@ -266,7 +266,7 @@ func isReadOnlyDatabase(ctx *sql.Context, dbName string) (bool, error) { // working set gets created in the new case are different, since the CLI takes // the working set with it. // -// TODO: This is cribbed heavily from doltdb.*DoltDB.NewBranchAtCommit. +// TODO: This is cribbed heavily from doltdb.*doltDB.NewBranchAtCommit. func createWorkingSetForLocalBranch(ctx *sql.Context, ddb *doltdb.DoltDB, branchName string) error { branchRef := ref.NewBranchRef(branchName) commit, err := ddb.ResolveCommitRef(ctx, branchRef) diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go index dc8e28f83b3..ddcdcc1ea00 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go @@ -346,13 +346,14 @@ func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.Wor } // TODO: There's an issue with using `dolt conflicts resolve` for schema conflicts, since having - // schema conflicts reported means that we haven't yet merged the table data. In some case, - // such as when there have ONLY been schema changes and no data changes that need to be - // merged, it is safe to use `dolt conflicts resolve`, but there are many other cases where the - // data changes would not be merged and could surprise customers. So, we are being cautious to - // prevent auto-resolution of schema changes with `dolt conflicts resolve` until we have a fix - // for resolving schema changes AND merging data (including dealing with any data conflicts). - // For more details, see: https://github.com/dolthub/dolt/issues/6616 + // + // schema conflicts reported means that we haven't yet merged the table data. In some case, + // such as when there have ONLY been schema changes and no data changes that need to be + // merged, it is safe to use `dolt conflicts resolve`, but there are many other cases where the + // data changes would not be merged and could surprise customers. So, we are being cautious to + // prevent auto-resolution of schema changes with `dolt conflicts resolve` until we have a fix + // for resolving schema changes AND merging data (including dealing with any data conflicts). + // For more details, see: https://github.com/dolthub/dolt/issues/6616 if ws.MergeState().HasSchemaConflicts() { return nil, fmt.Errorf("Unable to automatically resolve schema conflicts since data changes may " + "not have been fully merged yet. " + diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_rebase.go b/go/libraries/doltcore/sqle/dprocedures/dolt_rebase.go index 543c3d46d25..97e1ee689dc 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_rebase.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_rebase.go @@ -344,7 +344,7 @@ func validateRebaseBranchHasntChanged(ctx *sql.Context, branch string, rebaseSta doltSession := dsess.DSessFromSess(ctx.Session) doltDb, ok := doltSession.GetDoltDB(ctx, ctx.GetCurrentDatabase()) if !ok { - return fmt.Errorf("unable to access DoltDB for database %s", ctx.GetCurrentDatabase()) + return fmt.Errorf("unable to access doltDB for database %s", ctx.GetCurrentDatabase()) } wsRef, err := ref.WorkingSetRefForHead(ref.NewBranchRef(branch)) diff --git a/go/libraries/doltcore/sqle/dsess/session.go b/go/libraries/doltcore/sqle/dsess/session.go index cce58943e78..8a4f11d9d4d 100644 --- a/go/libraries/doltcore/sqle/dsess/session.go +++ b/go/libraries/doltcore/sqle/dsess/session.go @@ -866,7 +866,7 @@ func (d *DoltSession) ReleaseSavepoint(ctx *sql.Context, tx sql.Transaction, sav return nil } -// GetDoltDB returns the *DoltDB for a given database by name +// GetDoltDB returns the *doltDB for a given database by name func (d *DoltSession) GetDoltDB(ctx *sql.Context, dbName string) (*doltdb.DoltDB, bool) { branchState, ok, err := d.lookupDbState(ctx, dbName) if err != nil { diff --git a/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go b/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go index 5e151406ba3..5cb4e5cce4f 100644 --- a/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go +++ b/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go @@ -30,7 +30,7 @@ import ( func TestInsertIntoQueryCatalogTable(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) @@ -58,7 +58,7 @@ func TestInsertIntoQueryCatalogTable(t *testing.T) { err = dEnv.UpdateWorkingRoot(ctx, root) require.NoError(t, err) - rows, err := sqle.ExecuteSelect(dEnv, root, "select display_order, query, name, description from "+doltdb.DoltQueryCatalogTableName) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, "select display_order, query, name, description from "+doltdb.DoltQueryCatalogTableName) require.NoError(t, err) expectedRows := []sql.Row{ {uint64(1), "select 1 from dual", "name", "description"}, @@ -81,7 +81,7 @@ func TestInsertIntoQueryCatalogTable(t *testing.T) { err = dEnv.UpdateWorkingRoot(ctx, root) require.NoError(t, err) - rows, err = sqle.ExecuteSelect(dEnv, root, "select display_order, query, name, description from "+doltdb.DoltQueryCatalogTableName+" order by display_order") + rows, err = sqle.ExecuteSelect(ctx, dEnv, root, "select display_order, query, name, description from "+doltdb.DoltQueryCatalogTableName+" order by display_order") require.NoError(t, err) expectedRows = []sql.Row{ {uint64(1), "select 1 from dual", "name", "description"}, @@ -90,7 +90,7 @@ func TestInsertIntoQueryCatalogTable(t *testing.T) { assert.Equal(t, expectedRows, rows) - rows, err = sqle.ExecuteSelect(dEnv, root, "select id from "+doltdb.DoltQueryCatalogTableName) + rows, err = sqle.ExecuteSelect(ctx, dEnv, root, "select id from "+doltdb.DoltQueryCatalogTableName) require.NoError(t, err) for _, r := range rows { assert.NotEmpty(t, r) diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go index 20043743b26..c37ebffa190 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go @@ -1610,7 +1610,7 @@ func TestPersist(t *testing.T) { harness := newDoltHarness(t) defer harness.Close() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() localConf, ok := dEnv.Config.GetConfig(env.LocalConfig) require.True(t, ok) globals := config.NewPrefixConfig(localConf, env.SqlServerGlobalsPrefix) diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go index be5b92cb257..c52ace36488 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go @@ -519,9 +519,9 @@ func (d *DoltHarness) newProvider() sql.MutableDatabaseProvider { } else { dEnv = dtestutils.CreateTestEnv() } - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - store := dEnv.DoltDB.ValueReadWriter().(*types.ValueStore) + store := dEnv.DoltDB(ctx).ValueReadWriter().(*types.ValueStore) store.SetValidateContentAddresses(true) mrEnv, err := env.MultiEnvForDirectory(context.Background(), dEnv.Config.WriteableConfig(), dEnv.FS, dEnv.Version, dEnv) diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go b/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go index d3b9d216661..e4e8f15bf95 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go @@ -52,7 +52,7 @@ func TestDoltServerRunningUnixSocket(t *testing.T) { // Running unix socket server dEnv, sc, serverConfig := startServer(t, false, "", defaultUnixSocketPath) sc.WaitForStart() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() require.True(t, strings.Contains(servercfg.ConnectionString(serverConfig, "dolt"), "unix")) // default unix socket connection works @@ -100,7 +100,7 @@ func TestDoltServerRunningUnixSocket(t *testing.T) { // Running TCP socket server dEnv, tcpSc, tcpServerConfig := startServer(t, true, "0.0.0.0", "") tcpSc.WaitForStart() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() require.False(t, strings.Contains(servercfg.ConnectionString(tcpServerConfig, "dolt"), "unix")) t.Run("host and port specified, there should not be unix socket created", func(t *testing.T) { diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go b/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go index fffa257cdf2..674f30cd009 100755 --- a/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go @@ -482,7 +482,7 @@ func testSerialSessionScriptTests(t *testing.T, tests []queries.ScriptTest) { rand.Seed(time.Now().UnixNano()) port := 15403 + rand.Intn(25) serverConfig = serverConfig.WithPort(port) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, test := range tests { t.Run(test.Name, func(t *testing.T) { @@ -629,7 +629,7 @@ func testMultiSessionScriptTests(t *testing.T, tests []queries.ScriptTest) { dEnv, sc, serverConfig := startServer(t, true, "", "") err := sc.WaitForStart() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() conn1, sess1 := newConnection(t, serverConfig) conn2, sess2 := newConnection(t, serverConfig) diff --git a/go/libraries/doltcore/sqle/index/dolt_index_test.go b/go/libraries/doltcore/sqle/index/dolt_index_test.go index 044bf946fba..31b5ad872af 100644 --- a/go/libraries/doltcore/sqle/index/dolt_index_test.go +++ b/go/libraries/doltcore/sqle/index/dolt_index_test.go @@ -1343,7 +1343,7 @@ func doltIndexSetup(t *testing.T) (doltdb.RootValue, map[string]index.DoltIndex) if err != nil { panic(err) } - root, err = sqle.ExecuteSql(dEnv, root, ` + root, err = sqle.ExecuteSql(ctx, dEnv, root, ` CREATE TABLE onepk ( pk1 BIGINT PRIMARY KEY, v1 BIGINT, diff --git a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go index 3fa94256683..e9ad42678c2 100644 --- a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go +++ b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go @@ -180,7 +180,7 @@ func getDbState(t *testing.T, db sql.Database, dEnv *env.DoltEnv) (dsess.Initial if err != nil { return dsess.InitialDbState{}, err } - optCmt, err := dEnv.DoltDB.Resolve(ctx, headSpec, headRef) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, headSpec, headRef) require.NoError(t, err) headCommit, ok := optCmt.ToCommit() diff --git a/go/libraries/doltcore/sqle/integration_test/database_revision_test.go b/go/libraries/doltcore/sqle/integration_test/database_revision_test.go index 83e1ed0664d..be02bfdf27a 100644 --- a/go/libraries/doltcore/sqle/integration_test/database_revision_test.go +++ b/go/libraries/doltcore/sqle/integration_test/database_revision_test.go @@ -150,7 +150,7 @@ func TestDbRevision(t *testing.T) { t.Run(test.name, func(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() cliCtx, _ := cmd.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) @@ -188,7 +188,7 @@ func TestDbRevision(t *testing.T) { func populateCommitHashes(t *testing.T, dEnv *env.DoltEnv, root doltdb.RootValue) (cm1, cm2, cm3 hash.Hash) { q := "SELECT commit_hash FROM dolt_log;" - rows, err := sqle.ExecuteSelect(dEnv, root, q) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) require.NoError(t, err) assert.Len(t, rows, 4) cm3 = hash.Parse(rows[0][0].(string)) @@ -198,7 +198,7 @@ func populateCommitHashes(t *testing.T, dEnv *env.DoltEnv, root doltdb.RootValue } func makeTestAssertion(t *testing.T, a testAssert, dEnv *env.DoltEnv, root doltdb.RootValue) { - actRows, err := sqle.ExecuteSelect(dEnv, root, a.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, a.query) require.NoError(t, err) assert.Equal(t, a.rows, actRows) } diff --git a/go/libraries/doltcore/sqle/integration_test/history_table_test.go b/go/libraries/doltcore/sqle/integration_test/history_table_test.go index ec40abf4bbd..08ca7160024 100644 --- a/go/libraries/doltcore/sqle/integration_test/history_table_test.go +++ b/go/libraries/doltcore/sqle/integration_test/history_table_test.go @@ -33,7 +33,7 @@ import ( func TestHistoryTable(t *testing.T) { SkipByDefaultInCI(t) dEnv := setupHistoryTests(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, test := range historyTableTests() { t.Run(test.name, func(t *testing.T) { testHistoryTable(t, test, dEnv) @@ -225,7 +225,7 @@ func setupHistoryTests(t *testing.T) *env.DoltEnv { // get commit hashes from the log table q := "select commit_hash, date from dolt_log order by date desc;" - rows, err := sqle.ExecuteSelect(dEnv, root, q) + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) require.NoError(t, err) require.Equal(t, 5, len(rows)) HEAD = rows[0][0].(string) @@ -250,7 +250,7 @@ func testHistoryTable(t *testing.T, test historyTableTest, dEnv *env.DoltEnv) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - actRows, err := sqle.ExecuteSelect(dEnv, root, test.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, test.query) require.NoError(t, err) require.ElementsMatch(t, test.rows, actRows) diff --git a/go/libraries/doltcore/sqle/integration_test/json_value_test.go b/go/libraries/doltcore/sqle/integration_test/json_value_test.go index 4999d3cf2f8..c40552f6c76 100644 --- a/go/libraries/doltcore/sqle/integration_test/json_value_test.go +++ b/go/libraries/doltcore/sqle/integration_test/json_value_test.go @@ -139,7 +139,7 @@ func testJsonValue(t *testing.T, test jsonValueTest, setupCommon []testCommand) root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - actRows, err := sqle.ExecuteSelect(dEnv, root, test.query) + actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, test.query) require.NoError(t, err) require.Equal(t, len(test.rows), len(actRows)) diff --git a/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go b/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go index 9277d810983..0f7574d4460 100644 --- a/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go +++ b/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go @@ -20128,12 +20128,12 @@ INSERT INTO join_result VALUES ('stock','ZYNE','us','2017-11-01',9.7,9.93,9.41,9 func TestCreateTables(t *testing.T) { SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error - root, err = sqle.ExecuteSql(dEnv, root, createTables) + root, err = sqle.ExecuteSql(ctx, dEnv, root, createTables) require.NoError(t, err) table, _, err := root.GetTable(ctx, doltdb.TableName{Name: "daily_summary"}) @@ -20151,15 +20151,15 @@ func TestInserts(t *testing.T) { } SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error - root, err = sqle.ExecuteSql(dEnv, root, createTables) + root, err = sqle.ExecuteSql(ctx, dEnv, root, createTables) require.NoError(t, err) - root, err = sqle.ExecuteSql(dEnv, root, insertRows) + root, err = sqle.ExecuteSql(ctx, dEnv, root, insertRows) require.NoError(t, err) table, _, err := root.GetTable(ctx, doltdb.TableName{Name: "daily_summary"}) @@ -20181,18 +20181,18 @@ func TestInsertsWithIndexes(t *testing.T) { } SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error - root, err = sqle.ExecuteSql(dEnv, root, createTables) + root, err = sqle.ExecuteSql(ctx, dEnv, root, createTables) require.NoError(t, err) - root, err = sqle.ExecuteSql(dEnv, root, createIndexes) + root, err = sqle.ExecuteSql(ctx, dEnv, root, createIndexes) require.NoError(t, err) - root, err = sqle.ExecuteSql(dEnv, root, insertRows) + root, err = sqle.ExecuteSql(ctx, dEnv, root, insertRows) require.NoError(t, err) table, _, err := root.GetTable(ctx, doltdb.TableName{Name: "daily_summary"}) @@ -20217,23 +20217,23 @@ func TestInsertsWithIndexes(t *testing.T) { func TestJoin(t *testing.T) { SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error - root, err = sqle.ExecuteSql(dEnv, root, createTables) + root, err = sqle.ExecuteSql(ctx, dEnv, root, createTables) require.NoError(t, err) - root, err = sqle.ExecuteSql(dEnv, root, insertRows) + root, err = sqle.ExecuteSql(ctx, dEnv, root, insertRows) require.NoError(t, err) - rows, err := sqle.ExecuteSelect(dEnv, root, `select Type, d.Symbol, Country, TradingDate, Open, High, Low, Close, Volume, OpenInt, Name, Sector, IPOYear + rows, err := sqle.ExecuteSelect(ctx, dEnv, root, `select Type, d.Symbol, Country, TradingDate, Open, High, Low, Close, Volume, OpenInt, Name, Sector, IPOYear from daily_summary d join symbols t on d.Symbol = t.Symbol order by d.Symbol, Country, TradingDate`) require.NoError(t, err) assert.Equal(t, 5210, len(rows)) - expectedJoinRows, err := sqle.ExecuteSelect(dEnv, root, `select * from join_result order by symbol, country, TradingDate`) + expectedJoinRows, err := sqle.ExecuteSelect(ctx, dEnv, root, `select * from join_result order by symbol, country, TradingDate`) require.NoError(t, err) assertResultRowsEqual(t, expectedJoinRows, rows) } diff --git a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go index b8df98bc771..0d4a50adcb7 100644 --- a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go +++ b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go @@ -92,7 +92,7 @@ func TestCountAgg(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) diff --git a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go index 75878b25076..56c9cc634ce 100644 --- a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go +++ b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go @@ -150,7 +150,7 @@ func TestLookupJoin(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) diff --git a/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go b/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go index dbf125c803b..857a0165f3b 100644 --- a/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go +++ b/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go @@ -100,7 +100,7 @@ func TestDoltHarness(t *testing.T) { fs := filesys.NewInMemFS([]string{}, nil, tmp) dEnv := createTestEnvWithFS(fs, wd) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() // We run this several times in a row to make sure that the same dolt env can be used in multiple setup / teardown // cycles diff --git a/go/libraries/doltcore/sqle/replication.go b/go/libraries/doltcore/sqle/replication.go index 6c9bb3d6a5a..8cab390c5de 100644 --- a/go/libraries/doltcore/sqle/replication.go +++ b/go/libraries/doltcore/sqle/replication.go @@ -127,7 +127,7 @@ func ApplyReplicationConfig(ctx context.Context, bThreads *sql.BackgroundThreads if err != nil { return nil, err } - dEnv.DoltDB.SetCommitHooks(ctx, postCommitHooks) + dEnv.DoltDB(ctx).SetCommitHooks(ctx, postCommitHooks) if _, remote, ok := sql.SystemVariables.GetGlobal(dsess.ReadReplicaRemote); ok && remote != "" { remoteName, ok := remote.(string) diff --git a/go/libraries/doltcore/sqle/replication_test.go b/go/libraries/doltcore/sqle/replication_test.go index f2922de2147..600361ff451 100644 --- a/go/libraries/doltcore/sqle/replication_test.go +++ b/go/libraries/doltcore/sqle/replication_test.go @@ -31,7 +31,7 @@ import ( func TestCommitHooksNoErrors(t *testing.T) { dEnv, err := CreateEnvWithSeedData() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() sql.SystemVariables.SetGlobal(dsess.SkipReplicationErrors, true) sql.SystemVariables.SetGlobal(dsess.ReplicateToRemote, "unknown") diff --git a/go/libraries/doltcore/sqle/sqlddl_test.go b/go/libraries/doltcore/sqle/sqlddl_test.go index b7682237177..7f68cec6c60 100644 --- a/go/libraries/doltcore/sqle/sqlddl_test.go +++ b/go/libraries/doltcore/sqle/sqlddl_test.go @@ -265,12 +265,12 @@ func TestCreateTable(t *testing.T) { ctx := context.Background() dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - updatedRoot, err := ExecuteSql(dEnv, root, tt.query) + updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) if tt.expectedErr == "" { require.NoError(t, err) } else { @@ -341,12 +341,12 @@ func TestDropTable(t *testing.T) { ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - updatedRoot, err := ExecuteSql(dEnv, root, tt.query) + updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) if tt.expectedErr == "" { require.NoError(t, err) @@ -516,13 +516,13 @@ func TestAddColumn(t *testing.T) { t.Run(tt.name, func(t *testing.T) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - updatedRoot, err := ExecuteSql(dEnv, root, tt.query) + updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) if tt.expectedErr == "" { require.NoError(t, err) @@ -638,12 +638,12 @@ func TestRenameColumn(t *testing.T) { t.Run(tt.name, func(t *testing.T) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) - updatedRoot, err := ExecuteSql(dEnv, root, tt.query) + updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) if tt.expectedErr == "" { require.NoError(t, err) @@ -754,13 +754,13 @@ func TestRenameTableStatements(t *testing.T) { t.Run(tt.name, func(t *testing.T) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - updatedRoot, err := ExecuteSql(dEnv, root, tt.query) + updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) if len(tt.expectedErr) > 0 { require.Error(t, err) assert.Contains(t, err.Error(), tt.expectedErr) @@ -827,7 +827,7 @@ func TestAlterSystemTables(t *testing.T) { t.Run("Create", func(t *testing.T) { setup() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tableName := range append(systemTableNames, reservedTableNames...) { assertFails(t, dEnv, fmt.Sprintf("create table %s (a int primary key not null)", tableName), "reserved") } @@ -835,7 +835,7 @@ func TestAlterSystemTables(t *testing.T) { t.Run("Drop", func(t *testing.T) { setup() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tableName := range systemTableNames { expectedErr := "system table" if strings.HasPrefix(tableName, "dolt_diff") || strings.HasPrefix(tableName, "dolt_history") { @@ -850,7 +850,7 @@ func TestAlterSystemTables(t *testing.T) { t.Run("Rename", func(t *testing.T) { setup() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tableName := range systemTableNames { expectedErr := "system table" if strings.HasPrefix(tableName, "dolt_diff") || strings.HasPrefix(tableName, "dolt_history") { @@ -865,7 +865,7 @@ func TestAlterSystemTables(t *testing.T) { t.Run("Alter", func(t *testing.T) { setup() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() for _, tableName := range append(systemTableNames, reservedTableNames...) { expectedErr := "cannot be altered" if strings.HasPrefix(tableName, "dolt_diff") || strings.HasPrefix(tableName, "dolt_history") { @@ -1075,7 +1075,7 @@ func TestParseCreateTableStatement(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) //eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, dEnv) @@ -1129,12 +1129,12 @@ func newTestEngine(ctx context.Context, dEnv *env.DoltEnv) (*gms.Engine, *sql.Co func TestIndexOverwrite(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) if err != nil { panic(err) } - root, err = ExecuteSql(dEnv, root, ` + root, err = ExecuteSql(ctx, dEnv, root, ` CREATE TABLE parent ( pk bigint PRIMARY KEY, v1 bigint, @@ -1173,13 +1173,13 @@ INSERT INTO child_non_unq VALUES ('1', 1), ('2', NULL), ('3', 3), ('4', 3), ('5' `) // test index creation require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "CREATE INDEX abc ON child (parent_value);") + root, err = ExecuteSql(ctx, dEnv, root, "CREATE INDEX abc ON child (parent_value);") require.NoError(t, err) - _, err = ExecuteSql(dEnv, root, "CREATE INDEX abc_idx ON child_idx (parent_value);") + _, err = ExecuteSql(ctx, dEnv, root, "CREATE INDEX abc_idx ON child_idx (parent_value);") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "CREATE UNIQUE INDEX abc_unq ON child_unq (parent_value);") + root, err = ExecuteSql(ctx, dEnv, root, "CREATE UNIQUE INDEX abc_unq ON child_unq (parent_value);") require.NoError(t, err) - _, err = ExecuteSql(dEnv, root, "CREATE UNIQUE INDEX abc_non_unq ON child_non_unq (parent_value);") + _, err = ExecuteSql(ctx, dEnv, root, "CREATE UNIQUE INDEX abc_non_unq ON child_non_unq (parent_value);") if assert.Error(t, err) { assert.Contains(t, err.Error(), "duplicate unique key given") } @@ -1201,31 +1201,31 @@ INSERT INTO child_non_unq VALUES ('1', 1), ('2', NULL), ('3', 3), ('4', 3), ('5' require.Equal(t, "fk_child_non_unq", fkChildNonUnq.TableIndex) // insert tests against index - root, err = ExecuteSql(dEnv, root, "INSERT INTO child VALUES ('6', 5)") + root, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child VALUES ('6', 5)") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "INSERT INTO child_idx VALUES ('6', 5)") + root, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_idx VALUES ('6', 5)") require.NoError(t, err) - _, err = ExecuteSql(dEnv, root, "INSERT INTO child_unq VALUES ('6', 5)") + _, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_unq VALUES ('6', 5)") if assert.Error(t, err) { assert.True(t, sql.ErrUniqueKeyViolation.Is(err.(sql.WrappedInsertError).Cause)) } - root, err = ExecuteSql(dEnv, root, "INSERT INTO child_non_unq VALUES ('6', 5)") + root, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_non_unq VALUES ('6', 5)") require.NoError(t, err) // insert tests against foreign key - _, err = ExecuteSql(dEnv, root, "INSERT INTO child VALUES ('9', 9)") + _, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child VALUES ('9', 9)") if assert.Error(t, err) { assert.Contains(t, err.Error(), "Foreign key violation") } - _, err = ExecuteSql(dEnv, root, "INSERT INTO child_idx VALUES ('9', 9)") + _, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_idx VALUES ('9', 9)") if assert.Error(t, err) { assert.Contains(t, err.Error(), "Foreign key violation") } - _, err = ExecuteSql(dEnv, root, "INSERT INTO child_unq VALUES ('9', 9)") + _, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_unq VALUES ('9', 9)") if assert.Error(t, err) { assert.Contains(t, err.Error(), "Foreign key violation") } - _, err = ExecuteSql(dEnv, root, "INSERT INTO child_non_unq VALUES ('9', 9)") + _, err = ExecuteSql(ctx, dEnv, root, "INSERT INTO child_non_unq VALUES ('9', 9)") if assert.Error(t, err) { assert.Contains(t, err.Error(), "Foreign key violation") } @@ -1234,7 +1234,7 @@ INSERT INTO child_non_unq VALUES ('1', 1), ('2', NULL), ('3', 3), ('4', 3), ('5' func TestDropPrimaryKey(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) if err != nil { panic(err) @@ -1242,9 +1242,9 @@ func TestDropPrimaryKey(t *testing.T) { t.Run("drop primary key", func(t *testing.T) { // setup - root, err = ExecuteSql(dEnv, root, "create table parent (i int, j int, k int, index i (i), index ij (i, j), index ijk (i, j, k), index j (j), index kji (k, j, i));") + root, err = ExecuteSql(ctx, dEnv, root, "create table parent (i int, j int, k int, index i (i), index ij (i, j), index ijk (i, j, k), index j (j), index kji (k, j, i));") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "create table child (x int, y int, constraint fk_child foreign key (x, y) references parent (i, j));") + root, err = ExecuteSql(ctx, dEnv, root, "create table child (x int, y int, constraint fk_child foreign key (x, y) references parent (i, j));") require.NoError(t, err) // check foreign keys for updated index @@ -1256,11 +1256,11 @@ func TestDropPrimaryKey(t *testing.T) { require.Equal(t, "ij", fkChild.ReferencedTableIndex) // add primary key - root, err = ExecuteSql(dEnv, root, "alter table parent add primary key (i, j);") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent add primary key (i, j);") require.NoError(t, err) // dropping secondary index ij, should choose ijk - root, err = ExecuteSql(dEnv, root, "alter table parent drop index ij;") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop index ij;") require.NoError(t, err) // check foreign keys for updated index @@ -1272,7 +1272,7 @@ func TestDropPrimaryKey(t *testing.T) { require.Equal(t, "ijk", fkChild.ReferencedTableIndex) // dropping secondary index ijk, should switch to primary key - root, err = ExecuteSql(dEnv, root, "alter table parent drop index ijk;") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop index ijk;") require.NoError(t, err) // check foreign keys for updated index @@ -1284,7 +1284,7 @@ func TestDropPrimaryKey(t *testing.T) { require.Equal(t, "", fkChild.ReferencedTableIndex) // no viable secondary indexes left, should be unable to drop primary key - _, err = ExecuteSql(dEnv, root, "alter table parent drop primary key;") + _, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop primary key;") require.Error(t, err) }) } @@ -1292,22 +1292,22 @@ func TestDropPrimaryKey(t *testing.T) { func TestDropIndex(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) if err != nil { panic(err) } t.Run("drop secondary indexes", func(t *testing.T) { // setup - root, err = ExecuteSql(dEnv, root, "create table parent (i int);") + root, err = ExecuteSql(ctx, dEnv, root, "create table parent (i int);") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "alter table parent add index idx1 (i);") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent add index idx1 (i);") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "alter table parent add index idx2 (i);") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent add index idx2 (i);") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "alter table parent add index idx3 (i);") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent add index idx3 (i);") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "create table child (j int, constraint fk_child foreign key (j) references parent (i));") + root, err = ExecuteSql(ctx, dEnv, root, "create table child (j int, constraint fk_child foreign key (j) references parent (i));") require.NoError(t, err) // drop and check next index @@ -1319,7 +1319,7 @@ func TestDropIndex(t *testing.T) { require.Equal(t, "idx1", fkChild.ReferencedTableIndex) // dropping secondary index, should switch to existing index - root, err = ExecuteSql(dEnv, root, "alter table parent drop index idx1;") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop index idx1;") require.NoError(t, err) fkc, err = root.GetForeignKeyCollection(ctx) require.NoError(t, err) @@ -1329,7 +1329,7 @@ func TestDropIndex(t *testing.T) { require.Equal(t, "idx2", fkChild.ReferencedTableIndex) // dropping secondary index, should switch to existing index - root, err = ExecuteSql(dEnv, root, "alter table parent drop index idx2;") + root, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop index idx2;") require.NoError(t, err) fkc, err = root.GetForeignKeyCollection(ctx) require.NoError(t, err) @@ -1339,19 +1339,19 @@ func TestDropIndex(t *testing.T) { require.Equal(t, "idx3", fkChild.ReferencedTableIndex) // dropping secondary index, should fail since there are no indexes to replace it - _, err = ExecuteSql(dEnv, root, "alter table parent drop index idx3;") + _, err = ExecuteSql(ctx, dEnv, root, "alter table parent drop index idx3;") require.Error(t, err) }) } func TestCreateIndexUnique(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(context.Background()) if err != nil { panic(err) } - root, err = ExecuteSql(dEnv, root, ` + root, err = ExecuteSql(ctx, dEnv, root, ` CREATE TABLE pass_unique ( pk1 BIGINT PRIMARY KEY, v1 BIGINT, @@ -1366,9 +1366,9 @@ INSERT INTO pass_unique VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3); INSERT INTO fail_unique VALUES (1, 1, 1), (2, 2, 2), (3, 2, 3); `) require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "CREATE UNIQUE INDEX idx_v1 ON pass_unique(v1)") + root, err = ExecuteSql(ctx, dEnv, root, "CREATE UNIQUE INDEX idx_v1 ON pass_unique(v1)") assert.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "CREATE UNIQUE INDEX idx_v1 ON fail_unique(v1)") + root, err = ExecuteSql(ctx, dEnv, root, "CREATE UNIQUE INDEX idx_v1 ON fail_unique(v1)") if assert.Error(t, err) { assert.Contains(t, strings.ToLower(err.Error()), "unique") } @@ -1377,7 +1377,7 @@ INSERT INTO fail_unique VALUES (1, 1, 1), (2, 2, 2), (3, 2, 3); func assertFails(t *testing.T, dEnv *env.DoltEnv, query, expectedErr string) { ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) - _, err := ExecuteSql(dEnv, root, query) + _, err := ExecuteSql(ctx, dEnv, root, query) require.Error(t, err, query) assert.Contains(t, err.Error(), expectedErr) } @@ -1385,6 +1385,6 @@ func assertFails(t *testing.T, dEnv *env.DoltEnv, query, expectedErr string) { func assertSucceeds(t *testing.T, dEnv *env.DoltEnv, query string) { ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) - _, err := ExecuteSql(dEnv, root, query) + _, err := ExecuteSql(ctx, dEnv, root, query) assert.NoError(t, err, query) } diff --git a/go/libraries/doltcore/sqle/sqldelete_test.go b/go/libraries/doltcore/sqle/sqldelete_test.go index b5e62b04359..715cedcd7fe 100644 --- a/go/libraries/doltcore/sqle/sqldelete_test.go +++ b/go/libraries/doltcore/sqle/sqldelete_test.go @@ -227,7 +227,7 @@ func testDeleteQuery(t *testing.T, test DeleteTest) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) diff --git a/go/libraries/doltcore/sqle/sqlinsert_test.go b/go/libraries/doltcore/sqle/sqlinsert_test.go index e734516bfc8..d9733b5cc8e 100644 --- a/go/libraries/doltcore/sqle/sqlinsert_test.go +++ b/go/libraries/doltcore/sqle/sqlinsert_test.go @@ -428,7 +428,7 @@ func testInsertQuery(t *testing.T, test InsertTest) { dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) diff --git a/go/libraries/doltcore/sqle/sqlpersist_test.go b/go/libraries/doltcore/sqle/sqlpersist_test.go index b0eb9a00c7e..bb153b8b5ef 100644 --- a/go/libraries/doltcore/sqle/sqlpersist_test.go +++ b/go/libraries/doltcore/sqle/sqlpersist_test.go @@ -97,7 +97,7 @@ func TestExecutePersist(t *testing.T) { func testPersistQuery(t *testing.T, test PersistTest) { dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) diff --git a/go/libraries/doltcore/sqle/sqlreplace_test.go b/go/libraries/doltcore/sqle/sqlreplace_test.go index 790abd85ff3..3d30e7cb267 100644 --- a/go/libraries/doltcore/sqle/sqlreplace_test.go +++ b/go/libraries/doltcore/sqle/sqlreplace_test.go @@ -300,7 +300,7 @@ func testReplaceQuery(t *testing.T, test ReplaceTest) { dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) diff --git a/go/libraries/doltcore/sqle/sqlselect_test.go b/go/libraries/doltcore/sqle/sqlselect_test.go index 7f8fc08464d..68aef931c5c 100644 --- a/go/libraries/doltcore/sqle/sqlselect_test.go +++ b/go/libraries/doltcore/sqle/sqlselect_test.go @@ -1359,7 +1359,7 @@ func testSelectQuery(t *testing.T, test SelectTest) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) @@ -1453,7 +1453,7 @@ func mustRowData(t *testing.T, ctx context.Context, vrw types.ValueReadWriter, s } func CreateHistory(ctx context.Context, dEnv *env.DoltEnv, t *testing.T) []HistoryNode { - vrw := dEnv.DoltDB.ValueReadWriter() + vrw := dEnv.DoltDB(ctx).ValueReadWriter() return []HistoryNode{ { @@ -1560,7 +1560,7 @@ func testSelectDiffQuery(t *testing.T, test SelectTest) { cs, err := doltdb.NewCommitSpec("main") require.NoError(t, err) - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, nil) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, nil) require.NoError(t, err) cm, ok := optCmt.ToCommit() @@ -1676,7 +1676,7 @@ func initializeWithHistory(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, cs, err := doltdb.NewCommitSpec(env.DefaultInitBranch) require.NoError(t, err) - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, nil) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, nil) require.NoError(t, err) cm, ok := optCmt.ToCommit() @@ -1688,18 +1688,18 @@ func initializeWithHistory(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, func processNode(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, node HistoryNode, parent *doltdb.Commit) { branchRef := ref.NewBranchRef(node.Branch) - ok, err := dEnv.DoltDB.HasRef(ctx, branchRef) + ok, err := dEnv.DoltDB(ctx).HasRef(ctx, branchRef) require.NoError(t, err) if !ok { - err = dEnv.DoltDB.NewBranchAtCommit(ctx, branchRef, parent, nil) + err = dEnv.DoltDB(ctx).NewBranchAtCommit(ctx, branchRef, parent, nil) require.NoError(t, err) } cs, err := doltdb.NewCommitSpec(branchRef.String()) require.NoError(t, err) - optCmt, err := dEnv.DoltDB.Resolve(ctx, cs, nil) + optCmt, err := dEnv.DoltDB(ctx).Resolve(ctx, cs, nil) require.NoError(t, err) cm, ok := optCmt.ToCommit() @@ -1709,14 +1709,14 @@ func processNode(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, node Hist require.NoError(t, err) root = updateTables(t, ctx, root, node.Updates) - r, h, err := dEnv.DoltDB.WriteRootValue(ctx, root) + r, h, err := dEnv.DoltDB(ctx).WriteRootValue(ctx, root) require.NoError(t, err) root = r meta, err := datas.NewCommitMeta("Ash Ketchum", "ash@poke.mon", node.CommitMsg) require.NoError(t, err) - cm, err = dEnv.DoltDB.Commit(ctx, h, branchRef, meta) + cm, err = dEnv.DoltDB(ctx).Commit(ctx, h, branchRef, meta) require.NoError(t, err) for _, child := range node.Children { diff --git a/go/libraries/doltcore/sqle/sqlupdate_test.go b/go/libraries/doltcore/sqle/sqlupdate_test.go index 2ca58d78858..ec616da866a 100644 --- a/go/libraries/doltcore/sqle/sqlupdate_test.go +++ b/go/libraries/doltcore/sqle/sqlupdate_test.go @@ -391,7 +391,7 @@ func testUpdateQuery(t *testing.T, test UpdateTest) { dEnv, err := CreateTestDatabase() require.NoError(t, err) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() if test.AdditionalSetup != nil { test.AdditionalSetup(t, dEnv) diff --git a/go/libraries/doltcore/sqle/statsnoms/database.go b/go/libraries/doltcore/sqle/statsnoms/database.go index e7fee45b158..cc47001239d 100644 --- a/go/libraries/doltcore/sqle/statsnoms/database.go +++ b/go/libraries/doltcore/sqle/statsnoms/database.go @@ -87,14 +87,7 @@ func (sf NomsStatsFactory) Init(ctx *sql.Context, sourceDb dsess.SqlDatabase, pr dEnv = env.LoadWithoutDB(ctx, hdp, statsFs, "") } - if dEnv.DoltDB == nil { - ddb, err := doltdb.LoadDoltDBWithParams(ctx, types.Format_Default, urlPath, statsFs, params) - if err != nil { - return nil, err - } - - dEnv.DoltDB = ddb - } + dEnv.LoadDoltDBWithParams(ctx, types.Format_Default, urlPath, statsFs, params) deaf := dEnv.DbEaFactory() diff --git a/go/libraries/doltcore/sqle/table_editor_fk_test.go b/go/libraries/doltcore/sqle/table_editor_fk_test.go index a468aba4cba..e36a6ae6397 100644 --- a/go/libraries/doltcore/sqle/table_editor_fk_test.go +++ b/go/libraries/doltcore/sqle/table_editor_fk_test.go @@ -38,7 +38,7 @@ func setupEditorFkTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { if err != nil { panic(err) } - initialRoot, err := ExecuteSql(dEnv, root, ` + initialRoot, err := ExecuteSql(ctx, dEnv, root, ` CREATE TABLE one ( pk BIGINT PRIMARY KEY, v1 BIGINT, @@ -153,9 +153,9 @@ func TestTableEditorForeignKeyCascade(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - testRoot, err := ExecuteSql(dEnv, initialRoot, ` + testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` ALTER TABLE two ADD FOREIGN KEY (v1) REFERENCES one(v1) ON DELETE CASCADE ON UPDATE CASCADE; ALTER TABLE three ADD FOREIGN KEY (v1, v2) REFERENCES two(v1, v2) ON DELETE CASCADE ON UPDATE CASCADE; `) @@ -203,9 +203,9 @@ func TestTableEditorForeignKeySetNull(t *testing.T) { for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - testRoot, err := ExecuteSql(dEnv, initialRoot, ` + testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` ALTER TABLE two ADD FOREIGN KEY (v1) REFERENCES one(v1) ON DELETE SET NULL ON UPDATE SET NULL;`) require.NoError(t, err) @@ -286,9 +286,9 @@ func TestTableEditorForeignKeyRestrict(t *testing.T) { for _, test := range tests { t.Run(test.setup+test.trigger, func(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - testRoot, err := ExecuteSql(dEnv, initialRoot, fmt.Sprintf(` + testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, fmt.Sprintf(` ALTER TABLE two ADD FOREIGN KEY (v1) REFERENCES one(v1) %s; INSERT INTO one VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3); INSERT INTO two VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3);`, referenceOption)) @@ -358,9 +358,9 @@ func TestTableEditorForeignKeyViolations(t *testing.T) { for _, test := range tests { t.Run(test.setup+test.trigger, func(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - testRoot, err := ExecuteSql(dEnv, initialRoot, ` + testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` ALTER TABLE two ADD FOREIGN KEY (v1) REFERENCES one(v1) ON DELETE CASCADE ON UPDATE CASCADE; ALTER TABLE three ADD FOREIGN KEY (v1, v2) REFERENCES two(v1, v2) ON DELETE CASCADE ON UPDATE CASCADE; `) @@ -380,7 +380,7 @@ ALTER TABLE three ADD FOREIGN KEY (v1, v2) REFERENCES two(v1, v2) ON DELETE CASC func TestTableEditorSelfReferentialForeignKeyRestrict(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root := initialRoot @@ -451,7 +451,7 @@ func TestTableEditorSelfReferentialForeignKeyRestrict(t *testing.T) { func TestTableEditorSelfReferentialForeignKeyCascade(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root := initialRoot @@ -552,7 +552,7 @@ func TestTableEditorSelfReferentialForeignKeyCascade(t *testing.T) { func TestTableEditorSelfReferentialForeignKeySetNull(t *testing.T) { dEnv, initialRoot := setupEditorFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root := initialRoot @@ -747,7 +747,7 @@ func setupEditorKeylessFkTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { if err != nil { panic(err) } - initialRoot, err := ExecuteSql(dEnv, root, ` + initialRoot, err := ExecuteSql(ctx, dEnv, root, ` CREATE TABLE one ( pk BIGINT, v1 BIGINT, @@ -864,9 +864,9 @@ func TestTableEditorKeylessFKCascade(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { dEnv, initialRoot := setupEditorKeylessFkTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() - testRoot, err := ExecuteSql(dEnv, initialRoot, ` + testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` ALTER TABLE two ADD FOREIGN KEY (v1) REFERENCES one(v1) ON DELETE CASCADE ON UPDATE CASCADE; ALTER TABLE three ADD FOREIGN KEY (v1, v2) REFERENCES two(v1, v2) ON DELETE CASCADE ON UPDATE CASCADE; `) diff --git a/go/libraries/doltcore/sqle/table_editor_index_test.go b/go/libraries/doltcore/sqle/table_editor_index_test.go index 46b31e32175..ac06c91fa5e 100644 --- a/go/libraries/doltcore/sqle/table_editor_index_test.go +++ b/go/libraries/doltcore/sqle/table_editor_index_test.go @@ -36,7 +36,7 @@ func setupEditorIndexTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { root, err := index_dEnv.WorkingRoot(context.Background()) require.NoError(t, err) - index_initialRoot, err := ExecuteSql(index_dEnv, root, ` + index_initialRoot, err := ExecuteSql(ctx, index_dEnv, root, ` CREATE TABLE onepk ( pk1 BIGINT PRIMARY KEY, v1 BIGINT, @@ -120,7 +120,7 @@ UPDATE onepk SET pk1 = v1 + pk1 ORDER BY pk1 DESC; for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { dEnv, initialRoot := setupEditorIndexTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root := initialRoot for _, sqlStatement := range strings.Split(test.sqlStatement, ";") { @@ -283,7 +283,7 @@ UPDATE oneuni SET v1 = v1 + pk1; for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { dEnv, initialRoot := setupEditorIndexTest(t) - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root := initialRoot var err error diff --git a/go/libraries/doltcore/sqle/temp_table.go b/go/libraries/doltcore/sqle/temp_table.go index 6a07a804d02..44f5aff804b 100644 --- a/go/libraries/doltcore/sqle/temp_table.go +++ b/go/libraries/doltcore/sqle/temp_table.go @@ -96,7 +96,8 @@ func NewTempTable( } // NOTE: We don't support setting a schema name to qualify the table name here, so this code will not work - // correctly with Doltgres yet. + // + // correctly with Doltgres yet. tags, err := doltdb.GenerateTagsForNewColumns(ctx, ws.WorkingRoot(), doltdb.TableName{Name: name}, colNames, colKinds, ws.WorkingRoot()) if err != nil { return nil, err diff --git a/go/libraries/doltcore/sqle/testutil.go b/go/libraries/doltcore/sqle/testutil.go index 9af4a26bcba..a7567370465 100644 --- a/go/libraries/doltcore/sqle/testutil.go +++ b/go/libraries/doltcore/sqle/testutil.go @@ -44,7 +44,7 @@ import ( // ExecuteSql executes all the SQL non-select statements given in the string against the root value given and returns // the updated root, or an error. Statements in the input string are split by `;\n` -func ExecuteSql(dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (doltdb.RootValue, error) { +func ExecuteSql(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (doltdb.RootValue, error) { tmpDir, err := dEnv.TempTableFilesDir() if err != nil { return nil, err @@ -56,12 +56,12 @@ func ExecuteSql(dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (do return nil, err } - engine, ctx, err := NewTestEngine(dEnv, context.Background(), db) + engine, sqlCtx, err := NewTestEngine(dEnv, context.Background(), db) if err != nil { return nil, err } - err = ctx.Session.SetSessionVariable(ctx, sql.AutoCommitSessionVar, false) + err = sqlCtx.Session.SetSessionVariable(sqlCtx, sql.AutoCommitSessionVar, false) if err != nil { return nil, err } @@ -84,15 +84,15 @@ func ExecuteSql(dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (do return nil, errors.New("Select statements aren't handled") case *sqlparser.Insert: var rowIter sql.RowIter - _, rowIter, _, execErr = engine.Query(ctx, query) + _, rowIter, _, execErr = engine.Query(sqlCtx, query) if execErr == nil { - execErr = drainIter(ctx, rowIter) + execErr = drainIter(sqlCtx, rowIter) } case *sqlparser.DDL, *sqlparser.AlterTable: var rowIter sql.RowIter - _, rowIter, _, execErr = engine.Query(ctx, query) + _, rowIter, _, execErr = engine.Query(sqlCtx, query) if execErr == nil { - execErr = drainIter(ctx, rowIter) + execErr = drainIter(sqlCtx, rowIter) } default: return nil, fmt.Errorf("Unsupported SQL statement: '%v'.", query) @@ -103,12 +103,12 @@ func ExecuteSql(dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (do } } - err = dsess.DSessFromSess(ctx.Session).CommitTransaction(ctx, ctx.GetTransaction()) + err = dsess.DSessFromSess(sqlCtx.Session).CommitTransaction(sqlCtx, sqlCtx.GetTransaction()) if err != nil { return nil, err } - return db.GetRoot(ctx) + return db.GetRoot(sqlCtx) } func NewTestSQLCtxWithProvider(ctx context.Context, pro dsess.DoltDatabaseProvider, statsPro sql.StatsProvider) *sql.Context { @@ -140,9 +140,9 @@ func NewTestEngine(dEnv *env.DoltEnv, ctx context.Context, db dsess.SqlDatabase) } // ExecuteSelect executes the select statement given and returns the resulting rows, or an error if one is encountered. -func ExecuteSelect(dEnv *env.DoltEnv, root doltdb.RootValue, query string) ([]sql.Row, error) { +func ExecuteSelect(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, query string) ([]sql.Row, error) { dbData := env.DbData{ - Ddb: dEnv.DoltDB, + Ddb: dEnv.DoltDB(ctx), Rsw: dEnv.RepoStateWriter(), Rsr: dEnv.RepoStateReader(), } @@ -158,12 +158,12 @@ func ExecuteSelect(dEnv *env.DoltEnv, root doltdb.RootValue, query string) ([]sq return nil, err } - engine, ctx, err := NewTestEngine(dEnv, context.Background(), db) + engine, sqlCtx, err := NewTestEngine(dEnv, context.Background(), db) if err != nil { return nil, err } - _, rowIter, _, err := engine.Query(ctx, query) + _, rowIter, _, err := engine.Query(sqlCtx, query) if err != nil { return nil, err } @@ -173,7 +173,7 @@ func ExecuteSelect(dEnv *env.DoltEnv, root doltdb.RootValue, query string) ([]sq rowErr error row sql.Row ) - for row, rowErr = rowIter.Next(ctx); rowErr == nil; row, rowErr = rowIter.Next(ctx) { + for row, rowErr = rowIter.Next(sqlCtx); rowErr == nil; row, rowErr = rowIter.Next(sqlCtx) { rows = append(rows, row) } @@ -342,7 +342,7 @@ func CreateEnvWithSeedData() (*env.DoltEnv, error) { return nil, err } - root, err = ExecuteSql(dEnv, root, seedData) + root, err = ExecuteSql(ctx, dEnv, root, seedData) if err != nil { return nil, err } @@ -422,8 +422,8 @@ func CreateEmptyTestTable(dEnv *env.DoltEnv, tableName string, sch schema.Schema return err } - vrw := dEnv.DoltDB.ValueReadWriter() - ns := dEnv.DoltDB.NodeStore() + vrw := dEnv.DoltDB(ctx).ValueReadWriter() + ns := dEnv.DoltDB(ctx).NodeStore() rows, err := durable.NewEmptyPrimaryIndex(ctx, vrw, ns, sch) if err != nil { @@ -486,7 +486,7 @@ func CreateTestDatabase() (*env.DoltEnv, error) { return nil, err } - root, err = ExecuteSql(dEnv, root, simpsonsRowData) + root, err = ExecuteSql(ctx, dEnv, root, simpsonsRowData) if err != nil { return nil, err } diff --git a/go/libraries/doltcore/sqle/views_test.go b/go/libraries/doltcore/sqle/views_test.go index 8e82f1229b6..85f22c940fa 100644 --- a/go/libraries/doltcore/sqle/views_test.go +++ b/go/libraries/doltcore/sqle/views_test.go @@ -28,19 +28,19 @@ import ( // Not an exhaustive test of views -- we rely on bats tests for end-to-end verification. func TestViews(t *testing.T) { dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error - root, err = ExecuteSql(dEnv, root, "create table test (a int primary key)") + root, err = ExecuteSql(ctx, dEnv, root, "create table test (a int primary key)") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "insert into test values (1), (2), (3)") + root, err = ExecuteSql(ctx, dEnv, root, "insert into test values (1), (2), (3)") require.NoError(t, err) - root, err = ExecuteSql(dEnv, root, "create view plus1 as select a + 1 from test") + root, err = ExecuteSql(ctx, dEnv, root, "create view plus1 as select a + 1 from test") require.NoError(t, err) expectedRows := []sql.Row{ @@ -52,6 +52,6 @@ func TestViews(t *testing.T) { require.NoError(t, err) assert.Equal(t, expectedRows, rows) - root, err = ExecuteSql(dEnv, root, "drop view plus1") + root, err = ExecuteSql(ctx, dEnv, root, "drop view plus1") require.NoError(t, err) } diff --git a/go/libraries/doltcore/table/untyped/sqlexport/sqlwriter_test.go b/go/libraries/doltcore/table/untyped/sqlexport/sqlwriter_test.go index a1580c15318..bb45dfe2071 100644 --- a/go/libraries/doltcore/table/untyped/sqlexport/sqlwriter_test.go +++ b/go/libraries/doltcore/table/untyped/sqlexport/sqlwriter_test.go @@ -88,7 +88,7 @@ func TestEndToEnd(t *testing.T) { t.Run(tt.name, func(t *testing.T) { ctx := context.Background() dEnv := dtestutils.CreateTestEnv() - defer dEnv.DoltDB.Close() + defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) diff --git a/go/utils/remotesrv/main.go b/go/utils/remotesrv/main.go index 2e5d049d451..1c48412390e 100644 --- a/go/utils/remotesrv/main.go +++ b/go/utils/remotesrv/main.go @@ -78,7 +78,7 @@ func main() { if !dEnv.Valid() { log.Fatalln("repo-mode failed to load repository") } - db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB) + db := doltdb.HackDatasDatabaseFromDoltDB(dEnv.DoltDB(ctx)) cs := datas.ChunkStoreFromDatabase(db) dbCache = SingletonCSCache{cs.(remotesrv.RemoteSrvStore)} } else { From 8dfadf90eee9c72614c6ce653f2fc4649606a201 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Wed, 22 Jan 2025 21:19:08 -0800 Subject: [PATCH 03/17] Propagate context. --- go/cmd/dolt/commands/ci/init.go | 6 +++--- go/cmd/dolt/commands/dump.go | 2 +- go/cmd/dolt/commands/engine/utils.go | 6 +++--- go/cmd/dolt/commands/filter-branch.go | 4 ++-- go/cmd/dolt/commands/indexcmds/rebuild.go | 2 +- go/cmd/dolt/commands/schcmds/export.go | 2 +- go/cmd/dolt/commands/schcmds/show.go | 2 +- go/cmd/dolt/commands/sqlserver/server.go | 2 +- go/cmd/dolt/commands/stashcmds/pop.go | 2 +- go/cmd/dolt/commands/tblcmds/export.go | 2 +- go/cmd/dolt/dolt.go | 4 ++-- go/libraries/doltcore/dtestutils/testcommands/multienv.go | 4 ++-- go/libraries/doltcore/env/actions/clone.go | 2 +- go/libraries/doltcore/env/environment.go | 8 ++++---- go/libraries/doltcore/env/memory.go | 6 +++--- go/libraries/doltcore/env/multi_repo_env.go | 4 ++-- go/libraries/doltcore/mvdata/data_loc_test.go | 2 +- go/libraries/doltcore/rebase/filter_branch.go | 6 +++--- go/libraries/doltcore/sqle/alterschema_test.go | 4 ++-- go/libraries/doltcore/sqle/common_test.go | 8 ++++---- go/libraries/doltcore/sqle/database_provider.go | 4 ++-- go/libraries/doltcore/sqle/database_test.go | 4 ++-- go/libraries/doltcore/sqle/dprocedures/dolt_backup.go | 2 +- .../doltcore/sqle/index/mergeable_indexes_setup_test.go | 6 +++--- go/libraries/doltcore/sqle/kvexec/count_agg_test.go | 4 ++-- go/libraries/doltcore/sqle/kvexec/lookup_join_test.go | 4 ++-- go/libraries/doltcore/sqle/logictest/dolt/doltharness.go | 4 ++-- go/libraries/doltcore/sqle/procedures_table_test.go | 4 ++-- go/libraries/doltcore/sqle/replication.go | 4 ++-- go/libraries/doltcore/sqle/schema_table_test.go | 8 ++++---- go/libraries/doltcore/sqle/statsnoms/database.go | 4 ++-- go/libraries/doltcore/sqle/testutil.go | 6 +++--- .../doltcore/sqle/writer/noms_table_writer_test.go | 4 ++-- 33 files changed, 68 insertions(+), 68 deletions(-) diff --git a/go/cmd/dolt/commands/ci/init.go b/go/cmd/dolt/commands/ci/init.go index cad1b89de76..246fa6bf9fb 100644 --- a/go/cmd/dolt/commands/ci/init.go +++ b/go/cmd/dolt/commands/ci/init.go @@ -115,9 +115,9 @@ func (cmd InitCmd) Exec(ctx context.Context, commandStr string, args []string, d } func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv, useBulkEditor bool) (sqle.Database, error) { - deaf := dEnv.DbEaFactory() + deaf := dEnv.DbEaFactory(ctx) if useBulkEditor { - deaf = dEnv.BulkDbEaFactory() + deaf = dEnv.BulkDbEaFactory(ctx) } tmpDir, err := dEnv.TempTableFilesDir() if err != nil { @@ -127,5 +127,5 @@ func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv, useBulkEdi Deaf: deaf, Tempdir: tmpDir, } - return sqle.NewDatabase(ctx, name, dEnv.DbData(), opts) + return sqle.NewDatabase(ctx, name, dEnv.DbData(ctx), opts) } diff --git a/go/cmd/dolt/commands/dump.go b/go/cmd/dolt/commands/dump.go index b3194d06f2d..fb79e46ff8d 100644 --- a/go/cmd/dolt/commands/dump.go +++ b/go/cmd/dolt/commands/dump.go @@ -595,7 +595,7 @@ func getTableWriter(ctx context.Context, dEnv *env.DoltEnv, tblOpts *tableOption if err != nil { return nil, errhand.BuildDError("error: ").AddCause(err).Build() } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} writer, err := dEnv.FS.OpenForWriteAppend(filePath, os.ModePerm) if err != nil { diff --git a/go/cmd/dolt/commands/engine/utils.go b/go/cmd/dolt/commands/engine/utils.go index 4128d3b03b7..4d234bffd64 100644 --- a/go/cmd/dolt/commands/engine/utils.go +++ b/go/cmd/dolt/commands/engine/utils.go @@ -51,9 +51,9 @@ func CollectDBs(ctx context.Context, mrEnv *env.MultiRepoEnv, useBulkEditor bool } func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv, useBulkEditor bool) (sqle.Database, error) { - deaf := dEnv.DbEaFactory() + deaf := dEnv.DbEaFactory(ctx) if useBulkEditor { - deaf = dEnv.BulkDbEaFactory() + deaf = dEnv.BulkDbEaFactory(ctx) } tmpDir, err := dEnv.TempTableFilesDir() if err != nil { @@ -63,5 +63,5 @@ func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv, useBulkEdi Deaf: deaf, Tempdir: tmpDir, } - return sqle.NewDatabase(ctx, name, dEnv.DbData(), opts) + return sqle.NewDatabase(ctx, name, dEnv.DbData(ctx), opts) } diff --git a/go/cmd/dolt/commands/filter-branch.go b/go/cmd/dolt/commands/filter-branch.go index 06af7dbe5c8..936160af144 100644 --- a/go/cmd/dolt/commands/filter-branch.go +++ b/go/cmd/dolt/commands/filter-branch.go @@ -339,8 +339,8 @@ func rebaseSqlEngine(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootVal if err != nil { return nil, nil, err } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := dsqle.NewDatabase(ctx, filterDbName, dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := dsqle.NewDatabase(ctx, filterDbName, dEnv.DbData(ctx), opts) if err != nil { return nil, nil, err } diff --git a/go/cmd/dolt/commands/indexcmds/rebuild.go b/go/cmd/dolt/commands/indexcmds/rebuild.go index 039ddd75994..74b0a66dbcb 100644 --- a/go/cmd/dolt/commands/indexcmds/rebuild.go +++ b/go/cmd/dolt/commands/indexcmds/rebuild.go @@ -91,7 +91,7 @@ func (cmd RebuildCmd) Exec(ctx context.Context, commandStr string, args []string if err != nil { return HandleErr(errhand.BuildDError("error: ").AddCause(err).Build(), nil) } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} sch, err := table.GetSchema(ctx) if err != nil { return HandleErr(errhand.BuildDError("could not get table schema").AddCause(err).Build(), nil) diff --git a/go/cmd/dolt/commands/schcmds/export.go b/go/cmd/dolt/commands/schcmds/export.go index 9953fe1a8a9..7c7bed7ffc3 100644 --- a/go/cmd/dolt/commands/schcmds/export.go +++ b/go/cmd/dolt/commands/schcmds/export.go @@ -138,7 +138,7 @@ func exportSchemas(ctx context.Context, apr *argparser.ArgParseResults, root dol if err != nil { return errhand.BuildDError("error: ").AddCause(err).Build() } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} verr := exportTblSchema(ctx, tn, root, wr, opts) if verr != nil { return verr diff --git a/go/cmd/dolt/commands/schcmds/show.go b/go/cmd/dolt/commands/schcmds/show.go index 4e8824123f7..43627bc845d 100644 --- a/go/cmd/dolt/commands/schcmds/show.go +++ b/go/cmd/dolt/commands/schcmds/show.go @@ -137,7 +137,7 @@ func printSchemas(ctx context.Context, apr *argparser.ArgParseResults, dEnv *env if err != nil { return errhand.BuildDError("error: ").AddCause(err).Build() } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} sqlCtx, engine, _ := dsqle.PrepareCreateTableStmt(ctx, dsqle.NewUserSpaceDatabase(root, opts)) var notFound []string diff --git a/go/cmd/dolt/commands/sqlserver/server.go b/go/cmd/dolt/commands/sqlserver/server.go index b46ac8e2361..2f03c04d424 100644 --- a/go/cmd/dolt/commands/sqlserver/server.go +++ b/go/cmd/dolt/commands/sqlserver/server.go @@ -174,7 +174,7 @@ func ConfigureServices( AssertNoDatabasesInAccessModeReadOnly := &svcs.AnonService{ InitF: func(ctx context.Context) (err error) { return mrEnv.Iter(func(name string, dEnv *env.DoltEnv) (stop bool, err error) { - if dEnv.IsAccessModeReadOnly() { + if dEnv.IsAccessModeReadOnly(ctx) { return true, ErrCouldNotLockDatabase.New(name) } return false, nil diff --git a/go/cmd/dolt/commands/stashcmds/pop.go b/go/cmd/dolt/commands/stashcmds/pop.go index b4baac50702..d216ebe7eaa 100644 --- a/go/cmd/dolt/commands/stashcmds/pop.go +++ b/go/cmd/dolt/commands/stashcmds/pop.go @@ -163,7 +163,7 @@ func applyStashAtIdx(ctx *sql.Context, dEnv *env.DoltEnv, curWorkingRoot doltdb. return false, err } - opts := editor.Options{Deaf: dEnv.BulkDbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.BulkDbEaFactory(ctx), Tempdir: tmpDir} result, err := merge.MergeRoots(ctx, curWorkingRoot, stashRoot, parentRoot, stashRoot, parentCommit, opts, merge.MergeOpts{IsCherryPick: false}) if err != nil { return false, err diff --git a/go/cmd/dolt/commands/tblcmds/export.go b/go/cmd/dolt/commands/tblcmds/export.go index ed116d655ce..03030579dcf 100644 --- a/go/cmd/dolt/commands/tblcmds/export.go +++ b/go/cmd/dolt/commands/tblcmds/export.go @@ -242,7 +242,7 @@ func getTableWriter(ctx context.Context, root doltdb.RootValue, dEnv *env.DoltEn return nil, errhand.BuildDError("Error opening writer for %s.", exOpts.DestName()).AddCause(err).Build() } - wr, err := exOpts.dest.NewCreatingWriter(ctx, exOpts, root, rdSchema, editor.Options{Deaf: dEnv.DbEaFactory()}, writer) + wr, err := exOpts.dest.NewCreatingWriter(ctx, exOpts, root, rdSchema, editor.Options{Deaf: dEnv.DbEaFactory(ctx)}, writer) if err != nil { return nil, errhand.BuildDError("Error opening writer for %s.", exOpts.DestName()).AddCause(err).Build() } diff --git a/go/cmd/dolt/dolt.go b/go/cmd/dolt/dolt.go index 941639e4deb..539ca189253 100644 --- a/go/cmd/dolt/dolt.go +++ b/go/cmd/dolt/dolt.go @@ -778,7 +778,7 @@ If you're interested in running this command against a remote host, hit us up on } var lookForServer bool - if targetEnv.DoltDB(ctx) != nil && targetEnv.IsAccessModeReadOnly() { + if targetEnv.DoltDB(ctx) != nil && targetEnv.IsAccessModeReadOnly(ctx) { // If the loaded target environment has a doltDB and we do not // have access to it, we look for a server. lookForServer = true @@ -790,7 +790,7 @@ If you're interested in running this command against a remote host, hit us up on var allReposAreReadOnly bool = true mrEnv.Iter(func(name string, dEnv *env.DoltEnv) (stop bool, err error) { if dEnv.DoltDB(ctx) != nil { - allReposAreReadOnly = allReposAreReadOnly && dEnv.IsAccessModeReadOnly() + allReposAreReadOnly = allReposAreReadOnly && dEnv.IsAccessModeReadOnly(ctx) } return !allReposAreReadOnly, nil }) diff --git a/go/libraries/doltcore/dtestutils/testcommands/multienv.go b/go/libraries/doltcore/dtestutils/testcommands/multienv.go index a2fd8e7f82a..80b437dd8ab 100644 --- a/go/libraries/doltcore/dtestutils/testcommands/multienv.go +++ b/go/libraries/doltcore/dtestutils/testcommands/multienv.go @@ -160,7 +160,7 @@ func (mr *MultiRepoTestSetup) NewRemote(remoteName string) { func (mr *MultiRepoTestSetup) NewBranch(dbName, branchName string) { dEnv := mr.envs[dbName] - err := actions.CreateBranchWithStartPt(context.Background(), dEnv.DbData(), branchName, "head", false, nil) + err := actions.CreateBranchWithStartPt(context.Background(), dEnv.DbData(ctx), branchName, "head", false, nil) if err != nil { mr.Errhand(err) } @@ -258,7 +258,7 @@ func (mr *MultiRepoTestSetup) CommitWithWorkingSet(dbName string) *doltdb.Commit if err != nil { panic("couldn't get roots: " + err.Error()) } - pendingCommit, err := actions.GetCommitStaged(ctx, roots, ws, mergeParentCommits, dEnv.DbData().Ddb, actions.CommitStagedProps{ + pendingCommit, err := actions.GetCommitStaged(ctx, roots, ws, mergeParentCommits, dEnv.DbData(ctx).Ddb, actions.CommitStagedProps{ Message: "auto commit", Date: t, AllowEmpty: true, diff --git a/go/libraries/doltcore/env/actions/clone.go b/go/libraries/doltcore/env/actions/clone.go index 04647b465bc..59036c6d663 100644 --- a/go/libraries/doltcore/env/actions/clone.go +++ b/go/libraries/doltcore/env/actions/clone.go @@ -186,7 +186,7 @@ func CloneRemote(ctx context.Context, srcDB *doltdb.DoltDB, remoteName, branch s if depth <= 0 { checkedOutCommit, err = fullClone(ctx, srcDB, dEnv, srcRefHashes, branch, remoteName, singleBranch) } else { - checkedOutCommit, err = shallowCloneDataPull(ctx, dEnv.DbData(), srcDB, remoteName, branch, depth) + checkedOutCommit, err = shallowCloneDataPull(ctx, dEnv.DbData(ctx), srcDB, remoteName, branch, depth) } if err != nil { diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index d66d2e1393e..d0dfa368aab 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -833,7 +833,7 @@ func (dEnv *DoltEnv) HeadCommit(ctx context.Context) (*doltdb.Commit, error) { return dEnv.DoltDB(ctx).ResolveCommitRef(ctx, dEnv.RepoState.CWBHeadRef()) } -func (dEnv *DoltEnv) DbData() DbData { +func (dEnv *DoltEnv) DbData(ctx context.Context) DbData { return DbData{ Ddb: dEnv.DoltDB(ctx), Rsw: dEnv.RepoStateWriter(), @@ -1257,7 +1257,7 @@ func (dEnv *DoltEnv) TempTableFilesDir() (string, error) { return absPath, nil } -func (dEnv *DoltEnv) DbEaFactory() editor.DbEaFactory { +func (dEnv *DoltEnv) DbEaFactory(ctx context.Context) editor.DbEaFactory { tmpDir, err := dEnv.TempTableFilesDir() if err != nil { return nil @@ -1265,7 +1265,7 @@ func (dEnv *DoltEnv) DbEaFactory() editor.DbEaFactory { return editor.NewDbEaFactory(tmpDir, dEnv.DoltDB(ctx).ValueReadWriter()) } -func (dEnv *DoltEnv) BulkDbEaFactory() editor.DbEaFactory { +func (dEnv *DoltEnv) BulkDbEaFactory(ctx context.Context) editor.DbEaFactory { tmpDir, err := dEnv.TempTableFilesDir() if err != nil { return nil @@ -1273,6 +1273,6 @@ func (dEnv *DoltEnv) BulkDbEaFactory() editor.DbEaFactory { return editor.NewBulkImportTEAFactory(dEnv.DoltDB(ctx).ValueReadWriter(), tmpDir) } -func (dEnv *DoltEnv) IsAccessModeReadOnly() bool { +func (dEnv *DoltEnv) IsAccessModeReadOnly(ctx context.Context) bool { return dEnv.DoltDB(ctx).AccessMode() == chunks.ExclusiveAccessMode_ReadOnly } diff --git a/go/libraries/doltcore/env/memory.go b/go/libraries/doltcore/env/memory.go index a2202933209..4c2ed8f5768 100644 --- a/go/libraries/doltcore/env/memory.go +++ b/go/libraries/doltcore/env/memory.go @@ -145,7 +145,7 @@ func (m MemoryRepoState) UpdateStagedRoot(ctx context.Context, newRoot doltdb.Ro wsRef = ws.Ref() } - return m.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, m.workingSetMeta(), nil) + return m.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithStagedRoot(newRoot), h, m.workingSetMeta(), nil) } func (m MemoryRepoState) UpdateWorkingRoot(ctx context.Context, newRoot doltdb.RootValue) error { @@ -175,7 +175,7 @@ func (m MemoryRepoState) UpdateWorkingRoot(ctx context.Context, newRoot doltdb.R wsRef = ws.Ref() } - return m.DoltDB(ctx).UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, m.workingSetMeta(), nil) + return m.DoltDB.UpdateWorkingSet(ctx, wsRef, ws.WithWorkingRoot(newRoot), h, m.workingSetMeta(), nil) } func (m MemoryRepoState) WorkingSet(ctx context.Context) (*doltdb.WorkingSet, error) { @@ -188,7 +188,7 @@ func (m MemoryRepoState) WorkingSet(ctx context.Context) (*doltdb.WorkingSet, er return nil, err } - workingSet, err := m.DoltDB(ctx).ResolveWorkingSet(ctx, workingSetRef) + workingSet, err := m.DoltDB.ResolveWorkingSet(ctx, workingSetRef) if err != nil { return nil, err } diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index 9e6f09426fa..d63f9a08bbf 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -246,7 +246,7 @@ func (mrEnv *MultiRepoEnv) ReloadDBs( } } } - mrEnv.envs = enforceSingleFormat(mrEnv.envs) + mrEnv.envs = enforceSingleFormat(ctx, mrEnv.envs) } func (mrEnv *MultiRepoEnv) FileSystem() filesys.Filesys { @@ -350,7 +350,7 @@ func getRepoRootDir(path, pathSeparator string) string { // enforceSingleFormat enforces that constraint that all databases in // a multi-database environment have the same NomsBinFormat. // Databases are removed from the MultiRepoEnv to ensure this is true. -func enforceSingleFormat(envSet []NamedEnv) []NamedEnv { +func enforceSingleFormat(ctx context.Context, envSet []NamedEnv) []NamedEnv { formats := set.NewEmptyStrSet() for _, namedEnv := range envSet { dEnv := namedEnv.env diff --git a/go/libraries/doltcore/mvdata/data_loc_test.go b/go/libraries/doltcore/mvdata/data_loc_test.go index 212edd10305..55041069acf 100644 --- a/go/libraries/doltcore/mvdata/data_loc_test.go +++ b/go/libraries/doltcore/mvdata/data_loc_test.go @@ -211,7 +211,7 @@ func TestCreateRdWr(t *testing.T) { if tdErr != nil { t.Fatal("Unexpected error accessing .dolt directory.", tdErr) } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} filePath, fpErr := dEnv.FS.Abs(strings.Split(loc.String(), ":")[1]) if fpErr != nil { diff --git a/go/libraries/doltcore/rebase/filter_branch.go b/go/libraries/doltcore/rebase/filter_branch.go index af7bd39bd41..ee8266697e0 100644 --- a/go/libraries/doltcore/rebase/filter_branch.go +++ b/go/libraries/doltcore/rebase/filter_branch.go @@ -81,7 +81,7 @@ func AllBranchesAndTags(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted if err != nil { return err } - return rebaseRefs(ctx, dEnv.DbData(), applyUncommitted, commitReplayer, rootReplayer, nerf, append(branches, tags...)...) + return rebaseRefs(ctx, dEnv.DbData(ctx), applyUncommitted, commitReplayer, rootReplayer, nerf, append(branches, tags...)...) } // AllBranches rewrites the history of all branches in the repo using the |replay| function. @@ -90,7 +90,7 @@ func AllBranches(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted bool, if err != nil { return err } - return rebaseRefs(ctx, dEnv.DbData(), applyUncommitted, commitReplayer, rootReplayer, nerf, branches...) + return rebaseRefs(ctx, dEnv.DbData(ctx), applyUncommitted, commitReplayer, rootReplayer, nerf, branches...) } // CurrentBranch rewrites the history of the current branch using the |replay| function. @@ -99,7 +99,7 @@ func CurrentBranch(ctx context.Context, dEnv *env.DoltEnv, applyUncommitted bool if err != nil { return nil } - return rebaseRefs(ctx, dEnv.DbData(), applyUncommitted, commitReplayer, rootReplayer, nerf, headRef) + return rebaseRefs(ctx, dEnv.DbData(ctx), applyUncommitted, commitReplayer, rootReplayer, nerf, headRef) } func rebaseRefs(ctx context.Context, dbData env.DbData, applyUncommitted bool, commitReplayer CommitReplayer, rootReplayer RootReplayer, nerf NeedsRebaseFn, refs ...ref.DoltRef) error { diff --git a/go/libraries/doltcore/sqle/alterschema_test.go b/go/libraries/doltcore/sqle/alterschema_test.go index be221e1adad..874793e4d30 100644 --- a/go/libraries/doltcore/sqle/alterschema_test.go +++ b/go/libraries/doltcore/sqle/alterschema_test.go @@ -440,8 +440,8 @@ func TestDropPks(t *testing.T) { defer dEnv.DoltDB(ctx).Close() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(ctx, "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(ctx, "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) root, _ := dEnv.WorkingRoot(ctx) diff --git a/go/libraries/doltcore/sqle/common_test.go b/go/libraries/doltcore/sqle/common_test.go index 7b3b6361f55..893f589f2b6 100644 --- a/go/libraries/doltcore/sqle/common_test.go +++ b/go/libraries/doltcore/sqle/common_test.go @@ -41,8 +41,8 @@ type SetupFn func(t *testing.T, dEnv *env.DoltEnv) func executeSelect(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, query string) ([]sql.Row, sql.Schema, error) { tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(ctx, "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(ctx, "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, sqlCtx, err := NewTestEngine(dEnv, ctx, db) @@ -72,8 +72,8 @@ func executeSelect(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, root do func executeModify(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, query string) (doltdb.RootValue, error) { tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(ctx, "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(ctx, "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, sqlCtx, err := NewTestEngine(dEnv, ctx, db) diff --git a/go/libraries/doltcore/sqle/database_provider.go b/go/libraries/doltcore/sqle/database_provider.go index 218b506bc18..b27a671869f 100644 --- a/go/libraries/doltcore/sqle/database_provider.go +++ b/go/libraries/doltcore/sqle/database_provider.go @@ -847,12 +847,12 @@ func (p *DoltDatabaseProvider) registerNewDatabase(ctx *sql.Context, name string } opts := editor.Options{ - Deaf: newEnv.DbEaFactory(), + Deaf: newEnv.DbEaFactory(ctx), // TODO: this doesn't seem right, why is this getting set in the constructor to the DB ForeignKeyChecksDisabled: fkChecks.(int8) == 0, } - db, err := NewDatabase(ctx, name, newEnv.DbData(), opts) + db, err := NewDatabase(ctx, name, newEnv.DbData(ctx), opts) if err != nil { return err } diff --git a/go/libraries/doltcore/sqle/database_test.go b/go/libraries/doltcore/sqle/database_test.go index d5ea762ad57..bd415b3d6d1 100644 --- a/go/libraries/doltcore/sqle/database_test.go +++ b/go/libraries/doltcore/sqle/database_test.go @@ -46,11 +46,11 @@ func TestNeedsToReloadEvents(t *testing.T) { dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} timestamp := time.Now().Truncate(time.Minute).UTC() - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) _, ctx, err := NewTestEngine(dEnv, context.Background(), db) diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_backup.go b/go/libraries/doltcore/sqle/dprocedures/dolt_backup.go index 12679aad33b..0c5bbc4a1cf 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_backup.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_backup.go @@ -199,7 +199,7 @@ func restoreBackup(ctx *sql.Context, _ env.DbData, apr *argparser.ArgParseResult return err } - if err = syncRootsFromBackup(ctx, clonedEnv.DbData(), sess, r); err != nil { + if err = syncRootsFromBackup(ctx, clonedEnv.DbData(ctx), sess, r); err != nil { // If we're cloning into a directory that already exists do not erase it. // Otherwise, make a best effort to delete any directory we created. if userDirExisted { diff --git a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go index e9ad42678c2..3a438fd13a0 100644 --- a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go +++ b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go @@ -38,8 +38,8 @@ func setupIndexes(t *testing.T, tableName, insertQuery string) (*sqle.Engine, *s dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := dsqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := dsqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, sqlCtx, err := dsqle.NewTestEngine(dEnv, context.Background(), db) @@ -193,7 +193,7 @@ func getDbState(t *testing.T, db sql.Database, dEnv *env.DoltEnv) (dsess.Initial Db: db, HeadCommit: headCommit, WorkingSet: ws, - DbData: dEnv.DbData(), + DbData: dEnv.DbData(ctx), Remotes: dEnv.RepoState.Remotes, }, nil } diff --git a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go index 0d4a50adcb7..d974628a773 100644 --- a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go +++ b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go @@ -97,8 +97,8 @@ func TestCountAgg(t *testing.T) { tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) diff --git a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go index 56c9cc634ce..8dd2d900e83 100644 --- a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go +++ b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go @@ -155,8 +155,8 @@ func TestLookupJoin(t *testing.T) { tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) diff --git a/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go b/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go index 55a82af0dce..74d72b14e86 100644 --- a/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go +++ b/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go @@ -287,8 +287,8 @@ func sqlNewEngine(dEnv *env.DoltEnv) (*sqle.Engine, dsess.DoltDatabaseProvider, if err != nil { return nil, nil, err } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := dsql.NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := dsql.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) if err != nil { return nil, nil, err } diff --git a/go/libraries/doltcore/sqle/procedures_table_test.go b/go/libraries/doltcore/sqle/procedures_table_test.go index 13cb86abd24..d21a64a6664 100644 --- a/go/libraries/doltcore/sqle/procedures_table_test.go +++ b/go/libraries/doltcore/sqle/procedures_table_test.go @@ -37,7 +37,7 @@ func TestProceduresMigration(t *testing.T) { dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} timestamp := time.Now().Truncate(time.Minute).UTC() @@ -113,7 +113,7 @@ func TestProceduresMigration(t *testing.T) { } func newDatabaseWithProcedures(t *testing.T, dEnv *env.DoltEnv, opts editor.Options, timestamp time.Time) (*sql.Context, *Database) { - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) _, ctx, err := NewTestEngine(dEnv, context.Background(), db) diff --git a/go/libraries/doltcore/sqle/replication.go b/go/libraries/doltcore/sqle/replication.go index 8cab390c5de..0a6319ba938 100644 --- a/go/libraries/doltcore/sqle/replication.go +++ b/go/libraries/doltcore/sqle/replication.go @@ -93,10 +93,10 @@ func GetCommitHooks(ctx context.Context, bThreads *sql.BackgroundThreads, dEnv * // that will log warnings when attempting to perform replica commands. func newReplicaDatabase(ctx context.Context, name string, remoteName string, dEnv *env.DoltEnv) (ReadReplicaDatabase, error) { opts := editor.Options{ - Deaf: dEnv.DbEaFactory(), + Deaf: dEnv.DbEaFactory(ctx), } - db, err := NewDatabase(ctx, name, dEnv.DbData(), opts) + db, err := NewDatabase(ctx, name, dEnv.DbData(ctx), opts) if err != nil { return ReadReplicaDatabase{}, err } diff --git a/go/libraries/doltcore/sqle/schema_table_test.go b/go/libraries/doltcore/sqle/schema_table_test.go index 768e7f7cc77..c44e98deb14 100644 --- a/go/libraries/doltcore/sqle/schema_table_test.go +++ b/go/libraries/doltcore/sqle/schema_table_test.go @@ -33,8 +33,8 @@ func TestAncientSchemaTableMigration(t *testing.T) { dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) _, ctx, err := NewTestEngine(dEnv, context.Background(), db) @@ -94,8 +94,8 @@ func TestV1SchemasTable(t *testing.T) { dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) _, ctx, err := NewTestEngine(dEnv, context.Background(), db) diff --git a/go/libraries/doltcore/sqle/statsnoms/database.go b/go/libraries/doltcore/sqle/statsnoms/database.go index cc47001239d..ee05d74e90e 100644 --- a/go/libraries/doltcore/sqle/statsnoms/database.go +++ b/go/libraries/doltcore/sqle/statsnoms/database.go @@ -89,7 +89,7 @@ func (sf NomsStatsFactory) Init(ctx *sql.Context, sourceDb dsess.SqlDatabase, pr dEnv.LoadDoltDBWithParams(ctx, types.Format_Default, urlPath, statsFs, params) - deaf := dEnv.DbEaFactory() + deaf := dEnv.DbEaFactory(ctx) tmpDir, err := dEnv.TempTableFilesDir() if err != nil { @@ -99,7 +99,7 @@ func (sf NomsStatsFactory) Init(ctx *sql.Context, sourceDb dsess.SqlDatabase, pr Deaf: deaf, Tempdir: tmpDir, } - statsDb, err := sqle.NewDatabase(ctx, "stats", dEnv.DbData(), opts) + statsDb, err := sqle.NewDatabase(ctx, "stats", dEnv.DbData(ctx), opts) if err != nil { return nil, err } diff --git a/go/libraries/doltcore/sqle/testutil.go b/go/libraries/doltcore/sqle/testutil.go index a7567370465..52ed56bbd64 100644 --- a/go/libraries/doltcore/sqle/testutil.go +++ b/go/libraries/doltcore/sqle/testutil.go @@ -50,8 +50,8 @@ func ExecuteSql(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, s return nil, err } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) if err != nil { return nil, err } @@ -152,7 +152,7 @@ func ExecuteSelect(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue return nil, err } - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} db, err := NewDatabase(context.Background(), "dolt", dbData, opts) if err != nil { return nil, err diff --git a/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go b/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go index 92cb8f69ce1..1ba3b6542d5 100644 --- a/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go +++ b/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go @@ -159,8 +159,8 @@ func TestTableEditor(t *testing.T) { tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) - opts := editor.Options{Deaf: dEnv.DbEaFactory(), Tempdir: tmpDir} - db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(), opts) + opts := editor.Options{Deaf: dEnv.DbEaFactory(ctx), Tempdir: tmpDir} + db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) From 9c04d50a70dac32dd89593f05945cd418ad7daa7 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 00:01:04 -0800 Subject: [PATCH 04/17] Remove explicit list of commands that not need to eagerly load the DB. --- go/cmd/dolt/dolt.go | 44 +------------------------------------------- 1 file changed, 1 insertion(+), 43 deletions(-) diff --git a/go/cmd/dolt/dolt.go b/go/cmd/dolt/dolt.go index 539ca189253..05435103c8c 100644 --- a/go/cmd/dolt/dolt.go +++ b/go/cmd/dolt/dolt.go @@ -157,31 +157,6 @@ var commandsWithoutCliCtx = []cli.Command{ commands.ConfigCmd{}, } -// These commands have one of the following properties: -// - They require that the database does not exist -// - They never access the database -// - They only ever access the database through a CliContext. -// - They always call dEnv.ReloadDB() before accessing the database for the first time. -// In these cases, we can defer loading the database until it's actually needed. -var commandsWithoutDBLoad = []cli.Command{ - commands.InitCmd{}, - commands.CloneCmd{}, - commands.StatusCmd{}, - commands.LsCmd{}, - commands.AddCmd{}, - commands.DiffCmd{}, - commands.ResetCmd{}, - commands.CleanCmd{}, - commands.SqlCmd{VersionStr: doltversion.Version}, - commands.LogCmd{}, - commands.BranchCmd{}, - commands.MergeCmd{}, - commands.ShowCmd{}, - commands.CherryPickCmd{}, - commands.ConfigCmd{}, - credcmds.Commands, -} - var commandsWithoutGlobalArgSupport = []cli.Command{ commands.InitCmd{}, commands.CloneCmd{}, @@ -212,15 +187,6 @@ func initCliContext(commandName string) bool { return true } -func eagerlyLoadDB(commandName string) bool { - for _, command := range commandsWithoutDBLoad { - if command.Name() == commandName { - return false - } - } - return true -} - func supportsGlobalArgs(commandName string) bool { for _, command := range commandsWithoutGlobalArgSupport { if command.Name() == commandName { @@ -509,12 +475,7 @@ func runMain() int { args = nil // This is the dEnv passed to sub-commands, and is used to create the multi-repo environment. - var dEnv *env.DoltEnv - if eagerlyLoadDB(cfg.subCommand) { - dEnv = env.Load(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) - } else { - dEnv = env.LoadWithDeferredDB(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) - } + dEnv := env.LoadWithDeferredDB(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) if dEnv.CfgLoadErr != nil { cli.PrintErrln(color.RedString("Failed to load the global config. %v", dEnv.CfgLoadErr)) @@ -577,9 +538,6 @@ func runMain() int { cli.PrintErrln("failed to load database names") return 1 } - if eagerlyLoadDB(cfg.subCommand) { - mrEnv.ReloadDBs(ctx) - } _ = mrEnv.Iter(func(dbName string, dEnv *env.DoltEnv) (stop bool, err error) { dsess.DefineSystemVariablesForDB(dbName) return false, nil From a963a8507b661364a30b8f8274d651916c151ed6 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 00:13:39 -0800 Subject: [PATCH 05/17] Don't load the database until we actually bind the queryist. --- go/cmd/dolt/commands/utils.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/go/cmd/dolt/commands/utils.go b/go/cmd/dolt/commands/utils.go index 4f45e35e4f6..566578ab842 100644 --- a/go/cmd/dolt/commands/utils.go +++ b/go/cmd/dolt/commands/utils.go @@ -128,7 +128,6 @@ func BuildSqlEngineQueryist(ctx context.Context, cwdFS filesys.Filesys, mrEnv *e if ctx == nil || cwdFS == nil || mrEnv == nil || creds == nil || apr == nil { return nil, errhand.VerboseErrorFromError(fmt.Errorf("Invariant violated. Nil argument provided to BuildSqlEngineQueryist")) } - mrEnv.ReloadDBs(ctx) // We want to know if the user provided us the data-dir flag, but we want to use the abs value used to // create the DoltEnv. This is a little messy. @@ -248,6 +247,11 @@ func newLateBindingEngine( } var lateBinder cli.LateBindQueryist = func(ctx2 context.Context) (cli.Queryist, *sql.Context, func(), error) { + // We've deferred loading the database as long as we can. + // If we're binding the Queryist, that means that engine is actually + // going to be used. + mrEnv.ReloadDBs(ctx2) + se, err := engine.NewSqlEngine( ctx2, mrEnv, From b6c233dbbbf74b97a227d06a0fe7b225457cebf3 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 00:34:30 -0800 Subject: [PATCH 06/17] Remove explicit calls to `dEnv.ReloadDB()` from commands. --- go/cmd/dolt/commands/branch.go | 4 ---- go/cmd/dolt/commands/show.go | 4 ---- go/cmd/dolt/commands/sql.go | 12 ------------ 3 files changed, 20 deletions(-) diff --git a/go/cmd/dolt/commands/branch.go b/go/cmd/dolt/commands/branch.go index dfef6599cdc..8a613eb6206 100644 --- a/go/cmd/dolt/commands/branch.go +++ b/go/cmd/dolt/commands/branch.go @@ -139,10 +139,6 @@ func (cmd BranchCmd) Exec(ctx context.Context, commandStr string, args []string, case apr.Contains(showCurrentFlag): return printCurrentBranch(sqlCtx, queryEngine) case apr.Contains(datasetsFlag): - dEnv.ReloadDB(ctx) - if HandleDEnvErrorsAndExitCode(errorBuilder, dEnv, usage) { - return 1 - } return printAllDatasets(ctx, dEnv) case apr.NArg() > 0: return createBranch(sqlCtx, queryEngine, apr, args, usage) diff --git a/go/cmd/dolt/commands/show.go b/go/cmd/dolt/commands/show.go index 0e4ecc108b5..473ad4fa536 100644 --- a/go/cmd/dolt/commands/show.go +++ b/go/cmd/dolt/commands/show.go @@ -158,10 +158,6 @@ func (cmd ShowCmd) Exec(ctx context.Context, commandStr string, args []string, d cli.PrintErrln("`dolt show --no-pretty` or `dolt show (BRANCHNAME)` is not supported when using old LD_1 storage format.") return 1 } - dEnv.ReloadDB(ctx) - if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { - return 1 - } } specRefs := opts.specRefs diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go index 6f7a5fb4fd3..914141da163 100644 --- a/go/cmd/dolt/commands/sql.go +++ b/go/cmd/dolt/commands/sql.go @@ -218,24 +218,12 @@ func (cmd SqlCmd) Exec(ctx context.Context, commandStr string, args []string, dE if query, queryOK := apr.GetValue(QueryFlag); queryOK { if apr.Contains(saveFlag) { - dEnv.ReloadDB(ctx) - if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { - return 1 - } return execSaveQuery(sqlCtx, dEnv, queryist, apr, query, format, usage) } return queryMode(sqlCtx, queryist, apr, query, format, usage) } else if savedQueryName, exOk := apr.GetValue(executeFlag); exOk { - dEnv.ReloadDB(ctx) - if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { - return 1 - } return executeSavedQuery(sqlCtx, queryist, dEnv, savedQueryName, format, usage) } else if apr.Contains(listSavedFlag) { - dEnv.ReloadDB(ctx) - if HandleDEnvErrorsAndExitCode(nil, dEnv, usage) { - return 1 - } return listSavedQueries(sqlCtx, queryist, dEnv, format, usage) } else { // Run in either batch mode for piped input, or shell mode for interactive From e89385dfe95afd03a0c67cb04773e6d86487179f Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 12:13:58 -0800 Subject: [PATCH 07/17] Add url parameter to LoadWithoutDB and remove LoadWithDeferredDB --- go/cmd/dolt/dolt.go | 6 +++--- go/libraries/doltcore/env/environment.go | 15 ++++++--------- go/libraries/doltcore/env/multi_repo_env.go | 2 +- go/libraries/doltcore/sqle/statsnoms/database.go | 2 +- 4 files changed, 11 insertions(+), 14 deletions(-) diff --git a/go/cmd/dolt/dolt.go b/go/cmd/dolt/dolt.go index 05435103c8c..0cbc4851e8a 100644 --- a/go/cmd/dolt/dolt.go +++ b/go/cmd/dolt/dolt.go @@ -475,7 +475,7 @@ func runMain() int { args = nil // This is the dEnv passed to sub-commands, and is used to create the multi-repo environment. - dEnv := env.LoadWithDeferredDB(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) + dEnv := env.LoadWithoutDB(ctx, env.GetCurrentUserHomeDir, cfg.dataDirFS, doltdb.LocalDirDoltDB, doltversion.Version) if dEnv.CfgLoadErr != nil { cli.PrintErrln(color.RedString("Failed to load the global config. %v", dEnv.CfgLoadErr)) @@ -850,7 +850,7 @@ func interceptSendMetrics(ctx context.Context, args []string) (bool, int) { if len(args) < 1 || args[0] != commands.SendMetricsCommand { return false, 0 } - dEnv := env.LoadWithoutDB(ctx, env.GetCurrentUserHomeDir, filesys.LocalFS, doltversion.Version) + dEnv := env.LoadWithoutDB(ctx, env.GetCurrentUserHomeDir, filesys.LocalFS, "", doltversion.Version) return true, doltCommand.Exec(ctx, "dolt", args, dEnv, nil) } @@ -895,7 +895,7 @@ func createBootstrapConfig(ctx context.Context, args []string) (cfg *bootstrapCo return nil, true, 1 } - tmpEnv := env.LoadWithoutDB(ctx, env.GetCurrentUserHomeDir, cwdFs, doltversion.Version) + tmpEnv := env.LoadWithoutDB(ctx, env.GetCurrentUserHomeDir, cwdFs, "", doltversion.Version) var globalConfig config.ReadWriteConfig homeDir, err := env.GetCurrentUserHomeDir() diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index d0dfa368aab..8c933dae5a6 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -179,7 +179,9 @@ func (dEnv *DoltEnv) ReloadRepoState() error { return nil } -func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, version string) *DoltEnv { +// LoadWithoutDB creates a DoltEnv without eagerly loading the DB. +// If urlStr is non-empty, then the DB can be loaded later by calling DoltEnv.ReloadDB. +func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { cfg, cfgErr := LoadDoltCliConfig(hdp, fs) repoState, rsErr := createRepoState(fs) @@ -192,19 +194,14 @@ func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, v RSLoadErr: rsErr, FS: fs, hdp: hdp, + urlStr: urlStr, } } // Load loads the DoltEnv for the .dolt directory determined by resolving the specified urlStr with the specified Filesys. func Load(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { - dEnv := LoadWithoutDB(ctx, hdp, fs, version) - LoadDoltDB(ctx, fs, urlStr, dEnv) - return dEnv -} - -func LoadWithDeferredDB(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { - dEnv := LoadWithoutDB(ctx, hdp, fs, version) - dEnv.urlStr = urlStr + dEnv := LoadWithoutDB(ctx, hdp, fs, urlStr, version) + dEnv.ReloadDB(ctx) return dEnv } diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index d63f9a08bbf..40852758958 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -187,7 +187,7 @@ func MultiEnvForDirectory( version = dEnv.Version } - newEnv := LoadWithDeferredDB(ctx, GetCurrentUserHomeDir, newFs, doltdb.LocalDirDoltDB, version) + newEnv := LoadWithoutDB(ctx, GetCurrentUserHomeDir, newFs, doltdb.LocalDirDoltDB, version) if newEnv.Valid() { envSet[dbfactory.DirToDBName(dir)] = newEnv } else { diff --git a/go/libraries/doltcore/sqle/statsnoms/database.go b/go/libraries/doltcore/sqle/statsnoms/database.go index ee05d74e90e..6a972a3b103 100644 --- a/go/libraries/doltcore/sqle/statsnoms/database.go +++ b/go/libraries/doltcore/sqle/statsnoms/database.go @@ -84,7 +84,7 @@ func (sf NomsStatsFactory) Init(ctx *sql.Context, sourceDb dsess.SqlDatabase, pr } else if !isDir { return nil, fmt.Errorf("file exists where the dolt stats directory should be") } else { - dEnv = env.LoadWithoutDB(ctx, hdp, statsFs, "") + dEnv = env.LoadWithoutDB(ctx, hdp, statsFs, "", "") } dEnv.LoadDoltDBWithParams(ctx, types.Format_Default, urlPath, statsFs, params) From 849e5c0b670adb475883cca7cd07be2107cc5c2e Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 13:00:47 -0800 Subject: [PATCH 08/17] Create context object for remote server main function. --- go/utils/remotesrv/main.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/go/utils/remotesrv/main.go b/go/utils/remotesrv/main.go index 1c48412390e..f303463290a 100644 --- a/go/utils/remotesrv/main.go +++ b/go/utils/remotesrv/main.go @@ -74,7 +74,8 @@ func main() { var dbCache remotesrv.DBCache if *repoModeParam { - dEnv := env.Load(context.Background(), env.GetCurrentUserHomeDir, fs, doltdb.LocalDirDoltDB, "remotesrv") + ctx := context.Background() + dEnv := env.Load(ctx, env.GetCurrentUserHomeDir, fs, doltdb.LocalDirDoltDB, "remotesrv") if !dEnv.Valid() { log.Fatalln("repo-mode failed to load repository") } From e568a66a197e83b246ebf08f3e5e6f78e361d3f1 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 13:17:21 -0800 Subject: [PATCH 09/17] Fix infinite recursion loop in DoltEnv.DoltDB() --- go/libraries/doltcore/env/environment.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index 8c933dae5a6..e3a7837fcfb 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -111,7 +111,7 @@ func (dEnv *DoltEnv) DoltDB(ctx context.Context) *doltdb.DoltDB { if dEnv.doltDB == nil { LoadDoltDB(ctx, dEnv.FS, dEnv.urlStr, dEnv) } - return dEnv.DoltDB(ctx) + return dEnv.doltDB } func (dEnv *DoltEnv) LoadDoltDBWithParams(ctx context.Context, nbf *types.NomsBinFormat, urlStr string, fs filesys.Filesys, params map[string]interface{}) error { From d0fb77f7e21941fd324c279d783db103e0a98da5 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 14:02:56 -0800 Subject: [PATCH 10/17] Fixup tests. --- .../doltcore/merge/schema_integration_test.go | 14 +++--- .../doltcore/migrate/integration_test.go | 48 +++++++++---------- .../doltcore/sqle/cluster/commithook_test.go | 4 +- go/libraries/doltcore/sqle/database_test.go | 23 ++++----- go/libraries/doltcore/sqle/sqlddl_test.go | 2 +- 5 files changed, 46 insertions(+), 45 deletions(-) diff --git a/go/libraries/doltcore/merge/schema_integration_test.go b/go/libraries/doltcore/merge/schema_integration_test.go index 63033fe64b9..38ddd904391 100644 --- a/go/libraries/doltcore/merge/schema_integration_test.go +++ b/go/libraries/doltcore/merge/schema_integration_test.go @@ -541,12 +541,12 @@ func newColTypeInfo(name string, tag uint64, typeInfo typeinfo.TypeInfo, partOfP return c } -func fkCollection(fks ...DoltDB(ctx).ForeignKey) *doltdb.ForeignKeyCollection { -fkc, err := doltdb.NewForeignKeyCollection(fks...) -if err != nil { -panic(err) -} -return fkc +func fkCollection(fks ...doltdb.ForeignKey) *doltdb.ForeignKeyCollection { + fkc, err := doltdb.NewForeignKeyCollection(fks...) + if err != nil { + panic(err) + } + return fkc } func testMergeSchemas(t *testing.T, test mergeSchemaTest) { @@ -555,9 +555,9 @@ func testMergeSchemas(t *testing.T, test mergeSchemaTest) { return } + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() cliCtx, _ := commands.NewArgFreeCliContext(ctx, dEnv, dEnv.FS) diff --git a/go/libraries/doltcore/migrate/integration_test.go b/go/libraries/doltcore/migrate/integration_test.go index 17726d62424..4443d5f3c37 100644 --- a/go/libraries/doltcore/migrate/integration_test.go +++ b/go/libraries/doltcore/migrate/integration_test.go @@ -226,32 +226,32 @@ func runMigration(t *testing.T, ctx context.Context, preEnv *env.DoltEnv) (postE } func initTestMigrationDB(ctx context.Context) (*doltdb.DoltDB, error) { -var db datas.Database -storage := &chunks.MemoryStorage{} -cs := storage.NewViewWithFormat("__DOLT__") -vrw := types.NewValueStore(cs) -ns := tree.NewNodeStore(cs) -db = datas.NewTypesDatabase(vrw, ns) + var db datas.Database + storage := &chunks.MemoryStorage{} + cs := storage.NewViewWithFormat("__DOLT__") + vrw := types.NewValueStore(cs) + ns := tree.NewNodeStore(cs) + db = datas.NewTypesDatabase(vrw, ns) -name, email := "user", "user@fake.horse" -meta, err := datas.NewCommitMeta(name, email, "test migration") -if err != nil { -return nil, err -} + name, email := "user", "user@fake.horse" + meta, err := datas.NewCommitMeta(name, email, "test migration") + if err != nil { + return nil, err + } -rv, err := doltdb.EmptyRootValue(ctx, vrw, ns) -if err != nil { -return nil, err -} + rv, err := doltdb.EmptyRootValue(ctx, vrw, ns) + if err != nil { + return nil, err + } -ds, err := db.GetDataset(ctx, ref.NewInternalRef("migration").String()) -if err != nil { -return nil, err -} + ds, err := db.GetDataset(ctx, ref.NewInternalRef("migration").String()) + if err != nil { + return nil, err + } -_, err = db.Commit(ctx, ds, rv.NomsValue(), datas.CommitOptions{Meta: meta}) -if err != nil { -return nil, err -} -return doltdb.DoltDB(ctx)FromCS(cs, ""), nil + _, err = db.Commit(ctx, ds, rv.NomsValue(), datas.CommitOptions{Meta: meta}) + if err != nil { + return nil, err + } + return doltdb.DoltDBFromCS(cs, ""), nil } diff --git a/go/libraries/doltcore/sqle/cluster/commithook_test.go b/go/libraries/doltcore/sqle/cluster/commithook_test.go index d1135094298..c716dee441e 100644 --- a/go/libraries/doltcore/sqle/cluster/commithook_test.go +++ b/go/libraries/doltcore/sqle/cluster/commithook_test.go @@ -27,6 +27,7 @@ import ( func TestCommitHookStartsNotCaughtUp(t *testing.T) { srcEnv := dtestutils.CreateTestEnv() + ctx := context.Background() t.Cleanup(func() { srcEnv.DoltDB(ctx).Close() }) @@ -35,8 +36,7 @@ func TestCommitHookStartsNotCaughtUp(t *testing.T) { destEnv.DoltDB(ctx).Close() }) - hook := newCommitHook(logrus.StandardLogger(), "origin", "https://localhost:50051/mydb", "mydb", RolePrimary, func(context.Context) (*doltdb.DoltDB, error) - { + hook := newCommitHook(logrus.StandardLogger(), "origin", "https://localhost:50051/mydb", "mydb", RolePrimary, func(context.Context) (*doltdb.DoltDB, error) { return destEnv.DoltDB(ctx), nil }, srcEnv.DoltDB(ctx), t.TempDir()) diff --git a/go/libraries/doltcore/sqle/database_test.go b/go/libraries/doltcore/sqle/database_test.go index bd415b3d6d1..697fa75ff6c 100644 --- a/go/libraries/doltcore/sqle/database_test.go +++ b/go/libraries/doltcore/sqle/database_test.go @@ -43,6 +43,7 @@ func TestIsKeyFuncs(t *testing.T) { } func TestNeedsToReloadEvents(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) @@ -50,16 +51,16 @@ func TestNeedsToReloadEvents(t *testing.T) { timestamp := time.Now().Truncate(time.Minute).UTC() - db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) + db, err := NewDatabase(ctx, "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - _, ctx, err := NewTestEngine(dEnv, context.Background(), db) + _, sqlCtx, err := NewTestEngine(dEnv, ctx, db) require.NoError(t, err) var token any t.Run("empty schema table doesn't need to be reloaded", func(t *testing.T) { - needsReload, err := db.NeedsToReloadEvents(ctx, token) + needsReload, err := db.NeedsToReloadEvents(sqlCtx, token) require.NoError(t, err) assert.False(t, needsReload) }) @@ -73,38 +74,38 @@ BEGIN CALL archive_order_history(DATE_SUB(CURDATE(), INTERVAL 1 YEAR)); END` - err = db.addFragToSchemasTable(ctx, "event", "testEvent", eventDefn, timestamp, nil) + err = db.addFragToSchemasTable(sqlCtx, "event", "testEvent", eventDefn, timestamp, nil) require.NoError(t, err) t.Run("events need to be reloaded after addition", func(t *testing.T) { - needsReload, err := db.NeedsToReloadEvents(ctx, token) + needsReload, err := db.NeedsToReloadEvents(sqlCtx, token) require.NoError(t, err) assert.True(t, needsReload) }) - _, token, err = db.GetEvents(ctx) + _, token, err = db.GetEvents(sqlCtx) require.NoError(t, err) t.Run("events do not need to be reloaded after no change", func(t *testing.T) { - needsReload, err := db.NeedsToReloadEvents(ctx, token) + needsReload, err := db.NeedsToReloadEvents(sqlCtx, token) require.NoError(t, err) assert.False(t, needsReload) }) - err = db.dropFragFromSchemasTable(ctx, "event", "testEvent", nil) + err = db.dropFragFromSchemasTable(sqlCtx, "event", "testEvent", nil) require.NoError(t, err) t.Run("events need to be reloaded after dropping one", func(t *testing.T) { - needsReload, err := db.NeedsToReloadEvents(ctx, token) + needsReload, err := db.NeedsToReloadEvents(sqlCtx, token) require.NoError(t, err) assert.True(t, needsReload) }) - _, token, err = db.GetEvents(ctx) + _, token, err = db.GetEvents(sqlCtx) require.NoError(t, err) t.Run("events do not need to be reloaded after no change", func(t *testing.T) { - needsReload, err := db.NeedsToReloadEvents(ctx, token) + needsReload, err := db.NeedsToReloadEvents(sqlCtx, token) require.NoError(t, err) assert.False(t, needsReload) }) diff --git a/go/libraries/doltcore/sqle/sqlddl_test.go b/go/libraries/doltcore/sqle/sqlddl_test.go index 7f68cec6c60..7ec12066717 100644 --- a/go/libraries/doltcore/sqle/sqlddl_test.go +++ b/go/libraries/doltcore/sqle/sqlddl_test.go @@ -514,11 +514,11 @@ func TestAddColumn(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) From 7f0ca8c4c0923ad88e94f9dd902011767c38bbd4 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 14:54:25 -0800 Subject: [PATCH 11/17] Respond to PR feedback. --- go/libraries/doltcore/env/multi_repo_env.go | 4 +--- go/libraries/doltcore/sqle/dsess/session.go | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index 40852758958..fef0ee42074 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -230,9 +230,7 @@ func (mrEnv *MultiRepoEnv) ReloadDBs( for _, namedEnv := range mrEnv.envs { dEnv := namedEnv.env - if dEnv.DoltDB(ctx) == nil { - dEnv.ReloadDB(ctx) - } + dEnv.ReloadDB(ctx) if !dEnv.Valid() { dbErr := dEnv.DBLoadError if dbErr != nil { diff --git a/go/libraries/doltcore/sqle/dsess/session.go b/go/libraries/doltcore/sqle/dsess/session.go index 1e828e55e89..8bcd5cf79e0 100644 --- a/go/libraries/doltcore/sqle/dsess/session.go +++ b/go/libraries/doltcore/sqle/dsess/session.go @@ -871,7 +871,7 @@ func (d *DoltSession) ReleaseSavepoint(ctx *sql.Context, tx sql.Transaction, sav return nil } -// GetDoltDB returns the *doltDB for a given database by name +// GetDoltDB returns the *DoltDB for a given database by name func (d *DoltSession) GetDoltDB(ctx *sql.Context, dbName string) (*doltdb.DoltDB, bool) { branchState, ok, err := d.lookupDbState(ctx, dbName) if err != nil { From 411b676af4413c6580c2e792395630d34a0d3ac2 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Thu, 23 Jan 2025 16:54:54 -0800 Subject: [PATCH 12/17] Respond to PR feedback. --- go/cmd/dolt/commands/init_test.go | 8 +++-- go/cmd/dolt/commands/log_test.go | 6 ++-- go/cmd/dolt/commands/sql_test.go | 1 + go/cmd/dolt/commands/sqlserver/server_test.go | 9 +++++- .../dtestutils/testcommands/multienv.go | 10 +++---- .../sqle/enginetest/dolt_engine_test.go | 1 + .../doltcore/sqle/enginetest/dolt_harness.go | 30 ++++++++++--------- .../sqle/enginetest/dolt_server_test.go | 8 +++-- .../sqle/enginetest/dolt_server_tests.go | 2 ++ 9 files changed, 48 insertions(+), 27 deletions(-) diff --git a/go/cmd/dolt/commands/init_test.go b/go/cmd/dolt/commands/init_test.go index 50f78693014..ffe8952952d 100644 --- a/go/cmd/dolt/commands/init_test.go +++ b/go/cmd/dolt/commands/init_test.go @@ -67,6 +67,7 @@ func TestInit(t *testing.T) { for _, test := range tests { t.Run(test.Name, func(t *testing.T) { + ctx := context.Background() dEnv := createUninitializedEnv() gCfg, _ := dEnv.Config.GetConfig(env.GlobalConfig) gCfg.SetStrings(test.GlobalConfig) @@ -74,7 +75,7 @@ func TestInit(t *testing.T) { latebind := func(ctx context.Context) (cli.Queryist, *sql.Context, func(), error) { return nil, nil, func() {}, nil } cliCtx, _ := cli.NewCliContext(&apr, dEnv.Config, dEnv.FS, latebind) - result := InitCmd{}.Exec(context.Background(), "dolt init", test.Args, dEnv, cliCtx) + result := InitCmd{}.Exec(ctx, "dolt init", test.Args, dEnv, cliCtx) defer dEnv.DoltDB(ctx).Close() require.Equalf(t, test.ExpectSuccess, result == 0, "- Expected success: %t; result: %t;", test.ExpectSuccess, result == 0) @@ -92,12 +93,13 @@ func TestInit(t *testing.T) { } func TestInitTwice(t *testing.T) { + ctx := context.Background() dEnv := createUninitializedEnv() - result := InitCmd{}.Exec(context.Background(), "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) + result := InitCmd{}.Exec(ctx, "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) require.True(t, result == 0, "First init should succeed") defer dEnv.DoltDB(ctx).Close() - result = InitCmd{}.Exec(context.Background(), "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) + result = InitCmd{}.Exec(ctx, "dolt init", []string{"-name", "Bill Billerson", "-email", "bigbillieb@fake.horse"}, dEnv, nil) require.True(t, result != 0, "Second init should fail") } diff --git a/go/cmd/dolt/commands/log_test.go b/go/cmd/dolt/commands/log_test.go index 93da82e83de..d3fa7cf957a 100644 --- a/go/cmd/dolt/commands/log_test.go +++ b/go/cmd/dolt/commands/log_test.go @@ -32,8 +32,9 @@ import ( ) func TestLog(t *testing.T) { + ctx := context.Background() dEnv := createUninitializedEnv() - err := dEnv.InitRepo(context.Background(), types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) + err := dEnv.InitRepo(ctx, types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) defer dEnv.DoltDB(ctx).Close() if err != nil { @@ -53,8 +54,9 @@ func TestLogSigterm(t *testing.T) { t.Skip("Skipping test as function used is not supported on Windows") } + ctx := context.Background() dEnv := createUninitializedEnv() - err := dEnv.InitRepo(context.Background(), types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) + err := dEnv.InitRepo(ctx, types.Format_Default, "Bill Billerson", "bigbillieb@fake.horse", env.DefaultInitBranch) defer dEnv.DoltDB(ctx).Close() if err != nil { diff --git a/go/cmd/dolt/commands/sql_test.go b/go/cmd/dolt/commands/sql_test.go index 619b0940230..925fcc289a6 100644 --- a/go/cmd/dolt/commands/sql_test.go +++ b/go/cmd/dolt/commands/sql_test.go @@ -608,6 +608,7 @@ func TestDelete(t *testing.T) { } func TestCommitHooksNoErrors(t *testing.T) { + ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() diff --git a/go/cmd/dolt/commands/sqlserver/server_test.go b/go/cmd/dolt/commands/sqlserver/server_test.go index 99c289dcda4..8e0e4ef32cf 100644 --- a/go/cmd/dolt/commands/sqlserver/server_test.go +++ b/go/cmd/dolt/commands/sqlserver/server_test.go @@ -65,6 +65,7 @@ var ( ) func TestServerArgs(t *testing.T) { + ctx := context.Background() controller := svcs.NewController() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) @@ -110,6 +111,7 @@ listener: read_timeout_millis: 5000 write_timeout_millis: 5000 ` + ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { @@ -135,6 +137,7 @@ listener: } func TestServerBadArgs(t *testing.T) { + ctx := context.Background() env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { @@ -164,6 +167,7 @@ func TestServerBadArgs(t *testing.T) { } func TestServerGoodParams(t *testing.T) { + ctx := context.Background() env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { @@ -206,6 +210,7 @@ func TestServerGoodParams(t *testing.T) { } func TestServerSelect(t *testing.T) { + ctx := context.Background() env, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { @@ -263,6 +268,7 @@ func TestServerSelect(t *testing.T) { // If a port is already in use, throw error "Port XXXX already in use." func TestServerFailsIfPortInUse(t *testing.T) { + ctx := context.Background() controller := svcs.NewController() server := &http.Server{ Addr: ":15200", @@ -305,6 +311,7 @@ type defaultBranchTest struct { } func TestServerSetDefaultBranch(t *testing.T) { + ctx := context.Background() dEnv, err := sqle.CreateEnvWithSeedData() require.NoError(t, err) defer func() { @@ -498,7 +505,7 @@ func TestReadReplica(t *testing.T) { require.NoError(t, err) sess := conn.NewSession(nil) - multiSetup.NewBranch(sourceDbName, "feature") + multiSetup.NewBranch(ctx, sourceDbName, "feature") multiSetup.CheckoutBranch(sourceDbName, "feature") multiSetup.PushToRemote(sourceDbName, "remote1", "feature") diff --git a/go/libraries/doltcore/dtestutils/testcommands/multienv.go b/go/libraries/doltcore/dtestutils/testcommands/multienv.go index 80b437dd8ab..b452a0dd5b2 100644 --- a/go/libraries/doltcore/dtestutils/testcommands/multienv.go +++ b/go/libraries/doltcore/dtestutils/testcommands/multienv.go @@ -92,7 +92,7 @@ func (mr *MultiRepoTestSetup) homeProv() (string, error) { } func (mr *MultiRepoTestSetup) Close() { - for _, db := range mr.DoltDB(ctx)s { + for _, db := range mr.DoltDBs { err := db.Close() if err != nil { mr.Errhand(err) @@ -138,7 +138,7 @@ func (mr *MultiRepoTestSetup) NewDB(dbName string) { dEnv = env.Load(context.Background(), mr.homeProv, filesys.LocalFS, doltdb.LocalDirDoltDB, "test") mr.envs[dbName] = dEnv - mr.DoltDB(ctx)s[dbName] = ddb + mr.DoltDBs[dbName] = ddb mr.DbNames = append(mr.DbNames, dbName) mr.DbPaths[dbName] = repo } @@ -158,7 +158,7 @@ func (mr *MultiRepoTestSetup) NewRemote(remoteName string) { mr.Remotes[remoteName] = rem } -func (mr *MultiRepoTestSetup) NewBranch(dbName, branchName string) { +func (mr *MultiRepoTestSetup) NewBranch(ctx context.Context, dbName, branchName string) { dEnv := mr.envs[dbName] err := actions.CreateBranchWithStartPt(context.Background(), dEnv.DbData(ctx), branchName, "head", false, nil) if err != nil { @@ -214,7 +214,7 @@ func (mr *MultiRepoTestSetup) CloneDB(fromRemote, dbName string) { ddb := dEnv.DoltDB(ctx) mr.envs[dbName] = dEnv - mr.DoltDB(ctx)s[dbName] = ddb + mr.DoltDBs[dbName] = ddb mr.DbNames = append(mr.DbNames, dbName) mr.DbPaths[dbName] = cloneDir } @@ -228,7 +228,7 @@ func (mr *MultiRepoTestSetup) GetRemote(remoteName string) env.Remote { } func (mr *MultiRepoTestSetup) GetDB(dbName string) *doltdb.DoltDB { - db, ok := mr.DoltDB(ctx)s[dbName] + db, ok := mr.DoltDBs[dbName] if !ok { mr.Errhand("db not found") } diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go index c8ab0df10aa..ac958a8084e 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go @@ -1619,6 +1619,7 @@ func TestNullRanges(t *testing.T) { } func TestPersist(t *testing.T) { + ctx := context.Background() harness := newDoltHarness(t) defer harness.Close() dEnv := dtestutils.CreateTestEnv() diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go index c52ace36488..6f9f5ac67c0 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go @@ -232,9 +232,10 @@ func commitScripts(dbs []string) []setup.SetupScript { func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { initializeEngine := d.engine == nil if initializeEngine { + // We can't use enginetest.NewContext(d) until d's session is set d.branchControl = branch_control.CreateDefaultController(context.Background()) - pro := d.newProvider() + pro := d.newProvider(context.Background()) if d.setupTestProcedures { pro = d.newProviderWithProcedures() } @@ -256,8 +257,8 @@ func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { e.Analyzer.ExecBuilder = rowexec.NewOverrideBuilder(kvexec.Builder{}) d.engine = e - ctx := enginetest.NewContext(d) - databases := pro.AllDatabases(ctx) + sqlCtx := enginetest.NewContext(d) + databases := pro.AllDatabases(sqlCtx) d.setupDbs = make(map[string]struct{}) var dbs []string for _, db := range databases { @@ -267,7 +268,7 @@ func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { } if !d.skipSetupCommit { - e, err = enginetest.RunSetupScripts(ctx, e, commitScripts(dbs), d.SupportsNativeIndexCreation()) + e, err = enginetest.RunSetupScripts(sqlCtx, e, commitScripts(dbs), d.SupportsNativeIndexCreation()) if err != nil { return nil, err } @@ -281,8 +282,8 @@ func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { bThreads := sql.NewBackgroundThreads() e = e.WithBackgroundThreads(bThreads) - dSess := dsess.DSessFromSess(ctx.Session) - dbCache := dSess.DatabaseCache(ctx) + dSess := dsess.DSessFromSess(sqlCtx.Session) + dbCache := dSess.DatabaseCache(sqlCtx) dsessDbs := make([]dsess.SqlDatabase, len(dbs)) for i, dbName := range dbs { @@ -293,12 +294,12 @@ func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { sess := d.newSessionWithClient(sql.Client{Address: "localhost", User: "root"}) return sql.NewContext(context.Background(), sql.WithSession(sess)), nil } - if err = statsProv.Configure(ctx, ctxFact, bThreads, dsessDbs); err != nil { + if err = statsProv.Configure(sqlCtx, ctxFact, bThreads, dsessDbs); err != nil { return nil, err } statsOnlyQueries := filterStatsOnlyQueries(d.setupData) - e, err = enginetest.RunSetupScripts(ctx, e, statsOnlyQueries, d.SupportsNativeIndexCreation()) + e, err = enginetest.RunSetupScripts(sqlCtx, e, statsOnlyQueries, d.SupportsNativeIndexCreation()) } return e, nil @@ -310,8 +311,8 @@ func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { d.engine.Analyzer.Catalog.StatsProvider = statspro.NewProvider(d.provider.(*sqle.DoltDatabaseProvider), statsnoms.NewNomsStatsFactory(d.multiRepoEnv.RemoteDialProvider())) var err error - ctx := enginetest.NewContext(d) - e, err := enginetest.RunSetupScripts(ctx, d.engine, d.resetScripts(), d.SupportsNativeIndexCreation()) + sqlCtx := enginetest.NewContext(d) + e, err := enginetest.RunSetupScripts(sqlCtx, d.engine, d.resetScripts(), d.SupportsNativeIndexCreation()) // Get a fresh session after running setup scripts, since some setup scripts can change the session state d.session, err = dsess.NewDoltSession(enginetest.NewBaseSession(), d.provider, d.multiRepoEnv.Config(), d.branchControl, d.statsPro, writer.NewWriteSession) @@ -415,13 +416,14 @@ func (d *DoltHarness) SupportsKeylessTables() bool { } func (d *DoltHarness) NewDatabases(names ...string) []sql.Database { + ctx := enginetest.NewContext(d) d.closeProvider() d.engine = nil d.provider = nil d.branchControl = branch_control.CreateDefaultController(context.Background()) - pro := d.newProvider() + pro := d.newProvider(ctx) doltProvider, ok := pro.(*sqle.DoltDatabaseProvider) require.True(d.t, ok) d.provider = doltProvider @@ -443,7 +445,6 @@ func (d *DoltHarness) NewDatabases(names ...string) []sql.Database { require.NoError(d.t, err) } - ctx := enginetest.NewContext(d) databases := pro.AllDatabases(ctx) // It's important that we return the databases in the same order as the names argument @@ -510,7 +511,7 @@ func (d *DoltHarness) closeProvider() { } } -func (d *DoltHarness) newProvider() sql.MutableDatabaseProvider { +func (d *DoltHarness) newProvider(ctx context.Context) sql.MutableDatabaseProvider { d.closeProvider() var dEnv *env.DoltEnv @@ -536,7 +537,8 @@ func (d *DoltHarness) newProvider() sql.MutableDatabaseProvider { } func (d *DoltHarness) newProviderWithProcedures() sql.MutableDatabaseProvider { - pro := d.newProvider() + ctx := enginetest.NewContext(d) + pro := d.newProvider(ctx) provider, ok := pro.(*sqle.DoltDatabaseProvider) require.True(d.t, ok) for _, esp := range memory.ExternalStoredProcedures { diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go b/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go index e4e8f15bf95..35354423f7f 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_server_test.go @@ -15,6 +15,7 @@ package enginetest import ( + "context" "runtime" "strings" "testing" @@ -51,7 +52,9 @@ func TestDoltServerRunningUnixSocket(t *testing.T) { // Running unix socket server dEnv, sc, serverConfig := startServer(t, false, "", defaultUnixSocketPath) - sc.WaitForStart() + ctx := context.Background() + err := sc.WaitForStart() + require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() require.True(t, strings.Contains(servercfg.ConnectionString(serverConfig, "dolt"), "unix")) @@ -99,7 +102,8 @@ func TestDoltServerRunningUnixSocket(t *testing.T) { // Running TCP socket server dEnv, tcpSc, tcpServerConfig := startServer(t, true, "0.0.0.0", "") - tcpSc.WaitForStart() + err = tcpSc.WaitForStart() + require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() require.False(t, strings.Contains(servercfg.ConnectionString(tcpServerConfig, "dolt"), "unix")) diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go b/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go index 7d3ba1afdb8..497737b89f8 100755 --- a/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_server_tests.go @@ -477,6 +477,7 @@ var PersistVariableTests = []queries.ScriptTest{ // stopping the server in between scripts. Unlike other script test executors, scripts may influence later scripts in // the block. func testSerialSessionScriptTests(t *testing.T, tests []queries.ScriptTest) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() serverConfig := sqlserver.DefaultCommandLineServerConfig() rand.Seed(time.Now().UnixNano()) @@ -626,6 +627,7 @@ func assertResultsEqual(t *testing.T, expected []sql.Row, rows *gosql.Rows) { func testMultiSessionScriptTests(t *testing.T, tests []queries.ScriptTest) { for _, test := range tests { t.Run(test.Name, func(t *testing.T) { + ctx := context.Background() dEnv, sc, serverConfig := startServer(t, true, "", "") err := sc.WaitForStart() require.NoError(t, err) From e540affc2578ffe8447ef103d30ab78af97dc89e Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Fri, 24 Jan 2025 14:19:57 -0800 Subject: [PATCH 13/17] Add context variable to tests. --- .../env/actions/commitwalk/commitwalk_test.go | 5 ++- .../doltcore/env/actions/infer_schema_test.go | 1 + go/libraries/doltcore/env/environment.go | 8 +--- go/libraries/doltcore/env/environment_test.go | 2 + go/libraries/doltcore/env/multi_repo_env.go | 4 +- .../doltcore/merge/schema_integration_test.go | 5 +-- .../doltcore/merge/schema_merge_test.go | 8 ++-- .../doltcore/migrate/integration_test.go | 14 +++---- go/libraries/doltcore/mvdata/data_loc_test.go | 1 + .../sqle/dtables/query_catalog_table_test.go | 2 +- .../doltcore/sqle/enginetest/dolt_harness.go | 11 +++--- .../index/mergeable_indexes_setup_test.go | 1 + .../database_revision_test.go | 10 ++--- .../integration_test/history_table_test.go | 1 + .../sqle/integration_test/stockmarket_test.go | 15 ++++++-- .../doltcore/sqle/kvexec/count_agg_test.go | 15 ++++---- .../doltcore/sqle/kvexec/lookup_join_test.go | 15 ++++---- .../sqle/logictest/dolt/doltharness.go | 11 +++--- .../sqle/logictest/dolt/doltharness_test.go | 1 + .../doltcore/sqle/procedures_table_test.go | 37 ++++++++++--------- .../doltcore/sqle/replication_test.go | 1 + .../doltcore/sqle/schema_table_test.go | 34 +++++++++-------- go/libraries/doltcore/sqle/sqlddl_test.go | 8 ++-- go/libraries/doltcore/sqle/sqldelete_test.go | 1 + go/libraries/doltcore/sqle/sqlinsert_test.go | 7 ++-- go/libraries/doltcore/sqle/sqlpersist_test.go | 7 ++-- go/libraries/doltcore/sqle/sqlreplace_test.go | 5 ++- go/libraries/doltcore/sqle/sqlselect_test.go | 5 ++- go/libraries/doltcore/sqle/sqlupdate_test.go | 7 ++-- .../doltcore/sqle/table_editor_fk_test.go | 33 ++++++++++------- .../doltcore/sqle/table_editor_index_test.go | 8 ++-- go/libraries/doltcore/sqle/views_test.go | 2 +- .../sqle/writer/noms_table_writer_test.go | 17 +++++---- 33 files changed, 168 insertions(+), 134 deletions(-) diff --git a/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go b/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go index 6217e20b03d..a03cf9fe366 100644 --- a/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go +++ b/go/libraries/doltcore/env/actions/commitwalk/commitwalk_test.go @@ -62,6 +62,7 @@ func createUninitializedEnv() *env.DoltEnv { } func TestGetDotDotRevisions(t *testing.T) { + ctx := context.Background() dEnv := createUninitializedEnv() err := dEnv.InitRepo(context.Background(), types.Format_Default, "Bill Billerson", "bill@billerson.com", env.DefaultInitBranch) require.NoError(t, err) @@ -188,7 +189,7 @@ func TestGetDotDotRevisions(t *testing.T) { assertEqualHashes(t, featureCommits[1], res[3]) // Create a similar branch to "feature" on a forked repository and GetDotDotRevisions using that as well. - forkEnv := mustForkDB(t, dEnv.DoltDB(ctx), "feature", featureCommits[4]) + forkEnv := mustForkDB(ctx, t, dEnv.DoltDB(ctx), "feature", featureCommits[4]) // Create 3 commits on feature branch. for i := 5; i < 8; i++ { @@ -275,7 +276,7 @@ func mustCreateCommit(t *testing.T, ddb *doltdb.DoltDB, bn string, rvh hash.Hash return commit } -func mustForkDB(t *testing.T, fromDB *doltdb.DoltDB, bn string, cm *doltdb.Commit) *env.DoltEnv { +func mustForkDB(ctx context.Context, t *testing.T, fromDB *doltdb.DoltDB, bn string, cm *doltdb.Commit) *env.DoltEnv { h, err := cm.HashOf() require.NoError(t, err) forkEnv := createUninitializedEnv() diff --git a/go/libraries/doltcore/env/actions/infer_schema_test.go b/go/libraries/doltcore/env/actions/infer_schema_test.go index e80d7849329..0fcd644682f 100644 --- a/go/libraries/doltcore/env/actions/infer_schema_test.go +++ b/go/libraries/doltcore/env/actions/infer_schema_test.go @@ -450,6 +450,7 @@ func TestInferSchema(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index e3a7837fcfb..e024026ea0e 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -180,7 +180,7 @@ func (dEnv *DoltEnv) ReloadRepoState() error { } // LoadWithoutDB creates a DoltEnv without eagerly loading the DB. -// If urlStr is non-empty, then the DB can be loaded later by calling DoltEnv.ReloadDB. +// If urlStr is non-empty, then the DB can be loaded later by calling LoadDoltDB. func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { cfg, cfgErr := LoadDoltCliConfig(hdp, fs) @@ -201,12 +201,8 @@ func LoadWithoutDB(_ context.Context, hdp HomeDirProvider, fs filesys.Filesys, u // Load loads the DoltEnv for the .dolt directory determined by resolving the specified urlStr with the specified Filesys. func Load(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr string, version string) *DoltEnv { dEnv := LoadWithoutDB(ctx, hdp, fs, urlStr, version) - dEnv.ReloadDB(ctx) - return dEnv -} - -func (dEnv *DoltEnv) ReloadDB(ctx context.Context) { LoadDoltDB(ctx, dEnv.FS, dEnv.urlStr, dEnv) + return dEnv } func LoadDoltDB(ctx context.Context, fs filesys.Filesys, urlStr string, dEnv *DoltEnv) { diff --git a/go/libraries/doltcore/env/environment_test.go b/go/libraries/doltcore/env/environment_test.go index 8ce4aba8ce1..b03a53fdbad 100644 --- a/go/libraries/doltcore/env/environment_test.go +++ b/go/libraries/doltcore/env/environment_test.go @@ -145,6 +145,7 @@ func TestRepoDirNoLocal(t *testing.T) { } func TestInitRepo(t *testing.T) { + ctx := context.Background() dEnv, _ := createTestEnv(false, false) err := dEnv.InitRepo(context.Background(), types.Format_Default, "aoeu aoeu", "aoeu@aoeu.org", DefaultInitBranch) require.NoError(t, err) @@ -168,6 +169,7 @@ func TestMigrateWorkingSet(t *testing.T) { homeDir, err := os.MkdirTemp("", "TestMigrateWorkingSet*") require.NoError(t, err) + ctx := context.Background() dEnv := createFileTestEnv(t, working, homeDir) assert.NoError(t, dEnv.CfgLoadErr) diff --git a/go/libraries/doltcore/env/multi_repo_env.go b/go/libraries/doltcore/env/multi_repo_env.go index fef0ee42074..4110db26370 100644 --- a/go/libraries/doltcore/env/multi_repo_env.go +++ b/go/libraries/doltcore/env/multi_repo_env.go @@ -230,7 +230,9 @@ func (mrEnv *MultiRepoEnv) ReloadDBs( for _, namedEnv := range mrEnv.envs { dEnv := namedEnv.env - dEnv.ReloadDB(ctx) + if dEnv.doltDB == nil { + LoadDoltDB(ctx, dEnv.FS, dEnv.urlStr, dEnv) + } if !dEnv.Valid() { dbErr := dEnv.DBLoadError if dbErr != nil { diff --git a/go/libraries/doltcore/merge/schema_integration_test.go b/go/libraries/doltcore/merge/schema_integration_test.go index 38ddd904391..2b06b872648 100644 --- a/go/libraries/doltcore/merge/schema_integration_test.go +++ b/go/libraries/doltcore/merge/schema_integration_test.go @@ -591,8 +591,8 @@ func testMergeSchemas(t *testing.T, test mergeSchemaTest) { } func testMergeSchemasWithConflicts(t *testing.T, test mergeSchemaConflictTest) { + ctx := context.Background() getSchema := func(t *testing.T, dEnv *env.DoltEnv) schema.Schema { - ctx := context.Background() wr, err := dEnv.WorkingRoot(ctx) assert.NoError(t, err) tbl, ok, err := wr.GetTable(ctx, doltdb.TableName{Name: "test"}) @@ -605,7 +605,6 @@ func testMergeSchemasWithConflicts(t *testing.T, test mergeSchemaConflictTest) { dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() for _, c := range setupCommon { exit := c.exec(t, ctx, dEnv) require.Equal(t, 0, exit) @@ -664,9 +663,9 @@ func testMergeSchemasWithConflicts(t *testing.T, test mergeSchemaConflictTest) { } func testMergeForeignKeys(t *testing.T, test mergeForeignKeyTest) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() for _, c := range setupForeignKeyTests { exit := c.exec(t, ctx, dEnv) require.Equal(t, 0, exit) diff --git a/go/libraries/doltcore/merge/schema_merge_test.go b/go/libraries/doltcore/merge/schema_merge_test.go index e4738680fbb..3f9820bacb9 100644 --- a/go/libraries/doltcore/merge/schema_merge_test.go +++ b/go/libraries/doltcore/merge/schema_merge_test.go @@ -1631,9 +1631,9 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool t.Run(test.name, func(t *testing.T) { runTest := func(t *testing.T, test schemaMergeTest, expectDataConflict bool, expConstraintViolations []constraintViolation) { - a, l, r, m := setupSchemaMergeTest(t, test) - ctx := context.Background() + a, l, r, m := setupSchemaMergeTest(ctx, t, test) + var mo merge.MergeOpts var eo editor.Options eo = eo.WithDeaf(editor.NewInMemDeaf(a.VRW())) @@ -1785,7 +1785,7 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool } } -func setupSchemaMergeTest(t *testing.T, test schemaMergeTest) (anc, left, right, merged doltdb.RootValue) { +func setupSchemaMergeTest(ctx context.Context, t *testing.T, test schemaMergeTest) (anc, left, right, merged doltdb.RootValue) { denv := dtestutils.CreateTestEnv() var eo editor.Options eo = eo.WithDeaf(editor.NewInMemDeaf(denv.DoltDB(ctx).ValueReadWriter())) @@ -1827,10 +1827,10 @@ func tbl(ns namedSchema, rows ...sql.Row) *table { } func sch(definition string) namedSchema { + ctx := context.Background() denv := dtestutils.CreateTestEnv() vrw := denv.DoltDB(ctx).ValueReadWriter() ns := denv.DoltDB(ctx).NodeStore() - ctx := context.Background() root, _ := doltdb.EmptyRootValue(ctx, vrw, ns) eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, denv) sqlCtx, _ := eng.NewDefaultContext(ctx) diff --git a/go/libraries/doltcore/migrate/integration_test.go b/go/libraries/doltcore/migrate/integration_test.go index 4443d5f3c37..19224bf3bc7 100644 --- a/go/libraries/doltcore/migrate/integration_test.go +++ b/go/libraries/doltcore/migrate/integration_test.go @@ -212,13 +212,13 @@ func SetupHookRefKeys(ctx context.Context, dEnv *env.DoltEnv) (*env.DoltEnv, err func runMigration(t *testing.T, ctx context.Context, preEnv *env.DoltEnv) (postEnv *env.DoltEnv) { ddb, err := initTestMigrationDB(ctx) require.NoError(t, err) - postEnv = &env.DoltEnv{ - Version: preEnv.Version, - Config: preEnv.Config, - RepoState: preEnv.RepoState, - FS: preEnv.FS, - doltDB: ddb, - } + postEnv = env.NewDoltEnv( + preEnv.Version, + preEnv.Config, + preEnv.RepoState, + ddb, + preEnv.FS, + ) err = migrate.TraverseDAG(ctx, migrate.Environment{}, preEnv.DoltDB(ctx), postEnv.DoltDB(ctx)) assert.NoError(t, err) diff --git a/go/libraries/doltcore/mvdata/data_loc_test.go b/go/libraries/doltcore/mvdata/data_loc_test.go index 55041069acf..90f3b7b2c65 100644 --- a/go/libraries/doltcore/mvdata/data_loc_test.go +++ b/go/libraries/doltcore/mvdata/data_loc_test.go @@ -194,6 +194,7 @@ func TestCreateRdWr(t *testing.T) { //{NewDataLocation("file.nbf", ""), reflect.TypeOf((*nbf.NBFReader)(nil)).Elem(), reflect.TypeOf((*nbf.NBFWriter)(nil)).Elem()}, } + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(context.Background()) diff --git a/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go b/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go index 5cb4e5cce4f..c7f3ae1d43e 100644 --- a/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go +++ b/go/libraries/doltcore/sqle/dtables/query_catalog_table_test.go @@ -29,10 +29,10 @@ import ( ) func TestInsertIntoQueryCatalogTable(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) _, ok, err := root.GetTable(ctx, doltdb.TableName{Name: doltdb.DoltQueryCatalogTableName}) diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go index 6f9f5ac67c0..962e25b9040 100644 --- a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go +++ b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go @@ -232,12 +232,12 @@ func commitScripts(dbs []string) []setup.SetupScript { func (d *DoltHarness) NewEngine(t *testing.T) (enginetest.QueryEngine, error) { initializeEngine := d.engine == nil if initializeEngine { - // We can't use enginetest.NewContext(d) until d's session is set - d.branchControl = branch_control.CreateDefaultController(context.Background()) + ctx := context.Background() + d.branchControl = branch_control.CreateDefaultController(ctx) - pro := d.newProvider(context.Background()) + pro := d.newProvider(ctx) if d.setupTestProcedures { - pro = d.newProviderWithProcedures() + pro = d.newProviderWithProcedures(ctx) } doltProvider, ok := pro.(*sqle.DoltDatabaseProvider) require.True(t, ok) @@ -536,8 +536,7 @@ func (d *DoltHarness) newProvider(ctx context.Context) sql.MutableDatabaseProvid return pro } -func (d *DoltHarness) newProviderWithProcedures() sql.MutableDatabaseProvider { - ctx := enginetest.NewContext(d) +func (d *DoltHarness) newProviderWithProcedures(ctx context.Context) sql.MutableDatabaseProvider { pro := d.newProvider(ctx) provider, ok := pro.(*sqle.DoltDatabaseProvider) require.True(d.t, ok) diff --git a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go index 3a438fd13a0..3b3eeeb4a68 100644 --- a/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go +++ b/go/libraries/doltcore/sqle/index/mergeable_indexes_setup_test.go @@ -35,6 +35,7 @@ import ( ) func setupIndexes(t *testing.T, tableName, insertQuery string) (*sqle.Engine, *sql.Context, []*indexTuple) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) diff --git a/go/libraries/doltcore/sqle/integration_test/database_revision_test.go b/go/libraries/doltcore/sqle/integration_test/database_revision_test.go index be02bfdf27a..33ac30fd534 100644 --- a/go/libraries/doltcore/sqle/integration_test/database_revision_test.go +++ b/go/libraries/doltcore/sqle/integration_test/database_revision_test.go @@ -163,14 +163,14 @@ func TestDbRevision(t *testing.T) { root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) - cm1, cm2, cm3 = populateCommitHashes(t, dEnv, root) + cm1, cm2, cm3 = populateCommitHashes(ctx, t, dEnv, root) require.NotEqual(t, cm1, hash.Hash{}) require.NotEqual(t, cm2, hash.Hash{}) require.NotEqual(t, cm3, hash.Hash{}) for _, a := range test.asserts { t.Run(a.query, func(t *testing.T) { - makeTestAssertion(t, a, dEnv, root) + makeTestAssertion(ctx, t, a, dEnv, root) }) } for _, a2 := range test.asserts2 { @@ -179,14 +179,14 @@ func TestDbRevision(t *testing.T) { rows: a2.rows, } t.Run(a.query, func(t *testing.T) { - makeTestAssertion(t, a, dEnv, root) + makeTestAssertion(ctx, t, a, dEnv, root) }) } }) } } -func populateCommitHashes(t *testing.T, dEnv *env.DoltEnv, root doltdb.RootValue) (cm1, cm2, cm3 hash.Hash) { +func populateCommitHashes(ctx context.Context, t *testing.T, dEnv *env.DoltEnv, root doltdb.RootValue) (cm1, cm2, cm3 hash.Hash) { q := "SELECT commit_hash FROM dolt_log;" rows, err := sqle.ExecuteSelect(ctx, dEnv, root, q) require.NoError(t, err) @@ -197,7 +197,7 @@ func populateCommitHashes(t *testing.T, dEnv *env.DoltEnv, root doltdb.RootValue return } -func makeTestAssertion(t *testing.T, a testAssert, dEnv *env.DoltEnv, root doltdb.RootValue) { +func makeTestAssertion(ctx context.Context, t *testing.T, a testAssert, dEnv *env.DoltEnv, root doltdb.RootValue) { actRows, err := sqle.ExecuteSelect(ctx, dEnv, root, a.query) require.NoError(t, err) assert.Equal(t, a.rows, actRows) diff --git a/go/libraries/doltcore/sqle/integration_test/history_table_test.go b/go/libraries/doltcore/sqle/integration_test/history_table_test.go index 08ca7160024..e4c422467c8 100644 --- a/go/libraries/doltcore/sqle/integration_test/history_table_test.go +++ b/go/libraries/doltcore/sqle/integration_test/history_table_test.go @@ -32,6 +32,7 @@ import ( func TestHistoryTable(t *testing.T) { SkipByDefaultInCI(t) + ctx := context.Background() dEnv := setupHistoryTests(t) defer dEnv.DoltDB(ctx).Close() for _, test := range historyTableTests() { diff --git a/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go b/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go index 0f7574d4460..cd7eeffe7df 100644 --- a/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go +++ b/go/libraries/doltcore/sqle/integration_test/stockmarket_test.go @@ -20126,10 +20126,12 @@ INSERT INTO join_result VALUES ('stock','ZYNE','us','2017-11-01',9.7,9.93,9.41,9 ` func TestCreateTables(t *testing.T) { + ctx := context.Background() + SkipByDefaultInCI(t) + dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error @@ -20149,10 +20151,12 @@ func TestInserts(t *testing.T) { if types.Format_Default != types.Format_LD_1 { t.Skip() // todo: convert to enginetests } + + ctx := context.Background() + SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error @@ -20179,10 +20183,12 @@ func TestInsertsWithIndexes(t *testing.T) { if types.Format_Default != types.Format_LD_1 { t.Skip() // todo: convert to enginetests } + + ctx := context.Background() + SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error @@ -20215,10 +20221,11 @@ func TestInsertsWithIndexes(t *testing.T) { } func TestJoin(t *testing.T) { + ctx := context.Background() + SkipByDefaultInCI(t) dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error diff --git a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go index d974628a773..d802a11c2e1 100644 --- a/go/libraries/doltcore/sqle/kvexec/count_agg_test.go +++ b/go/libraries/doltcore/sqle/kvexec/count_agg_test.go @@ -91,6 +91,7 @@ func TestCountAgg(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() @@ -101,29 +102,29 @@ func TestCountAgg(t *testing.T) { db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) + engine, sqlCtx, err := sqle.NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) - err = ctx.Session.SetSessionVariable(ctx, sql.AutoCommitSessionVar, false) + err = sqlCtx.Session.SetSessionVariable(sqlCtx, sql.AutoCommitSessionVar, false) require.NoError(t, err) for _, q := range tt.setup { - _, iter, _, err := engine.Query(ctx, q) + _, iter, _, err := engine.Query(sqlCtx, q) require.NoError(t, err) - _, err = sql.RowIterToRows(ctx, iter) + _, err = sql.RowIterToRows(sqlCtx, iter) require.NoError(t, err) } - binder := planbuilder.New(ctx, engine.EngineAnalyzer().Catalog, engine.EngineEventScheduler(), engine.Parser) + binder := planbuilder.New(sqlCtx, engine.EngineAnalyzer().Catalog, engine.EngineEventScheduler(), engine.Parser) node, _, _, qFlags, err := binder.Parse(tt.query, nil, false) require.NoError(t, err) - node, err = engine.EngineAnalyzer().Analyze(ctx, node, nil, qFlags) + node, err = engine.EngineAnalyzer().Analyze(sqlCtx, node, nil, qFlags) require.NoError(t, err) j := getAgg(node) require.NotNil(t, j) - iter, err := Builder{}.Build(ctx, j, nil) + iter, err := Builder{}.Build(sqlCtx, j, nil) _, ok := iter.(*countAggKvIter) require.Equalf(t, tt.doRowexec, ok, "expected do row exec: %t", tt.doRowexec) }) diff --git a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go index 8dd2d900e83..fc252486bdf 100644 --- a/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go +++ b/go/libraries/doltcore/sqle/kvexec/lookup_join_test.go @@ -149,6 +149,7 @@ func TestLookupJoin(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() @@ -159,29 +160,29 @@ func TestLookupJoin(t *testing.T) { db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) + engine, sqlCtx, err := sqle.NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) - err = ctx.Session.SetSessionVariable(ctx, sql.AutoCommitSessionVar, false) + err = sqlCtx.Session.SetSessionVariable(sqlCtx, sql.AutoCommitSessionVar, false) require.NoError(t, err) for _, q := range tt.setup { - _, iter, _, err := engine.Query(ctx, q) + _, iter, _, err := engine.Query(sqlCtx, q) require.NoError(t, err) - _, err = sql.RowIterToRows(ctx, iter) + _, err = sql.RowIterToRows(sqlCtx, iter) require.NoError(t, err) } - binder := planbuilder.New(ctx, engine.EngineAnalyzer().Catalog, engine.EventScheduler, engine.Parser) + binder := planbuilder.New(sqlCtx, engine.EngineAnalyzer().Catalog, engine.EventScheduler, engine.Parser) node, _, _, qFlags, err := binder.Parse(tt.join, nil, false) require.NoError(t, err) - node, err = engine.EngineAnalyzer().Analyze(ctx, node, nil, qFlags) + node, err = engine.EngineAnalyzer().Analyze(sqlCtx, node, nil, qFlags) require.NoError(t, err) j := getJoin(node) require.NotNil(t, j) - iter, err := Builder{}.Build(ctx, j, nil) + iter, err := Builder{}.Build(sqlCtx, j, nil) _, ok := iter.(*lookupJoinKvIter) require.Equalf(t, tt.doRowexec, ok, "expected do row exec: %t", tt.doRowexec) }) diff --git a/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go b/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go index 74d72b14e86..1e13e154402 100644 --- a/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go +++ b/go/libraries/doltcore/sqle/logictest/dolt/doltharness.go @@ -123,6 +123,7 @@ func (h *DoltHarness) GetTimeout() int64 { } func innerInit(h *DoltHarness, dEnv *env.DoltEnv) error { + ctx := context.Background() if !dEnv.HasDoltDir() { err := dEnv.InitRepoWithTime(context.Background(), types.Format_Default, name, email, env.DefaultInitBranch, time.Now()) if err != nil { @@ -137,16 +138,16 @@ func innerInit(h *DoltHarness, dEnv *env.DoltEnv) error { var err error var pro dsess.DoltDatabaseProvider - h.engine, pro, err = sqlNewEngine(dEnv) + h.engine, pro, err = sqlNewEngine(ctx, dEnv) if err != nil { return err } - ctx := dsql.NewTestSQLCtxWithProvider(context.Background(), pro, statspro.NewProvider(pro.(*dsql.DoltDatabaseProvider), statsnoms.NewNomsStatsFactory(env.NewGRPCDialProviderFromDoltEnv(dEnv)))) - h.sess = ctx.Session.(*dsess.DoltSession) + sqlCtx := dsql.NewTestSQLCtxWithProvider(ctx, pro, statspro.NewProvider(pro.(*dsql.DoltDatabaseProvider), statsnoms.NewNomsStatsFactory(env.NewGRPCDialProviderFromDoltEnv(dEnv)))) + h.sess = sqlCtx.Session.(*dsess.DoltSession) - dbs := h.engine.Analyzer.Catalog.AllDatabases(ctx) + dbs := h.engine.Analyzer.Catalog.AllDatabases(sqlCtx) var dbName string for _, db := range dbs { dsqlDB, ok := db.(dsql.Database) @@ -282,7 +283,7 @@ func schemaToSchemaString(sch sql.Schema) (string, error) { return b.String(), nil } -func sqlNewEngine(dEnv *env.DoltEnv) (*sqle.Engine, dsess.DoltDatabaseProvider, error) { +func sqlNewEngine(ctx context.Context, dEnv *env.DoltEnv) (*sqle.Engine, dsess.DoltDatabaseProvider, error) { tmpDir, err := dEnv.TempTableFilesDir() if err != nil { return nil, nil, err diff --git a/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go b/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go index 857a0165f3b..37e91244110 100644 --- a/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go +++ b/go/libraries/doltcore/sqle/logictest/dolt/doltharness_test.go @@ -99,6 +99,7 @@ func TestDoltHarness(t *testing.T) { } fs := filesys.NewInMemFS([]string{}, nil, tmp) + ctx := context.Background() dEnv := createTestEnvWithFS(fs, wd) defer dEnv.DoltDB(ctx).Close() diff --git a/go/libraries/doltcore/sqle/procedures_table_test.go b/go/libraries/doltcore/sqle/procedures_table_test.go index d21a64a6664..cf11d3010f0 100644 --- a/go/libraries/doltcore/sqle/procedures_table_test.go +++ b/go/libraries/doltcore/sqle/procedures_table_test.go @@ -34,6 +34,7 @@ import ( // Tests the codepath for migrating the dolt_procedures system table from an older schema // to the latest schema func TestProceduresMigration(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) @@ -41,15 +42,15 @@ func TestProceduresMigration(t *testing.T) { timestamp := time.Now().Truncate(time.Minute).UTC() - ctx, db := newDatabaseWithProcedures(t, dEnv, opts, timestamp) + sqlCtx, db := newDatabaseWithProcedures(ctx, t, dEnv, opts, timestamp) t.Run("test migration logic", func(t *testing.T) { // Call the logic to migrate it to the latest schema - tbl, err := DoltProceduresGetTable(ctx, *db) + tbl, err := DoltProceduresGetTable(sqlCtx, *db) require.NoError(t, err) // Assert that the data was migrated correctly - rows := readAllRows(ctx, t, tbl) + rows := readAllRows(sqlCtx, t, tbl) expectedRows := []sql.Row{ {"proc1", "create procedure proc1() SELECT 42 as pk from dual;", timestamp, timestamp, nil}, {"proc2", "create procedure proc2() SELECT 'HELLO' as greeting from dual;", timestamp, timestamp, nil}, @@ -59,12 +60,12 @@ func TestProceduresMigration(t *testing.T) { t.Run("test that fetching stored procedure triggers the migration logic", func(t *testing.T) { // Call the logic to migrate it to the latest schema - _, found, err := db.GetStoredProcedure(ctx, "proc1") + _, found, err := db.GetStoredProcedure(sqlCtx, "proc1") require.NoError(t, err) require.True(t, found) // Assert that the data was migrated correctly - tbl, found, err := db.GetTableInsensitive(ctx, doltdb.ProceduresTableName) + tbl, found, err := db.GetTableInsensitive(sqlCtx, doltdb.ProceduresTableName) require.NoError(t, err) require.True(t, found) @@ -72,7 +73,7 @@ func TestProceduresMigration(t *testing.T) { require.True(t, ok) require.NotNil(t, wrapper.backingTable) - rows := readAllRows(ctx, t, wrapper.backingTable) + rows := readAllRows(sqlCtx, t, wrapper.backingTable) expectedRows := []sql.Row{ {"proc1", "create procedure proc1() SELECT 42 as pk from dual;", timestamp, timestamp, nil}, {"proc2", "create procedure proc2() SELECT 'HELLO' as greeting from dual;", timestamp, timestamp, nil}, @@ -89,11 +90,11 @@ func TestProceduresMigration(t *testing.T) { ModifiedAt: timestamp, SqlMode: "NO_ENGINE_SUBSTITUTION", } - err := db.SaveStoredProcedure(ctx, proc3) + err := db.SaveStoredProcedure(sqlCtx, proc3) require.NoError(t, err) // Assert that the data was migrated correctly - tbl, found, err := db.GetTableInsensitive(ctx, doltdb.ProceduresTableName) + tbl, found, err := db.GetTableInsensitive(sqlCtx, doltdb.ProceduresTableName) require.NoError(t, err) require.True(t, found) @@ -101,7 +102,7 @@ func TestProceduresMigration(t *testing.T) { require.True(t, ok) require.NotNil(t, wrapper.backingTable) - rows := readAllRows(ctx, t, wrapper.backingTable) + rows := readAllRows(sqlCtx, t, wrapper.backingTable) expectedRows := []sql.Row{ {"proc1", "create procedure proc1() SELECT 42 as pk from dual;", timestamp, timestamp, nil}, {"proc2", "create procedure proc2() SELECT 'HELLO' as greeting from dual;", timestamp, timestamp, nil}, @@ -112,15 +113,15 @@ func TestProceduresMigration(t *testing.T) { } -func newDatabaseWithProcedures(t *testing.T, dEnv *env.DoltEnv, opts editor.Options, timestamp time.Time) (*sql.Context, *Database) { +func newDatabaseWithProcedures(ctx context.Context, t *testing.T, dEnv *env.DoltEnv, opts editor.Options, timestamp time.Time) (*sql.Context, *Database) { db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - _, ctx, err := NewTestEngine(dEnv, context.Background(), db) + _, sqlCtx, err := NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) // Create the dolt_procedures table with its original schema - err = db.createSqlTable(ctx, doltdb.ProceduresTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ + err = db.createSqlTable(sqlCtx, doltdb.ProceduresTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ {Name: doltdb.ProceduresTableNameCol, Type: gmstypes.Text, Source: doltdb.ProceduresTableName, PrimaryKey: true}, {Name: doltdb.ProceduresTableCreateStmtCol, Type: gmstypes.Text, Source: doltdb.ProceduresTableName, PrimaryKey: false}, {Name: doltdb.ProceduresTableCreatedAtCol, Type: gmstypes.Timestamp, Source: doltdb.ProceduresTableName, PrimaryKey: false}, @@ -128,7 +129,7 @@ func newDatabaseWithProcedures(t *testing.T, dEnv *env.DoltEnv, opts editor.Opti }), sql.Collation_Default, "") require.NoError(t, err) - sqlTbl, found, err := db.GetTableInsensitive(ctx, doltdb.ProceduresTableName) + sqlTbl, found, err := db.GetTableInsensitive(sqlCtx, doltdb.ProceduresTableName) require.NoError(t, err) require.True(t, found) @@ -137,12 +138,12 @@ func newDatabaseWithProcedures(t *testing.T, dEnv *env.DoltEnv, opts editor.Opti require.NotNil(t, wrapper.backingTable) // Insert some test data for procedures - inserter := wrapper.backingTable.Inserter(ctx) - require.NoError(t, inserter.Insert(ctx, sql.Row{"proc1", "create procedure proc1() SELECT 42 as pk from dual;", timestamp, timestamp})) - require.NoError(t, inserter.Insert(ctx, sql.Row{"proc2", "create procedure proc2() SELECT 'HELLO' as greeting from dual;", timestamp, timestamp})) - require.NoError(t, inserter.Close(ctx)) + inserter := wrapper.backingTable.Inserter(sqlCtx) + require.NoError(t, inserter.Insert(sqlCtx, sql.Row{"proc1", "create procedure proc1() SELECT 42 as pk from dual;", timestamp, timestamp})) + require.NoError(t, inserter.Insert(sqlCtx, sql.Row{"proc2", "create procedure proc2() SELECT 'HELLO' as greeting from dual;", timestamp, timestamp})) + require.NoError(t, inserter.Close(sqlCtx)) - return ctx, &db + return sqlCtx, &db } func readAllRows(ctx *sql.Context, t *testing.T, tbl *WritableDoltTable) []sql.Row { diff --git a/go/libraries/doltcore/sqle/replication_test.go b/go/libraries/doltcore/sqle/replication_test.go index 600361ff451..d1782cc3e8e 100644 --- a/go/libraries/doltcore/sqle/replication_test.go +++ b/go/libraries/doltcore/sqle/replication_test.go @@ -29,6 +29,7 @@ import ( ) func TestCommitHooksNoErrors(t *testing.T) { + ctx := context.Background() dEnv, err := CreateEnvWithSeedData() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() diff --git a/go/libraries/doltcore/sqle/schema_table_test.go b/go/libraries/doltcore/sqle/schema_table_test.go index c44e98deb14..16abb743da7 100644 --- a/go/libraries/doltcore/sqle/schema_table_test.go +++ b/go/libraries/doltcore/sqle/schema_table_test.go @@ -30,6 +30,7 @@ import ( ) func TestAncientSchemaTableMigration(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) @@ -37,17 +38,17 @@ func TestAncientSchemaTableMigration(t *testing.T) { db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - _, ctx, err := NewTestEngine(dEnv, context.Background(), db) + _, sqlCtx, err := NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) - err = db.createSqlTable(ctx, doltdb.SchemasTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ // original schema of dolt_schemas table + err = db.createSqlTable(sqlCtx, doltdb.SchemasTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ // original schema of dolt_schemas table {Name: doltdb.SchemasTablesTypeCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: true}, {Name: doltdb.SchemasTablesNameCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: true}, {Name: doltdb.SchemasTablesFragmentCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: false}, }), sql.Collation_Default, "") require.NoError(t, err) - sqlTbl, found, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName) + sqlTbl, found, err := db.GetTableInsensitive(sqlCtx, doltdb.SchemasTableName) require.NoError(t, err) require.True(t, found) @@ -57,23 +58,23 @@ func TestAncientSchemaTableMigration(t *testing.T) { // unmodified dolt_schemas table. require.Equal(t, 3, len(wrapper.backingTable.Schema())) - inserter := wrapper.backingTable.Inserter(ctx) - err = inserter.Insert(ctx, sql.Row{"view", "view1", "SELECT v1 FROM test;"}) + inserter := wrapper.backingTable.Inserter(sqlCtx) + err = inserter.Insert(sqlCtx, sql.Row{"view", "view1", "SELECT v1 FROM test;"}) require.NoError(t, err) - err = inserter.Insert(ctx, sql.Row{"view", "view2", "SELECT v2 FROM test;"}) + err = inserter.Insert(sqlCtx, sql.Row{"view", "view2", "SELECT v2 FROM test;"}) require.NoError(t, err) - err = inserter.Close(ctx) + err = inserter.Close(sqlCtx) require.NoError(t, err) - tbl, err := getOrCreateDoltSchemasTable(ctx, db) // removes the old table and recreates it with the new schema + tbl, err := getOrCreateDoltSchemasTable(sqlCtx, db) // removes the old table and recreates it with the new schema require.NoError(t, err) - iter, err := SqlTableToRowIter(ctx, tbl.DoltTable, nil) + iter, err := SqlTableToRowIter(sqlCtx, tbl.DoltTable, nil) require.NoError(t, err) var rows []sql.Row for { - row, err := iter.Next(ctx) + row, err := iter.Next(sqlCtx) if err == io.EOF { break } @@ -82,7 +83,7 @@ func TestAncientSchemaTableMigration(t *testing.T) { rows = append(rows, row) } - require.NoError(t, iter.Close(ctx)) + require.NoError(t, iter.Close(sqlCtx)) expectedRows := []sql.Row{ {"view", "view1", "SELECT v1 FROM test;", nil, nil}, {"view", "view2", "SELECT v2 FROM test;", nil, nil}, @@ -91,6 +92,7 @@ func TestAncientSchemaTableMigration(t *testing.T) { } func TestV1SchemasTable(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() tmpDir, err := dEnv.TempTableFilesDir() require.NoError(t, err) @@ -98,10 +100,10 @@ func TestV1SchemasTable(t *testing.T) { db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - _, ctx, err := NewTestEngine(dEnv, context.Background(), db) + _, sqlCtx, err := NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) - err = db.createSqlTable(ctx, doltdb.SchemasTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ // original schema of dolt_schemas table + err = db.createSqlTable(sqlCtx, doltdb.SchemasTableName, "", sql.NewPrimaryKeySchema(sql.Schema{ // original schema of dolt_schemas table {Name: doltdb.SchemasTablesTypeCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: true}, {Name: doltdb.SchemasTablesNameCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: true}, {Name: doltdb.SchemasTablesFragmentCol, Type: gmstypes.Text, Source: doltdb.SchemasTableName, PrimaryKey: false}, @@ -109,7 +111,7 @@ func TestV1SchemasTable(t *testing.T) { }), sql.Collation_Default, "") require.NoError(t, err) - tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName) + tbl, _, err := db.GetTableInsensitive(sqlCtx, doltdb.SchemasTableName) require.NoError(t, err) wrapper, ok := tbl.(*SchemaTable) @@ -119,14 +121,14 @@ func TestV1SchemasTable(t *testing.T) { // unmodified dolt_schemas table. require.Equal(t, 4, len(wrapper.backingTable.Schema())) - tbl, err = getOrCreateDoltSchemasTable(ctx, db) + tbl, err = getOrCreateDoltSchemasTable(sqlCtx, db) require.NoError(t, err) require.NotNil(t, tbl) // modified dolt_schemas table. require.Equal(t, 5, len(tbl.Schema())) - tbl, _, err = db.GetTableInsensitive(ctx, doltdb.SchemasTableName) + tbl, _, err = db.GetTableInsensitive(sqlCtx, doltdb.SchemasTableName) require.NoError(t, err) wrapper, ok = tbl.(*SchemaTable) require.True(t, ok) diff --git a/go/libraries/doltcore/sqle/sqlddl_test.go b/go/libraries/doltcore/sqle/sqlddl_test.go index 7ec12066717..4d0b3c92887 100644 --- a/go/libraries/doltcore/sqle/sqlddl_test.go +++ b/go/libraries/doltcore/sqle/sqlddl_test.go @@ -636,11 +636,11 @@ func TestRenameColumn(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) updatedRoot, err := ExecuteSql(ctx, dEnv, root, tt.query) @@ -752,11 +752,11 @@ func TestRenameTableStatements(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, err := dEnv.WorkingRoot(ctx) require.NoError(t, err) @@ -809,6 +809,7 @@ func TestAlterSystemTables(t *testing.T) { systemTableNames := []string{"dolt_log", "dolt_history_people", "dolt_diff_people", "dolt_commit_diff_people", "dolt_schemas"} reservedTableNames := []string{"dolt_query_catalog", "dolt_docs", "dolt_procedures", "dolt_ignore"} + ctx := context.Background() var dEnv *env.DoltEnv var err error setup := func() { @@ -1074,9 +1075,9 @@ func TestParseCreateTableStatement(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) //eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, dEnv) eng, sqlCtx := newTestEngine(ctx, dEnv) @@ -1345,6 +1346,7 @@ func TestDropIndex(t *testing.T) { } func TestCreateIndexUnique(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() root, err := dEnv.WorkingRoot(context.Background()) diff --git a/go/libraries/doltcore/sqle/sqldelete_test.go b/go/libraries/doltcore/sqle/sqldelete_test.go index 715cedcd7fe..5212bbd635e 100644 --- a/go/libraries/doltcore/sqle/sqldelete_test.go +++ b/go/libraries/doltcore/sqle/sqldelete_test.go @@ -225,6 +225,7 @@ func testDeleteQuery(t *testing.T, test DeleteTest) { t.Skip("Skipping tests until " + singleDeleteQueryTest) } + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() diff --git a/go/libraries/doltcore/sqle/sqlinsert_test.go b/go/libraries/doltcore/sqle/sqlinsert_test.go index d9733b5cc8e..acda98596a2 100644 --- a/go/libraries/doltcore/sqle/sqlinsert_test.go +++ b/go/libraries/doltcore/sqle/sqlinsert_test.go @@ -426,6 +426,7 @@ func testInsertQuery(t *testing.T, test InsertTest) { t.Skip("Skipping test broken on SQL engine") } + ctx := context.Background() dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() @@ -434,8 +435,8 @@ func testInsertQuery(t *testing.T, test InsertTest) { test.AdditionalSetup(t, dEnv) } - root, _ := dEnv.WorkingRoot(context.Background()) - root, err = executeModify(t, context.Background(), dEnv, root, test.InsertQuery) + root, _ := dEnv.WorkingRoot(ctx) + root, err = executeModify(t, ctx, dEnv, root, test.InsertQuery) if len(test.ExpectedErr) > 0 { require.Error(t, err) assert.Contains(t, err.Error(), test.ExpectedErr) @@ -444,7 +445,7 @@ func testInsertQuery(t *testing.T, test InsertTest) { require.NoError(t, err) } - actualRows, sch, err := executeSelect(t, context.Background(), dEnv, root, test.SelectQuery) + actualRows, sch, err := executeSelect(t, ctx, dEnv, root, test.SelectQuery) require.NoError(t, err) assert.Equal(t, test.ExpectedRows, actualRows) diff --git a/go/libraries/doltcore/sqle/sqlpersist_test.go b/go/libraries/doltcore/sqle/sqlpersist_test.go index bb153b8b5ef..3d0ddbf0831 100644 --- a/go/libraries/doltcore/sqle/sqlpersist_test.go +++ b/go/libraries/doltcore/sqle/sqlpersist_test.go @@ -95,6 +95,7 @@ func TestExecutePersist(t *testing.T) { // Tests the given query on a freshly created dataset, asserting that the result has the given schema and rows. If // expectedErr is set, asserts instead that the execution returns an error that matches. func testPersistQuery(t *testing.T, test PersistTest) { + ctx := context.Background() dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() @@ -105,8 +106,8 @@ func testPersistQuery(t *testing.T, test PersistTest) { variables.InitSystemVariables() - root, _ := dEnv.WorkingRoot(context.Background()) - root, err = executeModify(t, context.Background(), dEnv, root, test.PersistQuery) + root, _ := dEnv.WorkingRoot(ctx) + root, err = executeModify(t, ctx, dEnv, root, test.PersistQuery) if len(test.ExpectedErr) > 0 { require.Error(t, err) return @@ -114,7 +115,7 @@ func testPersistQuery(t *testing.T, test PersistTest) { require.NoError(t, err) } - actualRows, _, err := executeSelect(t, context.Background(), dEnv, root, test.SelectQuery) + actualRows, _, err := executeSelect(t, ctx, dEnv, root, test.SelectQuery) require.NoError(t, err) assert.Equal(t, test.ExpectedRows, actualRows) diff --git a/go/libraries/doltcore/sqle/sqlreplace_test.go b/go/libraries/doltcore/sqle/sqlreplace_test.go index 3d30e7cb267..1be0d184c4a 100644 --- a/go/libraries/doltcore/sqle/sqlreplace_test.go +++ b/go/libraries/doltcore/sqle/sqlreplace_test.go @@ -298,6 +298,7 @@ func testReplaceQuery(t *testing.T, test ReplaceTest) { t.Skip("Skipping tests until " + singleReplaceQueryTest) } + ctx := context.Background() dEnv, err := CreateEmptyTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() @@ -306,8 +307,8 @@ func testReplaceQuery(t *testing.T, test ReplaceTest) { test.AdditionalSetup(t, dEnv) } - root, _ := dEnv.WorkingRoot(context.Background()) - root, err = executeModify(t, context.Background(), dEnv, root, test.ReplaceQuery) + root, _ := dEnv.WorkingRoot(ctx) + root, err = executeModify(t, ctx, dEnv, root, test.ReplaceQuery) if len(test.ExpectedErr) > 0 { require.Error(t, err) assert.Contains(t, err.Error(), test.ExpectedErr) diff --git a/go/libraries/doltcore/sqle/sqlselect_test.go b/go/libraries/doltcore/sqle/sqlselect_test.go index 68aef931c5c..04d4606b3a0 100644 --- a/go/libraries/doltcore/sqle/sqlselect_test.go +++ b/go/libraries/doltcore/sqle/sqlselect_test.go @@ -1357,6 +1357,7 @@ func testSelectQuery(t *testing.T, test SelectTest) { cleanup := installTestCommitClock() defer cleanup() + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() @@ -1365,8 +1366,8 @@ func testSelectQuery(t *testing.T, test SelectTest) { test.AdditionalSetup(t, dEnv) } - root, _ := dEnv.WorkingRoot(context.Background()) - actualRows, sch, err := executeSelect(t, context.Background(), dEnv, root, test.Query) + root, _ := dEnv.WorkingRoot(ctx) + actualRows, sch, err := executeSelect(t, ctx, dEnv, root, test.Query) if len(test.ExpectedErr) > 0 { require.Error(t, err) // Too much work to synchronize error messages between the two implementations, so for now we'll just assert that an error occurred. diff --git a/go/libraries/doltcore/sqle/sqlupdate_test.go b/go/libraries/doltcore/sqle/sqlupdate_test.go index ec616da866a..30a06818597 100644 --- a/go/libraries/doltcore/sqle/sqlupdate_test.go +++ b/go/libraries/doltcore/sqle/sqlupdate_test.go @@ -389,6 +389,7 @@ func testUpdateQuery(t *testing.T, test UpdateTest) { t.Skip("Skipping tests until " + singleUpdateQueryTest) } + ctx := context.Background() dEnv, err := CreateTestDatabase() require.NoError(t, err) defer dEnv.DoltDB(ctx).Close() @@ -397,8 +398,8 @@ func testUpdateQuery(t *testing.T, test UpdateTest) { test.AdditionalSetup(t, dEnv) } - root, _ := dEnv.WorkingRoot(context.Background()) - root, err = executeModify(t, context.Background(), dEnv, root, test.UpdateQuery) + root, _ := dEnv.WorkingRoot(ctx) + root, err = executeModify(t, ctx, dEnv, root, test.UpdateQuery) if len(test.ExpectedErr) > 0 { require.Error(t, err) return @@ -406,7 +407,7 @@ func testUpdateQuery(t *testing.T, test UpdateTest) { require.NoError(t, err) } - actualRows, sch, err := executeSelect(t, context.Background(), dEnv, root, test.SelectQuery) + actualRows, sch, err := executeSelect(t, ctx, dEnv, root, test.SelectQuery) require.NoError(t, err) assert.Equal(t, len(test.ExpectedRows), len(actualRows)) diff --git a/go/libraries/doltcore/sqle/table_editor_fk_test.go b/go/libraries/doltcore/sqle/table_editor_fk_test.go index e36a6ae6397..76bf1b6bf61 100644 --- a/go/libraries/doltcore/sqle/table_editor_fk_test.go +++ b/go/libraries/doltcore/sqle/table_editor_fk_test.go @@ -32,9 +32,9 @@ import ( "github.com/dolthub/dolt/go/libraries/doltcore/env" ) -func setupEditorFkTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { +func setupEditorFkTest(ctx context.Context, t *testing.T) (*env.DoltEnv, doltdb.RootValue) { dEnv := dtestutils.CreateTestEnv() - root, err := dEnv.WorkingRoot(context.Background()) + root, err := dEnv.WorkingRoot(ctx) if err != nil { panic(err) } @@ -152,7 +152,8 @@ func TestTableEditorForeignKeyCascade(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` @@ -202,7 +203,8 @@ func TestTableEditorForeignKeySetNull(t *testing.T) { for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` @@ -285,7 +287,8 @@ func TestTableEditorForeignKeyRestrict(t *testing.T) { for _, test := range tests { t.Run(test.setup+test.trigger, func(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, fmt.Sprintf(` @@ -357,7 +360,8 @@ func TestTableEditorForeignKeyViolations(t *testing.T) { for _, test := range tests { t.Run(test.setup+test.trigger, func(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` @@ -379,10 +383,10 @@ ALTER TABLE three ADD FOREIGN KEY (v1, v2) REFERENCES two(v1, v2) ON DELETE CASC } func TestTableEditorSelfReferentialForeignKeyRestrict(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root := initialRoot sequentialTests := []struct { @@ -450,10 +454,10 @@ func TestTableEditorSelfReferentialForeignKeyRestrict(t *testing.T) { } func TestTableEditorSelfReferentialForeignKeyCascade(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root := initialRoot sequentialTests := []struct { @@ -551,10 +555,10 @@ func TestTableEditorSelfReferentialForeignKeyCascade(t *testing.T) { } func TestTableEditorSelfReferentialForeignKeySetNull(t *testing.T) { - dEnv, initialRoot := setupEditorFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root := initialRoot sequentialTests := []struct { @@ -741,7 +745,7 @@ func sortInt64Rows(rows []sql.Row) []sql.Row { return rows } -func setupEditorKeylessFkTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { +func setupEditorKeylessFkTest(ctx context.Context, t *testing.T) (*env.DoltEnv, doltdb.RootValue) { dEnv := dtestutils.CreateTestEnv() root, err := dEnv.WorkingRoot(context.Background()) if err != nil { @@ -863,7 +867,8 @@ func TestTableEditorKeylessFKCascade(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { - dEnv, initialRoot := setupEditorKeylessFkTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorKeylessFkTest(ctx, t) defer dEnv.DoltDB(ctx).Close() testRoot, err := ExecuteSql(ctx, dEnv, initialRoot, ` diff --git a/go/libraries/doltcore/sqle/table_editor_index_test.go b/go/libraries/doltcore/sqle/table_editor_index_test.go index ac06c91fa5e..98b74bd8638 100644 --- a/go/libraries/doltcore/sqle/table_editor_index_test.go +++ b/go/libraries/doltcore/sqle/table_editor_index_test.go @@ -31,7 +31,7 @@ import ( "github.com/dolthub/dolt/go/store/types" ) -func setupEditorIndexTest(t *testing.T) (*env.DoltEnv, doltdb.RootValue) { +func setupEditorIndexTest(ctx context.Context, t *testing.T) (*env.DoltEnv, doltdb.RootValue) { index_dEnv := dtestutils.CreateTestEnv() root, err := index_dEnv.WorkingRoot(context.Background()) require.NoError(t, err) @@ -119,7 +119,8 @@ UPDATE onepk SET pk1 = v1 + pk1 ORDER BY pk1 DESC; for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { - dEnv, initialRoot := setupEditorIndexTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorIndexTest(ctx, t) defer dEnv.DoltDB(ctx).Close() root := initialRoot @@ -282,7 +283,8 @@ UPDATE oneuni SET v1 = v1 + pk1; for _, test := range tests { t.Run(test.sqlStatement, func(t *testing.T) { - dEnv, initialRoot := setupEditorIndexTest(t) + ctx := context.Background() + dEnv, initialRoot := setupEditorIndexTest(ctx, t) defer dEnv.DoltDB(ctx).Close() root := initialRoot diff --git a/go/libraries/doltcore/sqle/views_test.go b/go/libraries/doltcore/sqle/views_test.go index 85f22c940fa..fcc5cd2ab3d 100644 --- a/go/libraries/doltcore/sqle/views_test.go +++ b/go/libraries/doltcore/sqle/views_test.go @@ -27,10 +27,10 @@ import ( // Not an exhaustive test of views -- we rely on bats tests for end-to-end verification. func TestViews(t *testing.T) { + ctx := context.Background() dEnv := dtestutils.CreateTestEnv() defer dEnv.DoltDB(ctx).Close() - ctx := context.Background() root, _ := dEnv.WorkingRoot(ctx) var err error diff --git a/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go b/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go index 1ba3b6542d5..197f6250c21 100644 --- a/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go +++ b/go/libraries/doltcore/sqle/writer/noms_table_writer_test.go @@ -154,6 +154,7 @@ func TestTableEditor(t *testing.T) { for _, test := range testCases { t.Run(test.name, func(t *testing.T) { + ctx := context.Background() dEnv, err := sqle.CreateTestDatabase() require.NoError(t, err) @@ -163,28 +164,28 @@ func TestTableEditor(t *testing.T) { db, err := sqle.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts) require.NoError(t, err) - engine, ctx, err := sqle.NewTestEngine(dEnv, context.Background(), db) + engine, sqlCtx, err := sqle.NewTestEngine(dEnv, context.Background(), db) require.NoError(t, err) - peopleTable, _, err := db.GetTableInsensitive(ctx, "people") + peopleTable, _, err := db.GetTableInsensitive(sqlCtx, "people") require.NoError(t, err) dt := peopleTable.(sql.UpdatableTable) - ed := dt.Updater(ctx).(dsess.TableWriter) + ed := dt.Updater(sqlCtx).(dsess.TableWriter) - test.setup(ctx, t, ed) - require.NoError(t, ed.Close(ctx)) + test.setup(sqlCtx, t, ed) + require.NoError(t, ed.Close(sqlCtx)) - root, err := db.GetRoot(ctx) + root, err := db.GetRoot(sqlCtx) require.NoError(t, err) // TODO: not clear why this is necessary, the call to ed.Close should update the working set already require.NoError(t, dEnv.UpdateWorkingRoot(context.Background(), root)) - _, rowIter, _, err := engine.Query(ctx, test.selectQuery) + _, rowIter, _, err := engine.Query(sqlCtx, test.selectQuery) require.NoError(t, err) - actualRows, err := sql.RowIterToRows(ctx, rowIter) + actualRows, err := sql.RowIterToRows(sqlCtx, rowIter) require.NoError(t, err) assert.Equal(t, test.expectedRows, actualRows) From 8b10e7fc9be9a60d699f27bb76cec15663a1d8e5 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Fri, 24 Jan 2025 20:31:45 -0800 Subject: [PATCH 14/17] Update bats tests to assert that you can't clone directly from another repo. --- .../bats/remotes-file-system.bats | 20 +++++++++++++++++++ integration-tests/bats/replication.bats | 9 --------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/integration-tests/bats/remotes-file-system.bats b/integration-tests/bats/remotes-file-system.bats index c79d9c8a970..295d749f4b9 100644 --- a/integration-tests/bats/remotes-file-system.bats +++ b/integration-tests/bats/remotes-file-system.bats @@ -176,3 +176,23 @@ SQL [ ! -d test-repo ] cd .. } + +@test "remotes-file-system: disallow cloning directly from a repo" { + mkdir repo1 repo2 + cd repo1 + dolt init + cd ../repo2 + run dolt clone file://../repo1/.dolt/noms repo2 + [ "$status" -eq 1 ] + [[ "$output" =~ "cannot create NBS store for directory containing chunk journal" ]] || false +} + +@test "remotes-file-system: disallow cloning directly from a child repo" { + mkdir repo1 + cd repo1 + dolt init + cd .. + run dolt clone file://./repo1/.dolt/noms repo2 + [ "$status" -eq 1 ] + [[ "$output" =~ "cannot create NBS store for directory containing chunk journal" ]] || false +} \ No newline at end of file diff --git a/integration-tests/bats/replication.bats b/integration-tests/bats/replication.bats index d10420ab689..19635db2a25 100644 --- a/integration-tests/bats/replication.bats +++ b/integration-tests/bats/replication.bats @@ -944,15 +944,6 @@ SQL [[ "$output" =~ "t1" ]] || false } -@test "replication: local clone" { - run dolt clone file://./repo1/.dolt/noms repo2 - [ "$status" -eq 0 ] - cd repo2 - run dolt ls - [ "$status" -eq 0 ] - [ "${#lines[@]}" -eq 1 ] -} - @test "replication: commit --amend" { mkdir test_commit_amend_replication_primary dolt init --fun From 9b9722feec50fd7cdd1c28457e41b053c240bd8d Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Mon, 27 Jan 2025 12:22:16 -0800 Subject: [PATCH 15/17] Avoid race conditions when loading dolt DB. --- go/libraries/doltcore/env/environment.go | 79 ++++++++++++------------ 1 file changed, 41 insertions(+), 38 deletions(-) diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index e024026ea0e..010ef99790f 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -21,6 +21,7 @@ import ( "os" "path/filepath" "strings" + "sync" "time" goerrors "gopkg.in/src-d/go-errors.v1" @@ -87,6 +88,7 @@ type DoltEnv struct { RepoState *RepoState RSLoadErr error + loadDBOnce *sync.Once doltDB *doltdb.DoltDB DBLoadError error @@ -206,53 +208,54 @@ func Load(ctx context.Context, hdp HomeDirProvider, fs filesys.Filesys, urlStr s } func LoadDoltDB(ctx context.Context, fs filesys.Filesys, urlStr string, dEnv *DoltEnv) { - ddb, dbLoadErr := doltdb.LoadDoltDB(ctx, types.Format_Default, urlStr, fs) - - dEnv.doltDB = ddb - dEnv.DBLoadError = dbLoadErr - dEnv.urlStr = urlStr + dEnv.loadDBOnce.Do(func() { + ddb, dbLoadErr := doltdb.LoadDoltDB(ctx, types.Format_Default, urlStr, fs) + dEnv.doltDB = ddb + dEnv.DBLoadError = dbLoadErr + dEnv.urlStr = urlStr - if dbLoadErr == nil && dEnv.HasDoltDir() { - if !dEnv.HasDoltTempTableDir() { - tmpDir, err := dEnv.TempTableFilesDir() - if err != nil { - dEnv.DBLoadError = err - } - err = dEnv.FS.MkDirs(tmpDir) - dEnv.DBLoadError = err - } else { - // fire and forget cleanup routine. Will delete as many old temp files as it can during the main commands execution. - // The process will not wait for this to finish so this may not always complete. - go func() { - // TODO dEnv.HasDoltTempTableDir() true but dEnv.TempTableFileDir() panics - tmpTableDir, err := dEnv.FS.Abs(filepath.Join(dEnv.urlStr, dbfactory.DoltDir, tempTablesDir)) + if dbLoadErr == nil && dEnv.HasDoltDir() { + if !dEnv.HasDoltTempTableDir() { + tmpDir, err := dEnv.TempTableFilesDir() if err != nil { - return + dEnv.DBLoadError = err } - _ = fs.Iter(tmpTableDir, true, func(path string, size int64, isDir bool) (stop bool) { - if !isDir { - lm, exists := fs.LastModified(path) + err = dEnv.FS.MkDirs(tmpDir) + dEnv.DBLoadError = err + } else { + // fire and forget cleanup routine. Will delete as many old temp files as it can during the main commands execution. + // The process will not wait for this to finish so this may not always complete. + go func() { + // TODO dEnv.HasDoltTempTableDir() true but dEnv.TempTableFileDir() panics + tmpTableDir, err := dEnv.FS.Abs(filepath.Join(dEnv.urlStr, dbfactory.DoltDir, tempTablesDir)) + if err != nil { + return + } + _ = fs.Iter(tmpTableDir, true, func(path string, size int64, isDir bool) (stop bool) { + if !isDir { + lm, exists := fs.LastModified(path) - if exists && time.Now().Sub(lm) > (time.Hour*24) { - _ = fs.DeleteFile(path) + if exists && time.Now().Sub(lm) > (time.Hour*24) { + _ = fs.DeleteFile(path) + } } - } - return false - }) - }() + return false + }) + }() + } } - } - if dEnv.RSLoadErr == nil && dbLoadErr == nil { - // If the working set isn't present in the DB, create it from the repo state. This step can be removed post 1.0. - _, err := dEnv.WorkingSet(ctx) - if errors.Is(err, doltdb.ErrWorkingSetNotFound) { - _ = dEnv.initWorkingSetFromRepoState(ctx) - } else if err != nil { - dEnv.RSLoadErr = err + if dEnv.RSLoadErr == nil && dbLoadErr == nil { + // If the working set isn't present in the DB, create it from the repo state. This step can be removed post 1.0. + _, err := dEnv.WorkingSet(ctx) + if errors.Is(err, doltdb.ErrWorkingSetNotFound) { + _ = dEnv.initWorkingSetFromRepoState(ctx) + } else if err != nil { + dEnv.RSLoadErr = err + } } - } + }) } func GetDefaultInitBranch(cfg config.ReadableConfig) string { From d27b998aaf1e6241a8dc9a73b05c682e9239ebd6 Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Wed, 29 Jan 2025 11:31:15 -0800 Subject: [PATCH 16/17] prevent nil panic on DoltEnv::loadDBOnce --- go/libraries/doltcore/env/environment.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go/libraries/doltcore/env/environment.go b/go/libraries/doltcore/env/environment.go index 010ef99790f..5cda6857d69 100644 --- a/go/libraries/doltcore/env/environment.go +++ b/go/libraries/doltcore/env/environment.go @@ -88,7 +88,7 @@ type DoltEnv struct { RepoState *RepoState RSLoadErr error - loadDBOnce *sync.Once + loadDBOnce sync.Once doltDB *doltdb.DoltDB DBLoadError error From 3d5d419cef33f1f8034c42018ba3a064d1e2463a Mon Sep 17 00:00:00 2001 From: Nick Tobey Date: Mon, 3 Feb 2025 12:13:49 -0800 Subject: [PATCH 17/17] Update tag_test.go --- go/libraries/doltcore/env/actions/tag_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/go/libraries/doltcore/env/actions/tag_test.go b/go/libraries/doltcore/env/actions/tag_test.go index 6ad86189abb..0a82ff6c31d 100644 --- a/go/libraries/doltcore/env/actions/tag_test.go +++ b/go/libraries/doltcore/env/actions/tag_test.go @@ -68,7 +68,7 @@ func TestVisitResolvedTag(t *testing.T) { // Visit the tag and verify its properties var foundTag *doltdb.Tag - err = VisitResolvedTag(ctx, dEnv.DoltDB, tagName, func(tag *doltdb.Tag) error { + err = VisitResolvedTag(ctx, dEnv.DoltDB(ctx), tagName, func(tag *doltdb.Tag) error { foundTag = tag return nil }) @@ -78,7 +78,7 @@ func TestVisitResolvedTag(t *testing.T) { require.Equal(t, tagMsg, foundTag.Meta.Description) // Test visiting non-existent tag - err = VisitResolvedTag(ctx, dEnv.DoltDB, "non-existent-tag", func(tag *doltdb.Tag) error { + err = VisitResolvedTag(ctx, dEnv.DoltDB(ctx), "non-existent-tag", func(tag *doltdb.Tag) error { return nil }) require.Equal(t, doltdb.ErrTagNotFound, err) @@ -113,7 +113,7 @@ func TestIterResolvedTagsPaginated(t *testing.T) { // Test first page var foundTags []string - pageToken, err := IterResolvedTagsPaginated(ctx, dEnv.DoltDB, "", func(tag *doltdb.Tag) (bool, error) { + pageToken, err := IterResolvedTagsPaginated(ctx, dEnv.DoltDB(ctx), "", func(tag *doltdb.Tag) (bool, error) { foundTags = append(foundTags, tag.Name) return false, nil }) @@ -124,7 +124,7 @@ func TestIterResolvedTagsPaginated(t *testing.T) { // Test second page var secondPageTags []string - nextPageToken, err := IterResolvedTagsPaginated(ctx, dEnv.DoltDB, pageToken, func(tag *doltdb.Tag) (bool, error) { + nextPageToken, err := IterResolvedTagsPaginated(ctx, dEnv.DoltDB(ctx), pageToken, func(tag *doltdb.Tag) (bool, error) { secondPageTags = append(secondPageTags, tag.Name) return false, nil }) @@ -141,7 +141,7 @@ func TestIterResolvedTagsPaginated(t *testing.T) { // Test early termination var earlyTermTags []string - _, err = IterResolvedTagsPaginated(ctx, dEnv.DoltDB, "", func(tag *doltdb.Tag) (bool, error) { + _, err = IterResolvedTagsPaginated(ctx, dEnv.DoltDB(ctx), "", func(tag *doltdb.Tag) (bool, error) { earlyTermTags = append(earlyTermTags, tag.Name) return true, nil // Stop after first tag })