Update Go tests to use CliContext with an SqlEngine

go/cmd/dolt/commands/sql_test.go

@@ -43,19 +43,22 @@ import (
 
 var tableName = "people"
 
-var stubCliCtx = BuildEmptyCliContext()
-
 // Smoke test: Console opens and exits
 func TestSqlConsole(t *testing.T) {
 	t.Run("SQL console opens and exits", func(t *testing.T) {
+		ctx := context.TODO()
+
 		dEnv, err := sqle.CreateEnvWithSeedData()
 		require.NoError(t, err)
 		defer dEnv.DoltDB.Close()
 
+		cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+		require.NoError(t, err)
+
 		args := []string{}
 		commandStr := "dolt sql"
 
-		result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+		result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 		assert.Equal(t, 0, result)
 	})
 
@@ -76,14 +79,19 @@ func TestSqlBatchMode(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
+
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-b", "-q", test.query}
 
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -115,14 +123,18 @@ func TestSqlSelect(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -141,14 +153,18 @@ func TestSqlShow(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -171,6 +187,8 @@ func TestCreateTable(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
+
 			dEnv := dtestutils.CreateTestEnv()
 			defer dEnv.DoltDB.Close()
 			working, err := dEnv.WorkingRoot(context.Background())
@@ -179,9 +197,12 @@ func TestCreateTable(t *testing.T) {
 			assert.NoError(t, err)
 			assert.False(t, has, "table exists before creating it")
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 
 			working, err = dEnv.WorkingRoot(context.Background())
@@ -215,13 +236,17 @@ func TestShowTables(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -246,13 +271,18 @@ func TestAlterTable(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
+
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -273,13 +303,17 @@ func TestDropTable(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.TODO()
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(context.TODO(), commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 		})
 	}
@@ -395,10 +429,13 @@ func TestInsert(t *testing.T) {
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 
 			if result == 0 {
@@ -476,10 +513,13 @@ func TestUpdate(t *testing.T) {
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 
 			if result == 0 {
@@ -546,15 +586,18 @@ func TestDelete(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.query, func(t *testing.T) {
+			ctx := context.Background()
 			dEnv, err := sqle.CreateEnvWithSeedData()
 			require.NoError(t, err)
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, err := NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
+
 			args := []string{"-q", test.query}
 
-			ctx := context.Background()
 			commandStr := "dolt sql"
-			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, stubCliCtx)
+			result := SqlCmd{}.Exec(ctx, commandStr, args, dEnv, cliCtx)
 			assert.Equal(t, test.expectedRes, result)
 
 			if result == 0 {

go/cmd/dolt/commands/utils.go

@@ -16,6 +16,7 @@ package commands
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
@@ -75,9 +76,22 @@ func MaybeGetCommitWithVErr(dEnv *env.DoltEnv, maybeCommit string) (*doltdb.Comm
 	return cm, nil
 }
 
+// NewArgFreeCliContext creates a new CliContext instance with no arguments using a local SqlEngine. This is useful for testing primarily
+func NewArgFreeCliContext(ctx context.Context, dEnv *env.DoltEnv) (cli.CliContext, errhand.VerboseError) {
+	lateBind, err := BuildSqlEngineQueryist(ctx, dEnv, argparser.NewEmptyResults())
+	if err != nil {
+		return nil, err
+	}
+	return cli.NewCliContext(argparser.NewEmptyResults(), lateBind)
+}
+
 // BuildSqlEngineQueryist Utility function to build a local SQLEngine for use interacting with data on disk using
-// SQL queries.
+// SQL queries. ctx and dEnv must be non-nil. apr can be nil.
 func BuildSqlEngineQueryist(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgParseResults) (cli.LateBindQueryist, errhand.VerboseError) {
+	if ctx == nil || dEnv == nil || apr == nil {
+		errhand.VerboseErrorFromError(fmt.Errorf("Invariant violated. Nil argument provided to BuildSqlEngineQueryist"))
+	}
+
 	// Retrieve username and password from command line, if provided
 	username := DefaultUser
 	if user, ok := apr.GetValue(UserFlag); ok {

go/libraries/doltcore/doltdb/feature_version_test.go

@@ -58,7 +58,10 @@ func (cmd fvCommand) exec(ctx context.Context, dEnv *env.DoltEnv) int {
 	// execute the command using |cmd.user|'s Feature Version
 	doltdb.DoltFeatureVersion = cmd.user.vers
 	defer func() { doltdb.DoltFeatureVersion = DoltFeatureVersionCopy }()
-	return cmd.cmd.Exec(ctx, cmd.cmd.Name(), cmd.args, dEnv, commands.BuildEmptyCliContext())
+
+	cliCtx, _ := commands.NewArgFreeCliContext(ctx, dEnv)
+
+	return cmd.cmd.Exec(ctx, cmd.cmd.Name(), cmd.args, dEnv, cliCtx)
 }
 
 type fvUser struct {

go/libraries/doltcore/doltdb/foreign_key_test.go

@@ -37,8 +37,6 @@ func TestForeignKeys(t *testing.T) {
 	}
 }
 
-var fkCliCtx = commands.BuildEmptyCliContext()
-
 func TestForeignKeyErrors(t *testing.T) {
 	skipNewFormat(t)
 	cmds := []testCommand{
@@ -49,15 +47,17 @@ func TestForeignKeyErrors(t *testing.T) {
 
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
+	cliCtx, err := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, err)
 
 	for _, c := range cmds {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, fkCliCtx)
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 
-	exitCode := commands.SqlCmd{}.Exec(ctx, commands.SqlCmd{}.Name(), []string{"-q", `ALTER TABLE test MODIFY v1 INT;`}, dEnv, fkCliCtx)
+	exitCode := commands.SqlCmd{}.Exec(ctx, commands.SqlCmd{}.Name(), []string{"-q", `ALTER TABLE test MODIFY v1 INT;`}, dEnv, cliCtx)
 	require.Equal(t, 1, exitCode)
-	exitCode = commands.SqlCmd{}.Exec(ctx, commands.SqlCmd{}.Name(), []string{"-q", `ALTER TABLE test2 MODIFY v1 INT;`}, dEnv, fkCliCtx)
+	exitCode = commands.SqlCmd{}.Exec(ctx, commands.SqlCmd{}.Name(), []string{"-q", `ALTER TABLE test2 MODIFY v1 INT;`}, dEnv, cliCtx)
 
 	require.Equal(t, 1, exitCode)
 }
@@ -98,12 +98,15 @@ func testForeignKeys(t *testing.T, test foreignKeyTest) {
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
 
+	cliCtx, verr := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
+
 	for _, c := range fkSetupCommon {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, fkCliCtx)
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 	for _, c := range test.setup {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, fkCliCtx)
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 

go/libraries/doltcore/doltdb/gc_test.go

@@ -55,8 +55,6 @@ type gcTest struct {
 	postGCFunc func(ctx context.Context, t *testing.T, ddb *doltdb.DoltDB, prevRes interface{})
 }
 
-var gcCliCtx = commands.BuildEmptyCliContext()
-
 var gcTests = []gcTest{
 	{
 		name: "gc test",
@@ -114,8 +112,11 @@ func testGarbageCollection(t *testing.T, test gcTest) {
 	dEnv := dtestutils.CreateTestEnv()
 	defer dEnv.DoltDB.Close()
 
+	cliCtx, verr := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
+
 	for _, c := range gcSetupCommon {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, gcCliCtx)
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 
@@ -123,7 +124,7 @@ func testGarbageCollection(t *testing.T, test gcTest) {
 	for _, stage := range test.stages {
 		res = stage.preStageFunc(ctx, t, dEnv.DoltDB, res)
 		for _, c := range stage.commands {
-			exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, gcCliCtx)
+			exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 			require.Equal(t, 0, exitCode)
 		}
 	}

go/libraries/doltcore/merge/keyless_integration_test.go

@@ -114,9 +114,11 @@ func TestKeylessMerge(t *testing.T) {
 			require.NoError(t, err)
 			err = dEnv.UpdateWorkingRoot(ctx, root)
 			require.NoError(t, err)
+			cliCtx, err := cmd.NewArgFreeCliContext(ctx, dEnv)
+			require.NoError(t, err)
 
 			for _, c := range test.setup {
-				exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+				exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 				require.Equal(t, 0, exitCode)
 			}
 
@@ -247,9 +249,11 @@ func TestKeylessMergeConflicts(t *testing.T) {
 		require.NoError(t, err)
 		err = dEnv.UpdateWorkingRoot(ctx, root)
 		require.NoError(t, err)
+		cliCtx, err := cmd.NewArgFreeCliContext(ctx, dEnv)
+		require.NoError(t, err)
 
 		for _, c := range cc {
-			exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+			exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 			// allow merge to fail with conflicts
 			if _, ok := c.cmd.(cmd.MergeCmd); !ok {
 				require.Equal(t, 0, exitCode)

go/libraries/doltcore/merge/schema_integration_test.go

@@ -40,7 +40,9 @@ type testCommand struct {
 }
 
 func (tc testCommand) exec(t *testing.T, ctx context.Context, dEnv *env.DoltEnv) int {
-	return tc.cmd.Exec(ctx, tc.cmd.Name(), tc.args, dEnv, commands.BuildEmptyCliContext())
+	cliCtx, err := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, err)
+	return tc.cmd.Exec(ctx, tc.cmd.Name(), tc.args, dEnv, cliCtx)
 }
 
 type args []string

go/libraries/doltcore/migrate/integration_test.go

@@ -170,10 +170,12 @@ func setupMigrationTest(t *testing.T, ctx context.Context, test migrationTest) *
 		dEnv, err = test.hook(ctx, dEnv)
 		require.NoError(t, err)
 	}
+	cliCtx, err := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, err)
 
 	cmd := commands.SqlCmd{}
 	for _, query := range test.setup {
-		code := cmd.Exec(ctx, cmd.Name(), []string{"-q", query}, dEnv, commands.BuildEmptyCliContext())
+		code := cmd.Exec(ctx, cmd.Name(), []string{"-q", query}, dEnv, cliCtx)
 		require.Equal(t, 0, code)
 	}
 	return dEnv

go/libraries/doltcore/rebase/filter_branch_test.go

@@ -55,8 +55,6 @@ type testAssertion struct {
 	rows  []sql.Row
 }
 
-var cliCtx = cmd.BuildEmptyCliContext()
-
 var setupCommon = []testCommand{
 	{cmd.SqlCmd{}, args{"-q",
 		`create table test (
@@ -204,6 +202,9 @@ func filterBranchTests() []filterBranchTest {
 func setupFilterBranchTests(t *testing.T) *env.DoltEnv {
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
+	cliCtx, err := cmd.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, err)
+
 	for _, c := range setupCommon {
 		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
@@ -216,6 +217,9 @@ func testFilterBranch(t *testing.T, test filterBranchTest) {
 	ctx := context.Background()
 	dEnv := setupFilterBranchTests(t)
 	defer dEnv.DoltDB.Close()
+	cliCtx, err := cmd.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, err)
+
 	for _, c := range test.setup {
 		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)

go/libraries/doltcore/schema/integration_test.go

@@ -176,8 +176,11 @@ func TestGetKeyTags(t *testing.T) {
 func runTestSql(t *testing.T, ctx context.Context, setup []string) (*doltdb.DoltDB, *doltdb.RootValue) {
 	dEnv := dtestutils.CreateTestEnv()
 	cmd := commands.SqlCmd{}
+	cliCtx, verr := commands.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
+
 	for _, query := range setup {
-		code := cmd.Exec(ctx, cmd.Name(), []string{"-q", query}, dEnv, commands.BuildEmptyCliContext())
+		code := cmd.Exec(ctx, cmd.Name(), []string{"-q", query}, dEnv, cliCtx)
 		require.Equal(t, 0, code)
 	}
 	root, err := dEnv.WorkingRoot(ctx)

go/libraries/doltcore/sqle/integration_test/database_revision_test.go

@@ -152,9 +152,11 @@ func TestDbRevision(t *testing.T) {
 			dEnv := dtestutils.CreateTestEnv()
 			defer dEnv.DoltDB.Close()
 
+			cliCtx, _ := cmd.NewArgFreeCliContext(ctx, dEnv)
+
 			setup := append(setupCommon, test.setup...)
 			for _, c := range setup {
-				exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+				exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 				require.Equal(t, 0, exitCode)
 			}
 

go/libraries/doltcore/sqle/integration_test/history_table_test.go

@@ -212,8 +212,11 @@ var INIT = ""   // HEAD~4
 func setupHistoryTests(t *testing.T) *env.DoltEnv {
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
+	cliCtx, verr := cmd.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
+
 	for _, c := range setupCommon {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 
@@ -236,8 +239,11 @@ func setupHistoryTests(t *testing.T) *env.DoltEnv {
 
 func testHistoryTable(t *testing.T, test historyTableTest, dEnv *env.DoltEnv) {
 	ctx := context.Background()
+	cliCtx, verr := cmd.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
+
 	for _, c := range test.setup {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 

go/libraries/doltcore/sqle/integration_test/json_value_test.go

@@ -126,10 +126,12 @@ func TestJsonValues(t *testing.T) {
 func testJsonValue(t *testing.T, test jsonValueTest, setupCommon []testCommand) {
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
+	cliCtx, verr := cmd.NewArgFreeCliContext(ctx, dEnv)
+	require.NoError(t, verr)
 
 	setup := append(setupCommon, test.setup...)
 	for _, c := range setup {
-		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cmd.BuildEmptyCliContext())
+		exitCode := c.cmd.Exec(ctx, c.cmd.Name(), c.args, dEnv, cliCtx)
 		require.Equal(t, 0, exitCode)
 	}
 

go/libraries/utils/argparser/results.go

@@ -50,6 +50,11 @@ func (res *ArgParseResults) Equals(other *ArgParseResults) bool {
 	return true
 }
 
+// NewEmptyResults creates a new ArgParseResults object with no arguments or options. Mostly useful for testing.
+func NewEmptyResults() *ArgParseResults {
+	return &ArgParseResults{options: make(map[string]string), Args: make([]string, 0)}
+}
+
 func (res *ArgParseResults) Contains(name string) bool {
 	_, ok := res.options[name]
 	return ok

go/performance/microsysbench/sysbench_test.go

@@ -140,7 +140,12 @@ func populateRepo(dEnv *env.DoltEnv, insertData string) {
 	execSql := func(dEnv *env.DoltEnv, q string) int {
 		ctx := context.Background()
 		args := []string{"-r", "null", "-q", q}
-		return commands.SqlCmd{}.Exec(ctx, "sql", args, dEnv, commands.BuildEmptyCliContext())
+		cliCtx, err := commands.NewArgFreeCliContext(ctx, dEnv)
+		if err != nil {
+			panic(err)
+		}
+
+		return commands.SqlCmd{}.Exec(ctx, "sql", args, dEnv, cliCtx)
 	}
 	execSql(dEnv, createTable)
 	execSql(dEnv, insertData)