Tables and types with hooks/overrides

Author: Hydrocharged

_example/main.go

@@ -89,6 +89,7 @@ func createTestDatabase() *memory.DbProvider {
 	pro := memory.NewDBProvider(db)
 	session := memory.NewSession(sql.NewBaseSession(), pro)
 	ctx := sql.NewContext(context.Background(), sql.WithSession(session))
+	ctx.Session = session
 
 	table := memory.NewTable(db, tableName, sql.NewPrimaryKeySchema(sql.Schema{
 		{Name: "name", Type: types.Text, Nullable: false, Source: tableName, PrimaryKey: true},

driver/driver.go

@@ -162,7 +162,7 @@ func (d *Driver) OpenConnector(dsn string) (driver.Connector, error) {
 	d.mu.Lock()
 	db, ok := d.dbs[serverName]
 	if !ok {
-		anlz := analyzer.NewDefaultWithVersion(pro)
+		anlz := analyzer.NewDefault(pro)
 		engine := sqle.New(anlz, nil)
 		db = &dbConn{engine: engine}
 		d.dbs[serverName] = db

engine.go

@@ -183,6 +183,10 @@ func New(a *analyzer.Analyzer, cfg *Config) *Engine {
 	}
 
 	a.Catalog.RegisterFunction(emptyCtx, function.GetLockingFuncs(ls)...)
+	parser := sql.DefaultMySQLParser
+	if a.Overrides.Builder.Parser != nil {
+		parser = a.Overrides.Builder.Parser
+	}
 
 	ret := &Engine{
 		Analyzer:          a,
@@ -194,7 +198,7 @@ func New(a *analyzer.Analyzer, cfg *Config) *Engine {
 		PreparedDataCache: NewPreparedDataCache(),
 		mu:                &sync.Mutex{},
 		EventScheduler:    nil,
-		Parser:            sql.GlobalParser,
+		Parser:            parser,
 	}
 	ret.ReadOnly.Store(cfg.IsReadOnly)
 	a.Runner = ret
@@ -203,16 +207,15 @@ func New(a *analyzer.Analyzer, cfg *Config) *Engine {
 
 // NewDefault creates a new default Engine.
 func NewDefault(pro sql.DatabaseProvider) *Engine {
-	a := analyzer.NewDefaultWithVersion(pro)
-	return New(a, nil)
+	return New(analyzer.NewDefault(pro), nil)
 }
 
 // AnalyzeQuery analyzes a query and returns its sql.Node
 func (e *Engine) AnalyzeQuery(
 	ctx *sql.Context,
 	query string,
 ) (sql.Node, error) {
-	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler, e.Parser)
+	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler)
 	parsed, _, _, qFlags, err := binder.Parse(query, nil, false)
 	if err != nil {
 		return nil, err
@@ -243,7 +246,7 @@ func (e *Engine) PrepareParsedQuery(
 	// Make sure there is an active transaction if one hasn't been started yet
 	e.beginTransaction(ctx)
 
-	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler, e.Parser)
+	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler)
 	node, _, err := binder.BindOnly(stmt, query, nil)
 
 	if err != nil {
@@ -526,7 +529,7 @@ func (e *Engine) BoundQueryPlan(ctx *sql.Context, query string, parsed sqlparser
 
 	query = sql.RemoveSpaceAndDelimiter(query, ';')
 
-	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler, e.Parser)
+	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler)
 	binder.SetBindings(bindings)
 
 	// Begin a transaction if necessary (no-op if one is in flight)
@@ -580,7 +583,7 @@ func (e *Engine) preparedStatement(ctx *sql.Context, query string, parsed sqlpar
 		preparedAst, preparedDataFound = e.PreparedDataCache.GetCachedStmt(ctx.Session.ID(), query)
 	}
 
-	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler, e.Parser)
+	binder := planbuilder.New(ctx, e.Analyzer.Catalog, e.EventScheduler)
 	if preparedDataFound {
 		parsed = preparedAst
 		binder.SetBindings(bindings)

engine_test.go

@@ -231,7 +231,7 @@ func TestTrackProcess(t *testing.T) {
 	_, ok = rhs.Table.(*plan.ProcessTable)
 	require.True(ok)
 
-	iter, err := rowexec.DefaultBuilder.Build(ctx, result, nil)
+	iter, err := rowexec.NewBuilder(nil, sql.EngineOverrides{}).Build(ctx, result, nil)
 	require.NoError(err)
 	iter, _, err = rowexec.FinalizeIters(ctx, result, nil, iter)
 	require.NoError(err)

enginetest/engine_only_test.go

@@ -272,7 +272,7 @@ func TestShowProcessList(t *testing.T) {
 
 	n := plan.NewShowProcessList()
 
-	iter, err := rowexec.DefaultBuilder.Build(ctx, n, nil)
+	iter, err := rowexec.NewBuilder(nil, sql.EngineOverrides{}).Build(ctx, n, nil)
 	require.NoError(err)
 	rows, err := sql.RowIterToRows(ctx, iter)
 	require.NoError(err)
@@ -327,9 +327,9 @@ func TestLockTables(t *testing.T) {
 		{plan.NewResolvedTable(t1, nil, nil), true},
 		{plan.NewResolvedTable(t2, nil, nil), false},
 	})
-	node.Catalog = analyzer.NewCatalog(sql.NewDatabaseProvider())
+	node.Catalog = analyzer.NewCatalog(sql.NewDatabaseProvider(), sql.EngineOverrides{})
 
-	_, err := rowexec.DefaultBuilder.Build(sql.NewEmptyContext(), node, nil)
+	_, err := rowexec.NewBuilder(nil, sql.EngineOverrides{}).Build(sql.NewEmptyContext(), node, nil)
 
 	require.NoError(err)
 
@@ -350,9 +350,9 @@ func TestUnlockTables(t *testing.T) {
 	db.AddTable("bar", t2)
 	db.AddTable("baz", t3)
 
-	catalog := analyzer.NewCatalog(sql.NewDatabaseProvider(db))
+	catalog := analyzer.NewCatalog(sql.NewDatabaseProvider(db), sql.EngineOverrides{})
 
-	ctx := sql.NewContext(context.Background())
+	ctx := sql.NewEmptyContext()
 	ctx.SetCurrentDatabase("db")
 	catalog.LockTable(ctx, "foo")
 	catalog.LockTable(ctx, "bar")
@@ -438,7 +438,7 @@ func TestAnalyzer_Exp(t *testing.T) {
 			require.NoError(t, err)
 
 			ctx := enginetest.NewContext(harness)
-			b := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler(), nil)
+			b := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler())
 			parsed, _, _, _, err := b.Parse(tt.query, nil, false)
 			require.NoError(t, err)
 
@@ -591,7 +591,7 @@ func TestTableFunctions(t *testing.T) {
 	engine := enginetest.NewEngineWithProvider(t, harness, testDatabaseProvider)
 	harness = harness.WithProvider(engine.Analyzer.Catalog.DbProvider)
 
-	engine.EngineAnalyzer().ExecBuilder = rowexec.DefaultBuilder
+	engine.EngineAnalyzer().ExecBuilder = rowexec.NewBuilder(nil, sql.EngineOverrides{})
 
 	engine, err := enginetest.RunSetupScripts(harness.NewContext(), engine, setup.MydbData, true)
 	require.NoError(t, err)

enginetest/enginetests.go

@@ -741,7 +741,8 @@ func TestQueryPlan(t *testing.T, harness Harness, e QueryEngine, tt queries.Quer
 func TestQueryPlanWithName(t *testing.T, name string, harness Harness, e QueryEngine, query, expectedPlan string, options sql.DescribeOptions) {
 	t.Run(name, func(t *testing.T) {
 		ctx := NewContext(harness)
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, query)
+		builder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, nil)
+		parsed, _, _, qFlags, err := builder.Parse(query, nil, false)
 		require.NoError(t, err)
 
 		node, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
@@ -768,7 +769,8 @@ func TestQueryPlanWithName(t *testing.T, name string, harness Harness, e QueryEn
 func TestQueryPlanWithEngine(t *testing.T, harness Harness, e QueryEngine, tt queries.QueryPlanTest, verbose bool) {
 	t.Run(tt.Query, func(t *testing.T) {
 		ctx := NewContext(harness)
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, tt.Query)
+		builder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, nil)
+		parsed, _, _, qFlags, err := builder.Parse(tt.Query, nil, false)
 		require.NoError(t, err)
 
 		node, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
@@ -1482,6 +1484,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 	e := mustNewEngine(t, harness)
 	defer e.Close()
 	ctx := NewContext(harness)
+	builder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, nil)
 
 	t.Run("Standard TRUNCATE", func(t *testing.T) {
 		RunQueryWithContext(t, e, harness, ctx, "CREATE TABLE t1 (pk BIGINT PRIMARY KEY, v1 BIGINT, INDEX(v1))")
@@ -1530,7 +1533,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t5 ORDER BY 1", []sql.Row{{int64(1), int64(1)}, {int64(2), int64(2)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t5"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1559,7 +1562,8 @@ func TestTruncate(t *testing.T, harness Harness) {
 		RunQueryWithContext(t, e, harness, ctx, "INSERT INTO t6parent VALUES (1,1), (2,2)")
 		RunQueryWithContext(t, e, harness, ctx, "INSERT INTO t6child VALUES (1,1), (2,2)")
 
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, "DELETE FROM t6parent")
+		deleteStr := "DELETE FROM t6parent"
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1587,7 +1591,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t7i ORDER BY 1", []sql.Row{{int64(3), int64(3)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t7"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1615,7 +1619,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t8 ORDER BY 1", []sql.Row{{int64(1), int64(4)}, {int64(2), int64(5)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t8"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1644,7 +1648,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t9 ORDER BY 1", []sql.Row{{int64(7), int64(7)}, {int64(8), int64(8)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t9 WHERE pk > 0"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1671,7 +1675,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t10 ORDER BY 1", []sql.Row{{int64(8), int64(8)}, {int64(9), int64(9)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t10 LIMIT 1000"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1698,7 +1702,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t11 ORDER BY 1", []sql.Row{{int64(1), int64(1)}, {int64(9), int64(9)}}, nil, nil, nil)
 
 		deleteStr := "DELETE FROM t11 ORDER BY 1"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1729,7 +1733,7 @@ func TestTruncate(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "SELECT * FROM t12b ORDER BY 1", []sql.Row{{int64(1), int64(1)}, {int64(2), int64(2)}}, nil, nil, nil)
 
 		deleteStr := "DELETE t12a, t12b FROM t12a INNER JOIN t12b WHERE t12a.pk=t12b.pk"
-		parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, deleteStr)
+		parsed, _, _, qFlags, err := builder.Parse(deleteStr, nil, false)
 		require.NoError(t, err)
 		analyzed, err := e.EngineAnalyzer().Analyze(ctx, parsed, nil, qFlags)
 		require.NoError(t, err)
@@ -1956,7 +1960,7 @@ func TestUserPrivileges(t *testing.T, harness ClientHarness) {
 			defer engine.Close()
 
 			ctx := NewContext(harness)
-			ctx.NewCtxWithClient(sql.Client{
+			ctx.WithClient(sql.Client{
 				User:    "root",
 				Address: "localhost",
 			})
@@ -2055,7 +2059,7 @@ func TestUserPrivileges(t *testing.T, harness ClientHarness) {
 					t.Skipf("Skipping query %s", lastQuery)
 				}
 			}
-			ctx := rootCtx.NewCtxWithClient(sql.Client{
+			ctx := rootCtx.WithClient(sql.Client{
 				User:    "tester",
 				Address: "localhost",
 			})

enginetest/evaluation.go

@@ -627,7 +627,7 @@ func injectBindVarsAndPrepare(
 		}
 	}
 
-	b := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler(), nil)
+	b := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, e.EngineEventScheduler())
 	b.SetParserOptions(sql.LoadSqlMode(ctx).ParserOptions())
 	resPlan, err := e.PrepareQuery(ctx, q)
 	if err != nil {

enginetest/histogram_test.go

@@ -315,7 +315,7 @@ func testHistogram(ctx *sql.Context, table *plan.ResolvedTable, fields []int, bu
 		return nil, fmt.Errorf("found zero row count for table")
 	}
 
-	i, err := rowexec.DefaultBuilder.Build(ctx, table, nil)
+	i, err := rowexec.NewBuilder(nil, sql.EngineOverrides{}).Build(ctx, table, nil)
 	rows, err := sql.RowIterToRows(ctx, i)
 	if err != nil {
 		return nil, err
@@ -416,7 +416,7 @@ func expectedResultSize(ctx *sql.Context, t1, t2 *plan.ResolvedTable, filters []
 	if debug {
 		fmt.Println(sql.DebugString(j))
 	}
-	i, err := rowexec.DefaultBuilder.Build(ctx, j, nil)
+	i, err := rowexec.NewBuilder(nil, sql.EngineOverrides{}).Build(ctx, j, nil)
 	if err != nil {
 		return 0, err
 	}

enginetest/join_planning_tests.go

@@ -1901,7 +1901,8 @@ func evalJoinTypeTest(t *testing.T, harness Harness, e QueryEngine, query string
 }
 
 func analyzeQuery(ctx *sql.Context, e QueryEngine, query string) (sql.Node, error) {
-	parsed, qFlags, err := planbuilder.Parse(ctx, e.EngineAnalyzer().Catalog, query)
+	builder := planbuilder.New(ctx, e.EngineAnalyzer().Catalog, nil)
+	parsed, _, _, qFlags, err := builder.Parse(query, nil, false)
 	if err != nil {
 		return nil, err
 	}

enginetest/memory_engine_test.go

@@ -203,20 +203,27 @@ func TestSingleScript(t *testing.T) {
 	t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name:        "AS OF propagates to nested CALLs",
-			SetUpScript: []string{},
+			Name: "Parse table name as column",
+			SetUpScript: []string{
+				`CREATE TABLE test (pk INT PRIMARY KEY, v1 VARCHAR(255));`,
+				`INSERT INTO test VALUES (1, 'a'), (2, 'b');`,
+			},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "create procedure create_proc() create table t (i int primary key, j int);",
-					Expected: []sql.Row{
-						{types.NewOkResult(0)},
-					},
+					Query:    "SELECT temporarytesting(t) FROM test AS t;",
+					Expected: []sql.Row{},
 				},
 				{
-					Query: "call create_proc()",
-					Expected: []sql.Row{
-						{types.NewOkResult(0)},
-					},
+					Query:    "SELECT temporarytesting(test) FROM test;",
+					Expected: []sql.Row{},
+				},
+				{
+					Query:    "SELECT temporarytesting(pk, test) FROM test;",
+					Expected: []sql.Row{},
+				},
+				{
+					Query:    "SELECT temporarytesting(v1, test, pk) FROM test;",
+					Expected: []sql.Row{},
 				},
 			},
 		},