Full passthrough of Doltgres overrides

go/cmd/dolt/commands/dump.go

@@ -458,7 +458,7 @@ func dumpViews(ctx *sql.Context, engine *engine.SqlEngine, root doltdb.RootValue
 		}
 		// We used to store just the SELECT part of a view, but now we store the entire CREATE VIEW statement
 		sqlEngine := engine.GetUnderlyingEngine()
-		binder := planbuilder.New(ctx, sqlEngine.Analyzer.Catalog, sqlEngine.EventScheduler, sqlEngine.Parser)
+		binder := planbuilder.New(ctx, sqlEngine.Analyzer.Catalog, sqlEngine.EventScheduler, sqlEngine.Parser, sqlEngine.Overrides.Builder)
 		binder.SetParserOptions(sql.NewSqlModeFromString(sqlMode).ParserOptions())
 		fragCol, ok, err := sql.Unwrap[string](ctx, row[fragColIdx])
 		if err != nil {

go/cmd/dolt/commands/engine/sqlengine.go

@@ -86,6 +86,7 @@ type SqlEngineConfig struct {
 	BinlogReplicaController    binlogreplication.BinlogReplicaController
 	EventSchedulerStatus       eventscheduler.SchedulerStatus
 	BranchActivityTracking     bool
+	EngineOverrides            gms.EngineOverrides
 }
 
 type SqlEngineConfigOption func(*SqlEngineConfig)
@@ -175,6 +176,7 @@ func NewSqlEngine(
 	engine := gms.New(analyzer.NewBuilder(pro).Build(), &gms.Config{
 		IsReadOnly:     config.IsReadOnly,
 		IsServerLocked: config.IsServerLocked,
+		Overrides:      config.EngineOverrides,
 	}).WithBackgroundThreads(bThreads)
 
 	if err := configureBinlogPrimaryController(engine); err != nil {
@@ -515,7 +517,7 @@ func configureEventScheduler(config *SqlEngineConfig, engine *gms.Engine, ctxFac
 // sqlContextFactory returns a contextFactory that creates a new sql.Context with the given session
 func sqlContextFactory(ctx context.Context, opts ...sql.ContextOption) *sql.Context {
 	ctx = valctx.WithContextValidation(ctx)
-	sqlCtx := sql.NewContext(ctx, opts...)
+	sqlCtx := sql.NewNonEngineContext(ctx, opts...)
 	if sqlCtx.Session != nil {
 		valctx.SetContextValidation(ctx, dsess.DSessFromSess(sqlCtx.Session).Validate)
 	}

go/cmd/dolt/commands/filter-branch.go

@@ -358,7 +358,7 @@ func rebaseSqlEngine(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootVal
 
 	sess := dsess.DefaultSession(pro, writer.NewWriteSession)
 
-	sqlCtx := sql.NewContext(ctx, sql.WithSession(sess))
+	sqlCtx := sql.NewNonEngineContext(ctx, sql.WithSession(sess))
 	err = sqlCtx.SetSessionVariable(sqlCtx, sql.AutoCommitSessionVar, false)
 	if err != nil {
 		return nil, nil, err

go/cmd/dolt/commands/indexcmds/rebuild.go

@@ -100,7 +100,7 @@ func (cmd RebuildCmd) Exec(ctx context.Context, commandStr string, args []string
 	if idxSch == nil {
 		return HandleErr(errhand.BuildDError("the index `%s` does not exist on table `%s`", indexName, tableName).Build(), nil)
 	}
-	indexRowData, err := creation.BuildSecondaryIndex(sql.NewContext(ctx), table, idxSch, tableName, opts)
+	indexRowData, err := creation.BuildSecondaryIndex(sql.NewNonEngineContext(ctx), table, idxSch, tableName, opts)
 	if err != nil {
 		return HandleErr(errhand.BuildDError("Unable to rebuild index `%s` on table `%s`.", indexName, tableName).AddCause(err).Build(), nil)
 	}

go/cmd/dolt/commands/schcmds/tags.go

@@ -139,7 +139,7 @@ func (cmd TagsCmd) Exec(ctx context.Context, commandStr string, args []string, d
 		}
 	}
 
-	sqlCtx := sql.NewContext(ctx)
+	sqlCtx := sql.NewNonEngineContext(ctx)
 	err = engine.PrettyPrintResults(sqlCtx, outputFmt, headerSchema, sql.RowsToRowIter(rows...), false, false, false, false)
 
 	return commands.HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)

go/cmd/dolt/commands/sql.go

@@ -1082,7 +1082,7 @@ func newCompleter(
 	subCtx, stop := signal.NotifyContext(ctx.Context, os.Interrupt, syscall.SIGTERM)
 	defer stop()
 
-	sqlCtx := sql.NewContext(subCtx, sql.WithSession(ctx.Session))
+	sqlCtx := sql.NewNonEngineContext(subCtx, sql.WithSession(ctx.Session))
 
 	sqlCtx.Session.LockWarnings()
 	defer sqlCtx.Session.UnlockWarnings()

go/cmd/dolt/commands/sqlserver/command_line_config.go

@@ -21,12 +21,13 @@ import (
 	"strings"
 	"time"
 
-	"github.com/dolthub/dolt/go/libraries/doltcore/servercfg"
-	"github.com/dolthub/dolt/go/libraries/utils/filesys"
+	gms "github.com/dolthub/go-mysql-server"
 
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands"
+	"github.com/dolthub/dolt/go/libraries/doltcore/servercfg"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
+	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 )
 
 type commandLineServerConfig struct {
@@ -595,6 +596,10 @@ func (cfg *commandLineServerConfig) AutoGCBehavior() servercfg.AutoGCBehavior {
 	return stubAutoGCBehavior{}
 }
 
+func (cfg *commandLineServerConfig) Overrides() gms.EngineOverrides {
+	return gms.EngineOverrides{}
+}
+
 // DoltServerConfigReader is the default implementation of ServerConfigReader suitable for parsing Dolt config files
 // and command line options.
 type DoltServerConfigReader struct{}

go/cmd/dolt/commands/sqlserver/queryist_utils.go

@@ -99,7 +99,7 @@ func BuildConnectionStringQueryist(ctx context.Context, cwdFS filesys.Filesys, c
 	queryist := ConnectionQueryist{connection: conn, gatherWarnings: &gatherWarnings}
 
 	var lateBind cli.LateBindQueryist = func(ctx context.Context, opts ...cli.LateBindQueryistOption) (res cli.LateBindQueryistResult, err error) {
-		sqlCtx := sql.NewContext(ctx)
+		sqlCtx := sql.NewNonEngineContext(ctx)
 		sqlCtx.SetCurrentDatabase(dbRev)
 		res.Queryist = queryist
 		res.Context = sqlCtx

go/cmd/dolt/commands/sqlserver/server.go

@@ -251,6 +251,7 @@ func ConfigureServices(
 				ClusterController:          clusterController,
 				BinlogReplicaController:    binlogreplication.DoltBinlogReplicaController,
 				SkipRootUserInitialization: cfg.SkipRootUserInit,
+				EngineOverrides:            cfg.ServerConfig.Overrides(),
 			}
 			return nil
 		},
@@ -391,7 +392,7 @@ func ConfigureServices(
 
 	InitBinlogging := &svcs.AnonService{
 		InitF: func(ctx context.Context) error {
-			sqlCtx := sql.NewContext(ctx)
+			sqlCtx := sql.NewNonEngineContext(ctx)
 			primaryController := sqlEngine.GetUnderlyingEngine().Analyzer.Catalog.BinlogPrimaryController
 			doltBinlogPrimaryController, ok := primaryController.(*binlogreplication.DoltBinlogPrimaryController)
 			if !ok {

go/go.mod

@@ -199,4 +199,6 @@ require (
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 )
 
+replace github.com/dolthub/go-mysql-server => ../../go-mysql-server
+
 go 1.25.3

go/libraries/doltcore/merge/data_merge_test.go

@@ -129,7 +129,7 @@ func testDataMergeHelper(t *testing.T, tests []dataMergeTest, flipSides bool) {
 					var eo editor.Options
 					eo = eo.WithDeaf(editor.NewInMemDeaf(a.VRW()))
 					// attempt merge before skipping to assert no panics
-					result, err := merge.MergeRoots(sql.NewContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
+					result, err := merge.MergeRoots(sql.NewNonEngineContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
 
 					if data.dataConflict {
 						// TODO: Test the conflict error message more deeply

go/libraries/doltcore/merge/integration_test.go

@@ -311,7 +311,7 @@ func runConcurrentTxs(ctx context.Context, eng *engine.SqlEngine, seed int) erro
 	if err != nil {
 		return err
 	}
-	sctx := sql.NewContext(ctx, sql.WithSession(sess))
+	sctx := sql.NewNonEngineContext(ctx, sql.WithSession(sess))
 	sctx.SetCurrentDatabase("dolt")
 	sctx.Session.SetClient(sql.Client{User: "root", Address: "%"})
 

go/libraries/doltcore/merge/merge_test.go

@@ -310,7 +310,7 @@ func TestMergeCommits(t *testing.T) {
 	}
 	opts := editor.TestEditorOptions(vrw)
 	// TODO: stats
-	merged, _, err := merger.MergeTable(sql.NewContext(context.Background()), doltdb.TableName{Name: tableName}, opts, MergeOpts{IsCherryPick: false})
+	merged, _, err := merger.MergeTable(sql.NewNonEngineContext(context.Background()), doltdb.TableName{Name: tableName}, opts, MergeOpts{IsCherryPick: false})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -369,7 +369,7 @@ func TestNomsMergeCommits(t *testing.T) {
 		t.Fatal(err)
 	}
 	opts := editor.TestEditorOptions(vrw)
-	merged, stats, err := merger.MergeTable(sql.NewContext(context.Background()), doltdb.TableName{Name: tableName}, opts, MergeOpts{IsCherryPick: false})
+	merged, stats, err := merger.MergeTable(sql.NewNonEngineContext(context.Background()), doltdb.TableName{Name: tableName}, opts, MergeOpts{IsCherryPick: false})
 	if err != nil {
 		t.Fatal(err)
 	}

go/libraries/doltcore/merge/schema_integration_test.go

@@ -707,7 +707,7 @@ func testMergeForeignKeys(t *testing.T, test mergeForeignKeyTest) {
 
 	opts := editor.TestEditorOptions(dEnv.DoltDB(ctx).ValueReadWriter())
 	mo := merge.MergeOpts{IsCherryPick: false}
-	result, err := merge.MergeRoots(sql.NewContext(ctx), doltdb.SimpleTableResolver{}, mainRoot, otherRoot, ancRoot, mainWS, otherWS, opts, mo)
+	result, err := merge.MergeRoots(sql.NewNonEngineContext(ctx), doltdb.SimpleTableResolver{}, mainRoot, otherRoot, ancRoot, mainWS, otherWS, opts, mo)
 	assert.NoError(t, err)
 
 	fkc, err := result.Root.GetForeignKeyCollection(ctx)

go/libraries/doltcore/merge/schema_merge_test.go

@@ -1639,7 +1639,7 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool
 				var eo editor.Options
 				eo = eo.WithDeaf(editor.NewInMemDeaf(a.VRW()))
 				// attempt merge before skipping to assert no panics
-				result, err := merge.MergeRoots(sql.NewContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
+				result, err := merge.MergeRoots(sql.NewNonEngineContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
 				maybeSkip(t, a.VRW().Format(), test, flipSides)
 
 				if test.conflict {
@@ -1869,7 +1869,7 @@ func makeEmptyRoot(t *testing.T, ddb *doltdb.DoltDB, eo editor.Options) doltdb.R
 	require.NoError(t, err)
 	sess := writer.NewWriteSession(ddb.Format(), ws, gst, eo)
 
-	ws, err = sess.Flush(sql.NewContext(ctx))
+	ws, err = sess.Flush(sql.NewNonEngineContext(ctx))
 	require.NoError(t, err)
 	return ws.WorkingRoot()
 }
@@ -1890,15 +1890,15 @@ func makeRootWithTable(t *testing.T, ddb *doltdb.DoltDB, eo editor.Options, tbl
 	require.NoError(t, err)
 	noop := func(ctx *sql.Context, dbName string, root doltdb.RootValue) (err error) { return }
 	sess := writer.NewWriteSession(ddb.Format(), ws, gst, eo)
-	wr, err := sess.GetTableWriter(sql.NewContext(ctx), doltdb.TableName{Name: tbl.ns.name}, "test", noop, false)
+	wr, err := sess.GetTableWriter(sql.NewNonEngineContext(ctx), doltdb.TableName{Name: tbl.ns.name}, "test", noop, false)
 	require.NoError(t, err)
 
 	sctx := sql.NewEmptyContext()
 	for _, r := range tbl.rows {
 		err = wr.Insert(sctx, r)
 		assert.NoError(t, err)
 	}
-	ws, err = sess.Flush(sql.NewContext(ctx))
+	ws, err = sess.Flush(sql.NewNonEngineContext(ctx))
 	require.NoError(t, err)
 	return ws.WorkingRoot()
 }

go/libraries/doltcore/migrate/validation.go

@@ -123,7 +123,7 @@ func validateTableData(ctx context.Context, name string, old, new *doltdb.Table)
 }
 
 func validateTableDataPartition(ctx context.Context, name string, old, new *doltdb.Table, start, end uint64) error {
-	sctx := sql.NewContext(ctx)
+	sctx := sql.NewNonEngineContext(ctx)
 	_, oldIter, err := sqle.DoltTablePartitionToRowIter(sctx, name, old, start, end)
 	if err != nil {
 		return err

go/libraries/doltcore/mvdata/engine_table_reader.go

@@ -37,7 +37,7 @@ type sqlEngineTableReader struct {
 }
 
 func NewSqlEngineReader(ctx *sql.Context, engine *sqle.Engine, root doltdb.RootValue, tableName string) (*sqlEngineTableReader, error) {
-	binder := planbuilder.New(ctx, engine.Analyzer.Catalog, engine.EventScheduler, engine.Parser)
+	binder := planbuilder.New(ctx, engine.Analyzer.Catalog, engine.EventScheduler, engine.Parser, engine.Overrides.Builder)
 	ret, _, _, _, err := binder.Parse(fmt.Sprintf("show create table `%s`", tableName), nil, false)
 	if err != nil {
 		return nil, err

go/libraries/doltcore/mvdata/engine_table_writer.go

@@ -343,7 +343,7 @@ func (s *SqlEngineTableWriter) getInsertNode(inputChannel chan sql.Row, replace
 	}
 
 	sqlEngine := s.se
-	binder := planbuilder.New(s.sqlCtx, sqlEngine.Analyzer.Catalog, sqlEngine.EventScheduler, sqlEngine.Parser)
+	binder := planbuilder.New(s.sqlCtx, sqlEngine.Analyzer.Catalog, sqlEngine.EventScheduler, sqlEngine.Parser, sqlEngine.Overrides.Builder)
 	insert := fmt.Sprintf("insert into `%s` (%s) VALUES (%s)%s", s.tableName, colNames, values, duplicate)
 	parsed, _, _, qFlags, err := binder.Parse(insert, nil, false)
 	if err != nil {

go/libraries/doltcore/servercfg/serverconfig.go

@@ -26,6 +26,7 @@ import (
 	"strings"
 	"time"
 
+	gms "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
 )
 
@@ -247,6 +248,8 @@ type ServerConfig interface {
 	ValueSet(value string) bool
 	// AutoGCBehavior defines parameters around how auto-GC works for the running server.
 	AutoGCBehavior() AutoGCBehavior
+	// Overrides returns any overrides that are defined. This is primarily used by Doltgres.
+	Overrides() gms.EngineOverrides
 }
 
 // DefaultServerConfig creates a `*ServerConfig` that has all of the options set to their default values.

go/libraries/doltcore/servercfg/yaml_config.go

@@ -22,6 +22,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
+	gms "github.com/dolthub/go-mysql-server"
 	"gopkg.in/yaml.v2"
 
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
@@ -1016,6 +1017,10 @@ func (cfg YAMLConfig) EventSchedulerStatus() string {
 	}
 }
 
+func (cfg YAMLConfig) Overrides() gms.EngineOverrides {
+	return gms.EngineOverrides{}
+}
+
 type ClusterYAMLConfig struct {
 	StandbyRemotes_ []StandbyRemoteYAMLConfig   `yaml:"standby_remotes"`
 	BootstrapRole_  string                      `yaml:"bootstrap_role"`

go/libraries/doltcore/sqle/auto_gc_test.go

@@ -38,7 +38,7 @@ func TestAutoGCController(t *testing.T) {
 		return res
 	}
 	CtxFactory := func(ctx context.Context) (*sql.Context, error) {
-		return sql.NewContext(ctx, sql.WithSession(sql.NewBaseSession())), nil
+		return sql.NewNonEngineContext(ctx, sql.WithSession(sql.NewBaseSession())), nil
 	}
 	t.Run("Hook", func(t *testing.T) {
 		t.Run("NeverStarted", func(t *testing.T) {

go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go

@@ -965,7 +965,7 @@ func convertVitessJsonExpressionString(ctx *sql.Context, value sqltypes.Value) (
 		return nil, fmt.Errorf("unable to access running SQL server")
 	}
 
-	binder := planbuilder.New(ctx, server.Engine.Analyzer.Catalog, server.Engine.EventScheduler, server.Engine.Parser)
+	binder := planbuilder.New(ctx, server.Engine.Analyzer.Catalog, server.Engine.EventScheduler, server.Engine.Parser, server.Engine.Overrides.Builder)
 	node, _, _, qFlags, err := binder.Parse("SELECT "+strValue, nil, false)
 	if err != nil {
 		return nil, err
@@ -1031,7 +1031,7 @@ func loadReplicaServerId(ctx *sql.Context) (uint32, error) {
 
 func executeQueryWithEngine(ctx *sql.Context, engine *gms.Engine, query string) {
 	// Create a sub-context when running queries against the engine, so that we get an accurate query start time.
-	queryCtx := sql.NewContext(ctx, sql.WithSession(ctx.Session))
+	queryCtx := ctx.NewContext(ctx, sql.WithSession(ctx.Session))
 
 	if queryCtx.GetCurrentDatabase() == "" {
 		ctx.GetLogger().WithFields(logrus.Fields{

go/libraries/doltcore/sqle/commit_hooks_test.go

@@ -222,7 +222,7 @@ func TestAsyncPushOnWrite(t *testing.T) {
 		require.NotNil(t, hook)
 		require.NotNil(t, runThreads)
 		runThreads(bThreads, func(ctx context.Context) (*sql.Context, error) {
-			return sql.NewContext(ctx), nil
+			return sql.NewNonEngineContext(ctx), nil
 		})
 
 		for i := 0; i < 200; i++ {
@@ -294,7 +294,7 @@ func TestAsyncPushOnWrite(t *testing.T) {
 		hook, runThreads := NewAsyncPushOnWriteHook(tmpDir, &buffer.Buffer{})
 		hook.destDb = destDB
 		runThreads(bThreads, func(ctx context.Context) (*sql.Context, error) {
-			return sql.NewContext(ctx), nil
+			return sql.NewNonEngineContext(ctx), nil
 		})
 
 		// Pretend we replicate a HEAD which does exist.

go/libraries/doltcore/sqle/database.go

@@ -2670,7 +2670,7 @@ func (db Database) doltSchemaTableHash(ctx *sql.Context) (hash.Hash, error) {
 
 // createEventDefinitionFromFragment creates an EventDefinition instance from the schema fragment |frag|.
 func (db Database) createEventDefinitionFromFragment(ctx *sql.Context, frag schemaFragment) (*sql.EventDefinition, error) {
-	b := planbuilder.New(ctx, db.getCatalog(ctx), db.getEventScheduler(ctx), nil)
+	b := planbuilder.New(ctx, db.getCatalog(ctx), db.getEventScheduler(ctx), nil, planbuilder.BuilderOverrides{})
 	b.SetParserOptions(sql.NewSqlModeFromString(frag.sqlMode).ParserOptions())
 	parsed, _, _, _, err := b.Parse(updateEventStatusTemporarilyForNonDefaultBranch(db.revision, frag.fragment), nil, false)
 	if err != nil {

go/libraries/doltcore/sqle/dfunctions/join_cost.go

@@ -79,7 +79,7 @@ func (c *JoinCost) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	pro := dSess.Provider()
 	eng := gms.NewDefault(pro)
 
-	binder := planbuilder.New(ctx, eng.Analyzer.Catalog, eng.EventScheduler, eng.Parser)
+	binder := planbuilder.New(ctx, eng.Analyzer.Catalog, eng.EventScheduler, eng.Parser, eng.Overrides.Builder)
 	parsed, _, _, qFlags, err := binder.Parse(q, nil, false)
 	if err != nil {
 		return nil, err

go/libraries/doltcore/sqle/dsess/session_state_adapter.go

@@ -225,7 +225,7 @@ func (s SessionStateAdapter) RemoveBackup(_ context.Context, name string) error
 }
 
 func (s SessionStateAdapter) TempTableFilesDir() (string, error) {
-	branchState, _, err := s.session.lookupDbState(sql.NewContext(context.Background()), s.dbName)
+	branchState, _, err := s.session.lookupDbState(sql.NewNonEngineContext(context.Background()), s.dbName)
 	if err != nil {
 		return "", err
 	}

go/libraries/doltcore/sqle/dtablefunctions/dolt_test_run.go

@@ -303,7 +303,7 @@ func (trtf *TestsRunTableFunction) getDoltTestsData(arg string) ([]sql.Row, erro
 }
 
 func IsWriteQuery(query string, ctx *sql.Context, catalog sql.Catalog) (bool, error) {
-	builder := planbuilder.New(ctx, catalog, nil, nil)
+	builder := planbuilder.NewFromContext(ctx, catalog)
 
 	parsed, _, _, err := sql.GlobalParser.Parse(ctx, query, false)
 	if err != nil {

go/libraries/doltcore/sqle/enginetest/branch_control_test.go

@@ -1420,7 +1420,7 @@ func TestBranchControl(t *testing.T) {
 			defer engine.Close()
 
 			ctx := enginetest.NewContext(harness)
-			ctx.NewCtxWithClient(sql.Client{
+			ctx.WithClient(sql.Client{
 				User:    "root",
 				Address: "localhost",
 			})
@@ -1440,7 +1440,7 @@ func TestBranchControl(t *testing.T) {
 				if host == "" {
 					host = "localhost"
 				}
-				ctx = ctx.NewCtxWithClient(sql.Client{
+				ctx = ctx.WithClient(sql.Client{
 					User:    user,
 					Address: host,
 				})
@@ -1478,7 +1478,7 @@ func TestBranchControlBlocks(t *testing.T) {
 			defer engine.Close()
 
 			rootCtx := enginetest.NewContext(harness)
-			rootCtx.NewCtxWithClient(sql.Client{
+			rootCtx.WithClient(sql.Client{
 				User:    "root",
 				Address: "localhost",
 			})
@@ -1522,7 +1522,7 @@ func TestBranchControlBlocks(t *testing.T) {
 			defer engine.Close()
 
 			rootCtx := enginetest.NewContext(harness)
-			rootCtx.NewCtxWithClient(sql.Client{
+			rootCtx.WithClient(sql.Client{
 				User:    "root",
 				Address: "localhost",
 			})

go/libraries/doltcore/sqle/enginetest/dolt_branch_queries.go

@@ -603,7 +603,7 @@ func TestIndexedAccess(t *testing.T, e enginetest.QueryEngine, harness enginetes
 }
 
 func analyzeQuery(ctx *sql.Context, e enginetest.QueryEngine, query string) (sql.Node, error) {
-	binder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler(), nil)
+	binder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler(), nil, planbuilder.BuilderOverrides{})
 	parsed, _, _, qFlags, err := binder.Parse(query, nil, false)
 	if err != nil {
 		return nil, err