Merge branch 'main' into fulghum/dolt-5735

Author: fulghum

engine.go

@@ -16,7 +16,6 @@ package sqle
 
 import (
 	"fmt"
-	"os"
 	"sync"
 
 	"github.com/pkg/errors"
@@ -224,7 +223,6 @@ func (e *Engine) QueryNodeWithBindings(
 	var (
 		analyzed sql.Node
 		iter     sql.RowIter
-		iter2    sql.RowIter2
 		err      error
 	)
 
@@ -269,17 +267,7 @@ func (e *Engine) QueryNodeWithBindings(
 		return nil, nil, err
 	}
 
-	useIter2 := false
-	if enableRowIter2 {
-		useIter2 = allNode2(analyzed)
-	}
-
-	if useIter2 {
-		iter2, err = analyzed.(sql.Node2).RowIter2(ctx, nil)
-		iter = iter2
-	} else {
-		iter, err = analyzed.RowIter(ctx, nil)
-	}
+	iter, err = e.Analyzer.ExecBuilder.Build(ctx, analyzed, nil)
 	if err != nil {
 		err2 := clearAutocommitTransaction(ctx)
 		if err2 != nil {
@@ -289,14 +277,6 @@ func (e *Engine) QueryNodeWithBindings(
 		return nil, nil, err
 	}
 
-	if useIter2 {
-		iter = rowFormatSelectorIter{
-			iter:    iter,
-			iter2:   iter2,
-			isNode2: useIter2,
-		}
-	}
-
 	return analyzed.Schema(), iter, nil
 }
 
@@ -480,95 +460,6 @@ func (e *Engine) analyzePreparedQuery(ctx *sql.Context, query string, analyzed s
 	return analyzed, nil
 }
 
-// allNode2 returns whether all the nodes in the tree implement Node2.
-func allNode2(n sql.Node) bool {
-	allNode2 := true
-	transform.Inspect(n, func(n sql.Node) bool {
-		switch n := n.(type) {
-		case *plan.ResolvedTable:
-			table := n.Table
-			if tw, ok := table.(sql.TableWrapper); ok {
-				table = tw.Underlying()
-			}
-			if _, ok := table.(sql.Table2); !ok {
-				allNode2 = false
-				return false
-			}
-		}
-		if _, ok := n.(sql.Node2); n != nil && !ok {
-			allNode2 = false
-			return false
-		}
-		return true
-	})
-	if !allNode2 {
-		return allNode2
-	}
-
-	// All expressions in the tree must likewise be Expression2, and all types Type2, or we can't use rowFrame iteration
-	// TODO: likely that some nodes rely on expressions but don't implement sql.Expressioner, or implement it incompletely
-	transform.InspectExpressions(n, func(e sql.Expression) bool {
-		if e == nil {
-			return false
-		}
-		if _, ok := e.(sql.Expression2); !ok {
-			allNode2 = false
-			return false
-		}
-		if _, ok := e.Type().(sql.Type2); !ok {
-			allNode2 = false
-			return false
-		}
-		return true
-	})
-
-	return allNode2
-}
-
-// rowFormatSelectorIter is a wrapping row iter that implements RowIterTypeSelector so that clients consuming rows from it
-// know whether it's safe to iterate as RowIter or RowIter2.
-type rowFormatSelectorIter struct {
-	iter    sql.RowIter
-	iter2   sql.RowIter2
-	isNode2 bool
-}
-
-var _ sql.RowIterTypeSelector = rowFormatSelectorIter{}
-var _ sql.RowIter = rowFormatSelectorIter{}
-var _ sql.RowIter2 = rowFormatSelectorIter{}
-
-func (t rowFormatSelectorIter) Next(context *sql.Context) (sql.Row, error) {
-	return t.iter.Next(context)
-}
-
-func (t rowFormatSelectorIter) Close(context *sql.Context) error {
-	if t.iter2 != nil {
-		return t.iter2.Close(context)
-	}
-	return t.iter.Close(context)
-}
-
-func (t rowFormatSelectorIter) Next2(ctx *sql.Context, frame *sql.RowFrame) error {
-	return t.iter2.Next2(ctx, frame)
-}
-
-func (t rowFormatSelectorIter) IsNode2() bool {
-	return t.isNode2
-}
-
-const (
-	enableIter2EnvVar = "ENABLE_ROW_ITER_2"
-)
-
-var enableRowIter2 bool
-
-func init() {
-	_, ok := os.LookupEnv(enableIter2EnvVar)
-	if ok {
-		enableRowIter2 = true
-	}
-}
-
 func (e *Engine) beginTransaction(ctx *sql.Context, transactionDatabase string) error {
 	beginNewTransaction := ctx.GetTransaction() == nil || plan.ReadCommitted(ctx)
 	if beginNewTransaction {

enginetest/engine_only_test.go

@@ -42,6 +42,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/expression/function"
 	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/rowexec"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
@@ -245,7 +246,7 @@ func TestShowProcessList(t *testing.T) {
 
 	n := plan.NewShowProcessList()
 
-	iter, err := n.RowIter(ctx, nil)
+	iter, err := rowexec.DefaultBuilder.Build(ctx, n, nil)
 	require.NoError(err)
 	rows, err := sql.RowIterToRows(ctx, n.Schema(), iter)
 	require.NoError(err)
@@ -320,7 +321,7 @@ func TestTrackProcess(t *testing.T) {
 	_, ok = rhs.Table.(*plan.ProcessIndexableTable)
 	require.True(ok)
 
-	iter, err := proc.RowIter(ctx, nil)
+	iter, err := rowexec.DefaultBuilder.Build(ctx, proc, nil)
 	require.NoError(err)
 	_, err = sql.RowIterToRows(ctx, nil, iter)
 	require.NoError(err)
@@ -357,7 +358,8 @@ func TestLockTables(t *testing.T) {
 	})
 	node.Catalog = analyzer.NewCatalog(sql.NewDatabaseProvider())
 
-	_, err := node.RowIter(sql.NewEmptyContext(), nil)
+	_, err := rowexec.DefaultBuilder.Build(sql.NewEmptyContext(), node, nil)
+
 	require.NoError(err)
 
 	require.Equal(1, t1.writeLocks)
@@ -685,6 +687,8 @@ func TestTableFunctions(t *testing.T) {
 	testDatabaseProvider := NewTestProvider(&databaseProvider, SimpleTableFunction{}, memory.IntSequenceTable{})
 
 	engine := enginetest.NewEngineWithProvider(t, harness, testDatabaseProvider)
+	engine.Analyzer.ExecBuilder = rowexec.DefaultBuilder
+
 	engine, err := enginetest.RunSetupScripts(harness.NewContext(), engine, setup.MydbData, true)
 	require.NoError(t, err)
 
@@ -868,6 +872,7 @@ func TestCollationCoercion(t *testing.T) {
 
 var _ sql.TableFunction = (*SimpleTableFunction)(nil)
 var _ sql.CollationCoercible = (*SimpleTableFunction)(nil)
+var _ sql.ExecSourceRel = (*SimpleTableFunction)(nil)
 
 // SimpleTableFunction an extremely simple implementation of TableFunction for testing.
 // When evaluated, returns a single row: {"foo", 123}
@@ -879,6 +884,14 @@ func (s SimpleTableFunction) NewInstance(_ *sql.Context, _ sql.Database, _ []sql
 	return SimpleTableFunction{}, nil
 }
 
+func (s SimpleTableFunction) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) {
+	if s.returnedResults == true {
+		return nil, io.EOF
+	}
+	s.returnedResults = true
+	return &SimpleTableFunctionRowIter{}, nil
+}
+
 func (s SimpleTableFunction) Resolved() bool {
 	return true
 }
@@ -906,16 +919,6 @@ func (s SimpleTableFunction) Children() []sql.Node {
 	return []sql.Node{}
 }
 
-func (s SimpleTableFunction) RowIter(_ *sql.Context, _ sql.Row) (sql.RowIter, error) {
-	if s.returnedResults == true {
-		return nil, io.EOF
-	}
-
-	s.returnedResults = true
-	rowIter := &SimpleTableFunctionRowIter{}
-	return rowIter, nil
-}
-
 func (s SimpleTableFunction) WithChildren(_ ...sql.Node) (sql.Node, error) {
 	return s, nil
 }

enginetest/enginetests.go

@@ -38,6 +38,7 @@ import (
 	"github.com/dolthub/go-mysql-server/server"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/analyzer"
+	"github.com/dolthub/go-mysql-server/sql/analyzer/analyzererrors"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/expression/function/aggregation"
 	"github.com/dolthub/go-mysql-server/sql/mysql_db"
@@ -299,7 +300,7 @@ func TestReadOnlyDatabases(t *testing.T, harness ReadOnlyDatabaseHarness) {
 	} {
 		for _, tt := range querySet {
 			t.Run(tt.WriteQuery, func(t *testing.T) {
-				AssertErrWithBindings(t, engine, harness, tt.WriteQuery, tt.Bindings, analyzer.ErrReadOnlyDatabase)
+				AssertErrWithBindings(t, engine, harness, tt.WriteQuery, tt.Bindings, analyzererrors.ErrReadOnlyDatabase)
 			})
 		}
 	}
@@ -1818,6 +1819,12 @@ func TestStoredProcedures(t *testing.T, harness Harness) {
 	})
 }
 
+func TestEvents(t *testing.T, h Harness) {
+	for _, script := range queries.EventTests {
+		TestScript(t, h, script)
+	}
+}
+
 func TestTriggerErrors(t *testing.T, harness Harness) {
 	for _, script := range queries.TriggerErrorTests {
 		TestScript(t, harness, script)
@@ -1890,10 +1897,6 @@ func TestRecursiveViewDefinition(t *testing.T, harness Harness) {
 	db, err := e.Analyzer.Catalog.Database(ctx, "mydb")
 	require.NoError(t, err)
 
-	if pdb, ok := db.(mysql_db.PrivilegedDatabase); ok {
-		db = pdb.Unwrap()
-	}
-
 	vdb, ok := db.(sql.ViewDatabase)
 	require.True(t, ok, "expected sql.ViewDatabase")
 

enginetest/evaluation.go

@@ -29,7 +29,6 @@ import (
 	"github.com/dolthub/go-mysql-server/enginetest/queries"
 	"github.com/dolthub/go-mysql-server/enginetest/scriptgen/setup"
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/analyzer"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/plan"
@@ -766,7 +765,7 @@ func ExtractQueryNode(node sql.Node) sql.Node {
 	switch node := node.(type) {
 	case *plan.QueryProcess:
 		return ExtractQueryNode(node.Child())
-	case *analyzer.Releaser:
+	case *plan.Releaser:
 		return ExtractQueryNode(node.Child)
 	default:
 		return node

enginetest/memory_engine_test.go

@@ -645,6 +645,10 @@ func TestStoredProcedures(t *testing.T) {
 	enginetest.TestStoredProcedures(t, enginetest.NewDefaultMemoryHarness())
 }
 
+func TestEvents(t *testing.T) {
+	enginetest.TestEvents(t, enginetest.NewDefaultMemoryHarness())
+}
+
 func TestTriggersErrors(t *testing.T) {
 	enginetest.TestTriggerErrors(t, enginetest.NewDefaultMemoryHarness())
 }

enginetest/mysqlshim/database.go

@@ -36,6 +36,7 @@ var _ sql.TableRenamer = Database{}
 var _ sql.TriggerDatabase = Database{}
 var _ sql.StoredProcedureDatabase = Database{}
 var _ sql.ViewDatabase = Database{}
+var _ sql.EventDatabase = Database{}
 
 // Name implements the interface sql.Database.
 func (d Database) Name() string {
@@ -199,6 +200,63 @@ func (d Database) DropStoredProcedure(ctx *sql.Context, name string) error {
 	return d.shim.Exec(d.name, fmt.Sprintf("DROP PROCEDURE `%s`;", name))
 }
 
+// GetEvent implements sql.EventDatabase
+func (d Database) GetEvent(ctx *sql.Context, name string) (sql.EventDefinition, bool, error) {
+	name = strings.ToLower(name)
+	events, err := d.GetEvents(ctx)
+	if err != nil {
+		return sql.EventDefinition{}, false, err
+	}
+	for _, event := range events {
+		if name == strings.ToLower(event.Name) {
+			return event, true, nil
+		}
+	}
+	return sql.EventDefinition{}, false, nil
+}
+
+// GetEvents implements sql.EventDatabase
+func (d Database) GetEvents(ctx *sql.Context) ([]sql.EventDefinition, error) {
+	events, err := d.shim.QueryRows("", fmt.Sprintf("SHOW EVENTS WHERE Db = '%s';", d.name))
+	if err != nil {
+		return nil, err
+	}
+	eventDefinition := make([]sql.EventDefinition, len(events))
+	for i, event := range events {
+		// Db, Name, Definer, Time Zone, Type, ...
+		eventStmt, err := d.shim.QueryRows("", fmt.Sprintf("SHOW CREATE EVENT `%s`.`%s`;", d.name, event[1]))
+		if err != nil {
+			return nil, err
+		}
+		// Event, sql_mode, time_zone, Create Event, ...
+		eventDefinition[i] = sql.EventDefinition{
+			Name:            eventStmt[0][0].(string),
+			CreateStatement: eventStmt[0][3].(string),
+			// TODO: other fields should be added such as Created, LastAltered
+		}
+	}
+	return eventDefinition, nil
+}
+
+// SaveEvent implements sql.EventDatabase
+func (d Database) SaveEvent(ctx *sql.Context, ed sql.EventDefinition) error {
+	return d.shim.Exec(d.name, ed.CreateStatement)
+}
+
+// DropEvent implements sql.EventDatabase
+func (d Database) DropEvent(ctx *sql.Context, name string) error {
+	return d.shim.Exec(d.name, fmt.Sprintf("DROP EVENT `%s`;", name))
+}
+
+// UpdateEvent implements sql.EventDatabase
+func (d Database) UpdateEvent(ctx *sql.Context, ed sql.EventDefinition) error {
+	err := d.shim.Exec(d.name, fmt.Sprintf("DROP EVENT `%s`;", ed.Name))
+	if err != nil {
+		return err
+	}
+	return d.shim.Exec(d.name, ed.CreateStatement)
+}
+
 // CreateView implements the interface sql.ViewDatabase.
 func (d Database) CreateView(ctx *sql.Context, name string, selectStatement, createViewStmt string) error {
 	return d.shim.Exec(d.name, createViewStmt)

enginetest/queries/charset_collation_engine.go

@@ -43,6 +43,19 @@ type CharsetCollationEngineTestQuery struct {
 // CharsetCollationEngineTests are used to ensure that character sets and collations have the correct behavior over the
 // engine. Return values should all have the `utf8mb4` encoding, as it's returning the internal encoding type.
 var CharsetCollationEngineTests = []CharsetCollationEngineTest{
+	{
+		Name: "Uppercase and lowercase collations",
+		Queries: []CharsetCollationEngineTestQuery{
+			{
+				Query:    "CREATE TABLE test1 (v1 VARCHAR(255) COLLATE utf16_unicode_ci, v2 VARCHAR(255) COLLATE UTF16_UNICODE_CI);",
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+			{
+				Query:    "CREATE TABLE test2 (v1 VARCHAR(255) CHARACTER SET utf16, v2 VARCHAR(255) CHARACTER SET UTF16);",
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+		},
+	},
 	{
 		Name: "Insert multiple character sets",
 		SetUpScript: []string{