Merge branch 'main' of github.com:dolthub/go-mysql-server into elianddb/9325-support-oct-function

Author: elianddb

enginetest/memory_engine_test.go

@@ -226,7 +226,7 @@ func TestSingleScript(t *testing.T) {
 
 	for _, test := range scripts {
 		harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, true, nil)
-		harness.UseServer()
+		//harness.UseServer()
 		engine, err := harness.NewEngine(t)
 		if err != nil {
 			panic(err)

enginetest/queries/insert_queries.go

@@ -2301,9 +2301,13 @@ var InsertScripts = []ScriptTest{
 				Expected: []sql.Row{{1, "Cat"}},
 			},
 			{
-				Query:    "insert into auto_pk values (NULL, 'Dog'),(5, 'Fish'),(NULL, 'Horse') returning pk,name",
+				Query:    "insert into auto_pk values (NULL, 'Dog'),(5, 'Fish'),(NULL, 'Horse') returning *",
 				Expected: []sql.Row{{2, "Dog"}, {5, "Fish"}, {6, "Horse"}},
 			},
+			{
+				Query:    "insert into auto_pk (name) select name from animals where id = 3 returning *",
+				Expected: []sql.Row{{7, "Tiger"}},
+			},
 		},
 	},
 }

enginetest/queries/script_queries.go

@@ -8684,6 +8684,34 @@ where
 			},
 		},
 	},
+	{
+		Name:    "substring function tests with wrappers",
+		Dialect: "mysql",
+		SetUpScript: []string{
+			"create table tbl (t text);",
+			"insert into tbl values ('abcdef');",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select left(t, 3) from tbl;",
+				Expected: []sql.Row{
+					{"abc"},
+				},
+			},
+			{
+				Query: "select right(t, 3) from tbl;",
+				Expected: []sql.Row{
+					{"def"},
+				},
+			},
+			{
+				Query: "select instr(t, 'bcd') from tbl;",
+				Expected: []sql.Row{
+					{2},
+				},
+			},
+		},
+	},
 }
 
 var SpatialScriptTests = []ScriptTest{

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/dolthub/go-icu-regex v0.0.0-20250327004329-6799764f2dad
 	github.com/dolthub/jsonpath v0.0.2-0.20240227200619-19675ab05c71
 	github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81
-	github.com/dolthub/vitess v0.0.0-20250605180032-fa2a634c215b
+	github.com/dolthub/vitess v0.0.0-20250609213846-75541d7ef20a
 	github.com/go-kit/kit v0.10.0
 	github.com/go-sql-driver/mysql v1.7.2-0.20231213112541-0004702b931d
 	github.com/gocraft/dbr/v2 v2.7.2

go.sum

@@ -60,6 +60,8 @@ github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81 h1:7/v8q9X
 github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81/go.mod h1:siLfyv2c92W1eN/R4QqG/+RjjX5W2+gCTRjZxBjI3TY=
 github.com/dolthub/vitess v0.0.0-20250605180032-fa2a634c215b h1:rgZXgRYZ3SZbb4Tz5Y6vnzvB7P9pFvEP+Q7UGfRC9uY=
 github.com/dolthub/vitess v0.0.0-20250605180032-fa2a634c215b/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
+github.com/dolthub/vitess v0.0.0-20250609213846-75541d7ef20a h1:DWQt6KSgrkZYuxzvGflImldau0a3IfINhEGQnFst/pw=
+github.com/dolthub/vitess v0.0.0-20250609213846-75541d7ef20a/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=

sql/analyzer/apply_foreign_keys.go

@@ -122,6 +122,8 @@ func applyForeignKeysToNodes(ctx *sql.Context, a *Analyzer, n sql.Node, cache *f
 		if plan.IsEmptyTable(n.Child) {
 			return n, transform.SameTree, nil
 		}
+		// TODO: UPDATE JOIN can update multiple tables. Because updatableJoinTable does not implement
+		//       sql.ForeignKeyTable, we do not currenly support FK checks for UPDATE JOIN statements.
 		updateDest, err := plan.GetUpdatable(n.Child)
 		if err != nil {
 			return nil, transform.SameTree, err

sql/expression/function/substring.go

@@ -349,8 +349,20 @@ func (l Left) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	switch str := str.(type) {
 	case string:
 		text = []rune(str)
+	case sql.StringWrapper:
+		s, err := str.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		text = []rune(s)
 	case []byte:
 		text = []rune(string(str))
+	case sql.BytesWrapper:
+		b, err := str.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		text = []rune(string(b))
 	case nil:
 		return nil, nil
 	default:
@@ -583,8 +595,20 @@ func (i Instr) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	switch str := str.(type) {
 	case string:
 		text = []rune(str)
+	case sql.StringWrapper:
+		s, err := str.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		text = []rune(s)
 	case []byte:
 		text = []rune(string(str))
+	case sql.BytesWrapper:
+		s, err := str.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		text = []rune(string(s))
 	case nil:
 		return nil, nil
 	default:
@@ -600,8 +624,20 @@ func (i Instr) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	switch substr := substr.(type) {
 	case string:
 		subtext = []rune(substr)
+	case sql.StringWrapper:
+		s, err := substr.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		text = []rune(s)
 	case []byte:
-		subtext = []rune(string(subtext))
+		subtext = []rune(string(substr))
+	case sql.BytesWrapper:
+		s, err := substr.Unwrap(ctx)
+		if err != nil {
+			return nil, err
+		}
+		subtext = []rune(string(s))
 	case nil:
 		return nil, nil
 	default:

sql/plan/update_join.go

@@ -54,6 +54,11 @@ func (u *UpdateJoin) DebugString() string {
 
 // GetUpdatable returns an updateJoinTable which implements sql.UpdatableTable.
 func (u *UpdateJoin) GetUpdatable() sql.UpdatableTable {
+	// TODO: UpdateJoin can update multiple tables, but this interface only allows for a single table.
+	//       Additionally, updatableJoinTable doesn't implement interfaces that other parts of the code
+	//       expect, so UpdateJoins don't always work correctly. For example, because updatableJoinTable
+	//       doesn't implement ForeignKeyTable, UpdateJoin statements don't enforce foreign key checks.
+	//       We should revamp this function so that we can communicate multiple tables being updated.
 	return &updatableJoinTable{
 		updaters: u.Updaters,
 		joinNode: u.Child.(*UpdateSource).Child,

sql/planbuilder/dml.go

@@ -150,12 +150,10 @@ func (b *Builder) buildInsert(inScope *scope, i *ast.Insert) (outScope *scope) {
 	ins := plan.NewInsertInto(db, plan.NewInsertDestination(sch, dest), srcScope.node, isReplace, columns, onDupExprs, ignore)
 	ins.LiteralValueSource = srcLiteralOnly
 
-	if i.Returning != nil {
-		returningExprs := make([]sql.Expression, len(i.Returning))
-		for i, selectExpr := range i.Returning {
-			returningExprs[i] = b.selectExprToExpression(destScope, selectExpr)
-		}
-		ins.Returning = returningExprs
+	if len(i.Returning) > 0 {
+		// TODO: read returning results from outScope instead of ins.Returning so that there is no need to return list
+		// of expressions
+		ins.Returning = b.analyzeSelectList(destScope, destScope, i.Returning)
 	}
 
 	b.validateInsert(ins)
@@ -492,6 +490,11 @@ func (b *Builder) buildDelete(inScope *scope, d *ast.Delete) (outScope *scope) {
 	return
 }
 
+// buildUpdate builds a Update node from |u|. If the update joins tables, the returned Update node's
+// children will have a JoinNode, which will later be replaced by an UpdateJoin node during analysis. We
+// don't create the UpdateJoin node here, because some query plans, such as IN SUBQUERY nodes, require
+// analyzer processing that converts the subquery into a join, and then requires the same logic to
+// create an UpdateJoin node under the original Update node.
 func (b *Builder) buildUpdate(inScope *scope, u *ast.Update) (outScope *scope) {
 	// TODO: this shouldn't be called during ComPrepare or `PREPARE ... FROM ...` statements, but currently it is.
 	//   The end result is that the ComDelete counter is incremented during prepare statements, which is incorrect.
@@ -534,44 +537,26 @@ func (b *Builder) buildUpdate(inScope *scope, u *ast.Update) (outScope *scope) {
 	update.IsProcNested = b.ProcCtx().DbName != ""
 
 	var checks []*sql.CheckConstraint
-	if join, ok := outScope.node.(*plan.JoinNode); ok {
-		// TODO this doesn't work, a lot of the time the top node
-		// is a filter. This would have to go before we build the
-		// filter/accessory nodes. But that errors for a lot of queries.
-		source := plan.NewUpdateSource(
-			join,
-			ignore,
-			updateExprs,
-		)
-		updaters, err := rowUpdatersByTable(b.ctx, source, join)
+	if hasJoinNode(outScope.node) {
+		tablesToUpdate, err := getResolvedTablesToUpdate(b.ctx, update.Child, outScope.node)
 		if err != nil {
 			b.handleErr(err)
 		}
-		updateJoin := plan.NewUpdateJoin(updaters, source)
-		update.Child = updateJoin
-		transform.Inspect(update, func(n sql.Node) bool {
-			// todo maybe this should be later stage
-			switch n := n.(type) {
-			case sql.NameableNode:
-				if _, ok := updaters[n.Name()]; ok {
-					rt := getResolvedTable(n)
-					tableScope := inScope.push()
-					for _, c := range rt.Schema() {
-						tableScope.addColumn(scopeColumn{
-							db:       rt.SqlDatabase.Name(),
-							table:    strings.ToLower(n.Name()),
-							tableId:  tableScope.tables[strings.ToLower(n.Name())],
-							col:      strings.ToLower(c.Name),
-							typ:      c.Type,
-							nullable: c.Nullable,
-						})
-					}
-					checks = append(checks, b.loadChecksFromTable(tableScope, rt.Table)...)
-				}
-			default:
+
+		for _, rt := range tablesToUpdate {
+			tableScope := inScope.push()
+			for _, c := range rt.Schema() {
+				tableScope.addColumn(scopeColumn{
+					db:       rt.SqlDatabase.Name(),
+					table:    strings.ToLower(rt.Name()),
+					tableId:  tableScope.tables[strings.ToLower(rt.Name())],
+					col:      strings.ToLower(c.Name),
+					typ:      c.Type,
+					nullable: c.Nullable,
+				})
 			}
-			return true
-		})
+			checks = append(checks, b.loadChecksFromTable(tableScope, rt.Table)...)
+		}
 	} else {
 		transform.Inspect(update, func(n sql.Node) bool {
 			// todo maybe this should be later stage
@@ -583,46 +568,39 @@ func (b *Builder) buildUpdate(inScope *scope, u *ast.Update) (outScope *scope) {
 	}
 
 	if len(u.Returning) > 0 {
-		returningExprs := make([]sql.Expression, len(u.Returning))
-		for i, selectExpr := range u.Returning {
-			returningExprs[i] = b.selectExprToExpression(outScope, selectExpr)
-		}
-		update.Returning = returningExprs
+		update.Returning = b.analyzeSelectList(outScope, outScope, u.Returning)
 	}
 
 	outScope.node = update.WithChecks(checks)
 	return
 }
 
-// rowUpdatersByTable maps a set of tables to their RowUpdater objects.
-func rowUpdatersByTable(ctx *sql.Context, node sql.Node, ij sql.Node) (map[string]sql.RowUpdater, error) {
-	namesOfTableToBeUpdated := getTablesToBeUpdated(node)
-	resolvedTables := getTablesByName(ij)
-
-	rowUpdatersByTable := make(map[string]sql.RowUpdater)
-	for tableToBeUpdated, _ := range namesOfTableToBeUpdated {
-		resolvedTable, ok := resolvedTables[strings.ToLower(tableToBeUpdated)]
-		if !ok {
-			return nil, plan.ErrUpdateForTableNotSupported.New(tableToBeUpdated)
+// hasJoinNode returns true if |node| or any child is a JoinNode.
+func hasJoinNode(node sql.Node) bool {
+	updateJoinFound := false
+	transform.Inspect(node, func(n sql.Node) bool {
+		if _, ok := n.(*plan.JoinNode); ok {
+			updateJoinFound = true
 		}
+		return !updateJoinFound
+	})
+	return updateJoinFound
+}
 
-		var table = resolvedTable.UnderlyingTable()
+func getResolvedTablesToUpdate(_ *sql.Context, node sql.Node, ij sql.Node) (resolvedTables []*plan.ResolvedTable, err error) {
+	namesOfTablesToBeUpdated := getTablesToBeUpdated(node)
+	resolvedTablesMap := getTablesByName(ij)
 
-		// If there is no UpdatableTable for a table being updated, error out
-		updatable, ok := table.(sql.UpdatableTable)
-		if !ok && updatable == nil {
+	for tableToBeUpdated, _ := range namesOfTablesToBeUpdated {
+		resolvedTable, ok := resolvedTablesMap[strings.ToLower(tableToBeUpdated)]
+		if !ok {
 			return nil, plan.ErrUpdateForTableNotSupported.New(tableToBeUpdated)
 		}
 
-		keyless := sql.IsKeyless(updatable.Schema())
-		if keyless {
-			return nil, sql.ErrUnsupportedFeature.New("error: keyless tables unsupported for UPDATE JOIN")
-		}
-
-		rowUpdatersByTable[tableToBeUpdated] = updatable.Updater(ctx)
+		resolvedTables = append(resolvedTables, resolvedTable)
 	}
 
-	return rowUpdatersByTable, nil
+	return resolvedTables, nil
 }
 
 // getTablesByName takes a node and returns all found resolved tables in a map.

sql/planbuilder/project.go

@@ -29,8 +29,8 @@ func (b *Builder) analyzeProjectionList(inScope, outScope *scope, selectExprs as
 	b.analyzeSelectList(inScope, outScope, selectExprs)
 }
 
-func (b *Builder) analyzeSelectList(inScope, outScope *scope, selectExprs ast.SelectExprs) {
-	// todo ideally we would not create new expressions here.
+func (b *Builder) analyzeSelectList(inScope, outScope *scope, selectExprs ast.SelectExprs) (expressions []sql.Expression) {
+	// TODO: ideally we would not create new expressions here.
 	// we want to in-place identify aggregations, expand stars.
 	// use inScope to construct projections for projScope
 
@@ -160,6 +160,7 @@ func (b *Builder) analyzeSelectList(inScope, outScope *scope, selectExprs ast.Se
 	}
 
 	inScope.parent = tempScope.parent
+	return exprs
 }
 
 // selectExprToExpression binds dependencies in a scalar expression in a SELECT clause.