Full passthrough of Doltgres overrides

go/cmd/dolt/commands/assist.go

@@ -36,6 +36,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/dconfig"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
 )
 
@@ -581,6 +582,7 @@ func jsonMessage(role string, content string) ([]byte, error) {
 }
 
 func getCreateTableStatements(ctx *sql.Context, sqlEngine *engine.SqlEngine, dEnv *env.DoltEnv) (string, error) {
+	formatter := overrides.SchemaFormatterFromContext(ctx)
 	sb := strings.Builder{}
 
 	root, err := dEnv.WorkingRoot(ctx)
@@ -590,7 +592,7 @@ func getCreateTableStatements(ctx *sql.Context, sqlEngine *engine.SqlEngine, dEn
 
 	tables, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	for _, table := range tables {
-		_, iter, _, err := sqlEngine.Query(ctx, fmt.Sprintf("SHOW CREATE TABLE %s", sql.QuoteIdentifier(table)))
+		_, iter, _, err := sqlEngine.Query(ctx, fmt.Sprintf("SHOW CREATE TABLE %s", formatter.QuoteIdentifier(table)))
 		if err != nil {
 			return "", err
 		}

go/cmd/dolt/commands/diff_output.go

@@ -30,6 +30,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/diff"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtablefunctions"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlfmt"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table/typed/json"
@@ -256,12 +257,13 @@ func (s sqlDiffWriter) WriteTableSchemaDiff(fromTableInfo, toTableInfo *diff.Tab
 
 func (s sqlDiffWriter) WriteEventDiff(ctx context.Context, eventName, oldDefn, newDefn string) error {
 	// definitions will already be semicolon terminated, no need to add additional ones
+	formatter := overrides.SchemaFormatterFromContext(ctx)
 	if oldDefn == "" {
 		cli.Println(newDefn)
 	} else if newDefn == "" {
-		cli.Println(fmt.Sprintf("DROP EVENT %s;", sql.QuoteIdentifier(eventName)))
+		cli.Println(fmt.Sprintf("DROP EVENT %s;", formatter.QuoteIdentifier(eventName)))
 	} else {
-		cli.Println(fmt.Sprintf("DROP EVENT %s;", sql.QuoteIdentifier(eventName)))
+		cli.Println(fmt.Sprintf("DROP EVENT %s;", formatter.QuoteIdentifier(eventName)))
 		cli.Println(newDefn)
 	}
 
@@ -270,12 +272,13 @@ func (s sqlDiffWriter) WriteEventDiff(ctx context.Context, eventName, oldDefn, n
 
 func (s sqlDiffWriter) WriteTriggerDiff(ctx context.Context, triggerName, oldDefn, newDefn string) error {
 	// definitions will already be semicolon terminated, no need to add additional ones
+	formatter := overrides.SchemaFormatterFromContext(ctx)
 	if oldDefn == "" {
 		cli.Println(newDefn)
 	} else if newDefn == "" {
-		cli.Println(fmt.Sprintf("DROP TRIGGER %s;", sql.QuoteIdentifier(triggerName)))
+		cli.Println(fmt.Sprintf("DROP TRIGGER %s;", formatter.QuoteIdentifier(triggerName)))
 	} else {
-		cli.Println(fmt.Sprintf("DROP TRIGGER %s;", sql.QuoteIdentifier(triggerName)))
+		cli.Println(fmt.Sprintf("DROP TRIGGER %s;", formatter.QuoteIdentifier(triggerName)))
 		cli.Println(newDefn)
 	}
 
@@ -284,12 +287,13 @@ func (s sqlDiffWriter) WriteTriggerDiff(ctx context.Context, triggerName, oldDef
 
 func (s sqlDiffWriter) WriteViewDiff(ctx context.Context, viewName, oldDefn, newDefn string) error {
 	// definitions will already be semicolon terminated, no need to add additional ones
+	formatter := overrides.SchemaFormatterFromContext(ctx)
 	if oldDefn == "" {
 		cli.Println(newDefn)
 	} else if newDefn == "" {
-		cli.Println(fmt.Sprintf("DROP VIEW %s;", sql.QuoteIdentifier(viewName)))
+		cli.Println(fmt.Sprintf("DROP VIEW %s;", formatter.QuoteIdentifier(viewName)))
 	} else {
-		cli.Println(fmt.Sprintf("DROP VIEW %s;", sql.QuoteIdentifier(viewName)))
+		cli.Println(fmt.Sprintf("DROP VIEW %s;", formatter.QuoteIdentifier(viewName)))
 		cli.Println(newDefn)
 	}
 

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)
 		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            sql.EngineOverrides
 }
 
 type SqlEngineConfigOption func(*SqlEngineConfig)
@@ -157,7 +158,7 @@ func NewSqlEngine(
 	}
 
 	b := env.GetDefaultInitBranch(mrEnv.Config())
-	pro, err := sqle.NewDoltDatabaseProviderWithDatabases(b, mrEnv.FileSystem(), all, locations)
+	pro, err := sqle.NewDoltDatabaseProviderWithDatabases(b, mrEnv.FileSystem(), all, locations, config.EngineOverrides)
 	if err != nil {
 		return nil, err
 	}
@@ -172,7 +173,7 @@ func NewSqlEngine(
 
 	sqlEngine := &SqlEngine{}
 	// Create the engine
-	engine := gms.New(analyzer.NewBuilder(pro).Build(), &gms.Config{
+	engine := gms.New(analyzer.NewBuilder(pro).AddOverrides(config.EngineOverrides).Build(), &gms.Config{
 		IsReadOnly:     config.IsReadOnly,
 		IsServerLocked: config.IsServerLocked,
 	}).WithBackgroundThreads(bThreads)
@@ -253,7 +254,7 @@ func NewSqlEngine(
 
 	branchActivityTracker := doltdb.NewBranchActivityTracker(ctx, config.BranchActivityTracking)
 
-	engine.Analyzer.ExecBuilder = rowexec.NewOverrideBuilder(kvexec.Builder{})
+	engine.Analyzer.ExecBuilder = rowexec.NewBuilder(kvexec.Builder{}, engine.Analyzer.Overrides)
 	sessFactory := doltSessionFactory(pro, statsPro, mrEnv.Config(), bcController, gcSafepointController, config.Autocommit, branchActivityTracker)
 	sqlEngine.provider = pro
 	sqlEngine.dsessFactory = sessFactory

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

@@ -351,7 +351,7 @@ func rebaseSqlEngine(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootVal
 	}
 
 	b := env.GetDefaultInitBranch(dEnv.Config)
-	pro, err := dsqle.NewDoltDatabaseProviderWithDatabase(b, mrEnv.FileSystem(), db, dEnv.FS)
+	pro, err := dsqle.NewDoltDatabaseProviderWithDatabase(b, mrEnv.FileSystem(), db, dEnv.FS, sql.EngineOverrides{})
 	if err != nil {
 		return nil, nil, err
 	}

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"
+	"github.com/dolthub/go-mysql-server/sql"
 
 	"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() sql.EngineOverrides {
+	return sql.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/server.go

@@ -251,6 +251,7 @@ func ConfigureServices(
 				ClusterController:          clusterController,
 				BinlogReplicaController:    binlogreplication.DoltBinlogReplicaController,
 				SkipRootUserInitialization: cfg.SkipRootUserInit,
+				EngineOverrides:            cfg.ServerConfig.Overrides(),
 			}
 			return nil
 		},

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/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)
 	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

@@ -29,6 +29,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/transform"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table/typed/noms"
 	"github.com/dolthub/dolt/go/store/types"
@@ -143,7 +144,8 @@ func (s *SqlEngineTableWriter) WriteRows(ctx context.Context, inputChannel chan
 		return err
 	}
 
-	iter, err := rowexec.DefaultBuilder.Build(s.sqlCtx, insertOrUpdateOperation, nil)
+	engOverrides := overrides.EngineOverridesFromContext(ctx)
+	iter, err := rowexec.NewBuilder(nil, engOverrides).Build(s.sqlCtx, insertOrUpdateOperation, nil)
 	if err != nil {
 		return err
 	}
@@ -299,21 +301,22 @@ func (s *SqlEngineTableWriter) createOrEmptyTableIfNeeded() error {
 func (s *SqlEngineTableWriter) createTable() error {
 	// TODO don't use internal interfaces to do this, we had to have a sql.Schema somewhere
 	// upstream to make the dolt schema
+	formatter := overrides.SchemaFormatterFromContext(s.sqlCtx)
 	sqlCols := make([]string, len(s.tableSchema.Schema))
 	for i, c := range s.tableSchema.Schema {
-		sqlCols[i] = sql.GenerateCreateTableColumnDefinition(c, c.Default.String(), c.OnUpdate.String(), sql.Collation_Default)
+		sqlCols[i] = formatter.GenerateCreateTableColumnDefinition(c, c.Default.String(), c.OnUpdate.String(), sql.Collation_Default)
 	}
 	var pks string
 	var sep string
 	for _, i := range s.tableSchema.PkOrdinals {
-		pks += sep + sql.QuoteIdentifier(s.tableSchema.Schema[i].Name)
+		pks += sep + formatter.QuoteIdentifier(s.tableSchema.Schema[i].Name)
 		sep = ", "
 	}
 	if len(sep) > 0 {
 		sqlCols = append(sqlCols, fmt.Sprintf("PRIMARY KEY (%s)", pks))
 	}
 
-	createTable := sql.GenerateCreateTableStatement(s.tableName, sqlCols, "", "", sql.CharacterSet_utf8mb4.String(), sql.Collation_Default.String(), "")
+	createTable := formatter.GenerateCreateTableStatement(s.tableName, sqlCols, "", "", sql.CharacterSet_utf8mb4.String(), sql.Collation_Default.String(), "")
 	_, iter, _, err := s.se.Query(s.sqlCtx, createTable)
 	if err != nil {
 		return err
@@ -325,6 +328,7 @@ func (s *SqlEngineTableWriter) createTable() error {
 // createInsertImportNode creates the relevant/analyzed insert node given the import option. This insert node is wrapped
 // with an error handler.
 func (s *SqlEngineTableWriter) getInsertNode(inputChannel chan sql.Row, replace bool) (sql.Node, error) {
+	formatter := overrides.SchemaFormatterFromContext(s.sqlCtx)
 	update := s.importOption == UpdateOp
 	colNames := ""
 	values := ""
@@ -334,7 +338,7 @@ func (s *SqlEngineTableWriter) getInsertNode(inputChannel chan sql.Row, replace
 	}
 	sep := ""
 	for _, col := range s.rowOperationSchema.Schema {
-		colNames += fmt.Sprintf("%s%s", sep, sql.QuoteIdentifier(col.Name))
+		colNames += fmt.Sprintf("%s%s", sep, formatter.QuoteIdentifier(col.Name))
 		values += fmt.Sprintf("%s1", sep)
 		if update {
 			duplicate += fmt.Sprintf("%s`%s` = VALUES(`%s`)", sep, col.Name, col.Name)
@@ -343,7 +347,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)
 	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

@@ -247,6 +247,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() sql.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"
 
+	"github.com/dolthub/go-mysql-server/sql"
 	"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() sql.EngineOverrides {
+	return sql.EngineOverrides{}
+}
+
 type ClusterYAMLConfig struct {
 	StandbyRemotes_ []StandbyRemoteYAMLConfig   `yaml:"standby_remotes"`
 	BootstrapRole_  string                      `yaml:"bootstrap_role"`

go/libraries/doltcore/sqle/alterschema_test.go

@@ -292,11 +292,7 @@ func makePeopleTable(ctx context.Context, dEnv *env.DoltEnv) (*env.DoltEnv, erro
 }
 
 func mustStringToColumnDefault(defaultString string) *sql.ColumnDefaultValue {
-	def, err := planbuilder.StringToColumnDefaultValue(sql.NewEmptyContext(), defaultString)
-	if err != nil {
-		panic(err)
-	}
-	return def
+	return planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), defaultString, nil, true)
 }
 
 func schemaNewColumnWithDefault(name string, tag uint64, kind types.NomsKind, partOfPK bool, defaultVal string, constraints ...schema.ColConstraint) schema.Column {

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

@@ -40,6 +40,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/writer"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqlserver"
 )
@@ -965,7 +966,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)
 	node, _, _, qFlags, err := binder.Parse("SELECT "+strValue, nil, false)
 	if err != nil {
 		return nil, err
@@ -976,7 +977,8 @@ func convertVitessJsonExpressionString(ctx *sql.Context, value sqltypes.Value) (
 		return nil, err
 	}
 
-	rowIter, err := rowexec.DefaultBuilder.Build(ctx, analyze, nil)
+	engOverrides := overrides.EngineOverridesFromContext(ctx)
+	rowIter, err := rowexec.NewBuilder(nil, engOverrides).Build(ctx, analyze, nil)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/database.go

@@ -48,6 +48,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtables"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/globalstate"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table/editor"
@@ -2670,7 +2671,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))
 	b.SetParserOptions(sql.NewSqlModeFromString(frag.sqlMode).ParserOptions())
 	parsed, _, _, _, err := b.Parse(updateEventStatusTemporarilyForNonDefaultBranch(db.revision, frag.fragment), nil, false)
 	if err != nil {
@@ -3027,7 +3028,8 @@ func (db Database) LoadRebasePlan(ctx *sql.Context) (*rebase.RebasePlan, error)
 		Column: expression.NewGetField(0, rebaseSchema[0].Type, "rebase_order", false),
 		Order:  sql.Ascending,
 	}}, resolvedTable)
-	iter, err := rowexec.DefaultBuilder.Build(ctx, sort, nil)
+	engOverrides := overrides.EngineOverridesFromContext(ctx)
+	iter, err := rowexec.NewBuilder(nil, engOverrides).Build(ctx, sort, nil)
 	if err != nil {
 		return nil, err
 	}