Merge branch 'main' into zachmu/literals-alt

Author: zachmu

enginetest/join_op_tests.go

@@ -1984,6 +1984,56 @@ SELECT SUM(x) FROM xy WHERE x IN (
 			},
 		},
 	},
+	{
+		name: "string key test",
+		setup: [][]string{
+			{
+				`
+CREATE TABLE testA (
+	id int PRIMARY KEY,
+	supplierkey VARCHAR(100),
+	name VARCHAR(100),
+	product VARCHAR(100),
+	UNIQUE KEY unique_product_supplier_key (product, supplierKey)
+);`,
+				`
+CREATE TABLE testB (
+	id int PRIMARY KEY,
+	vendorkey VARCHAR(100),
+	name VARCHAR(100),
+	supplierkey VARCHAR(100),
+	product VARCHAR(100),
+	UNIQUE KEY unique_product_vendor_key (product,vendorKey)
+);`,
+				"INSERT INTO testA VALUES (1, 'texwin-post-frame', 'Texwin (Post Frame)', 'carports');",
+				"INSERT INTO testA VALUES (2, 'texwin', 'Texwin', 'carports');",
+				"INSERT INTO testB VALUES (1, 'advancebldg', 'Test', 'texwin', 'carports');",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query: `
+SELECT  
+    v.vendorkey AS vendor,
+    v.product,
+    v.supplierkey,
+    s.name      AS supplierName
+FROM   
+    testB AS v
+INNER JOIN 
+    testA AS s
+ON 
+    s.supplierkey = v.supplierkey AND 
+    s.product     = v.product
+WHERE 
+    v.vendorkey = 'advancebldg';
+`,
+				Expected: []sql.Row{
+					{"advancebldg", "carports", "texwin", "Texwin"},
+				},
+			},
+		},
+	},
 }
 
 var rangeJoinOpTests = []JoinOpTests{

enginetest/queries/json_scripts.go

@@ -627,7 +627,7 @@ var JsonScripts = []ScriptTest{
 		SetUpScript: []string{
 			"create table t (pk int primary key, col1 JSON, col2 JSON);",
 			`insert into t values (1, JSON_OBJECT('key1', 1, 'key2', '"abc"'), JSON_ARRAY(3,10,5,17,"z"));`,
-			`insert into t values (2, JSON_OBJECT('key1', 100, 'key2', '"ghi"'), JSON_ARRAY(3,10,5,17,JSON_ARRAY(22,"y",66)));`,
+			`insert into t values (2, JSON_OBJECT('key1', 100, 'key2', 'ghi'), JSON_ARRAY(3,10,5,17,JSON_ARRAY(22,"y",66)));`,
 			`CREATE TABLE t2 (i INT PRIMARY KEY, j JSON);`,
 			`INSERT INTO t2 VALUES (0, '{"a": "123", "outer": {"inner": 456}}');`,
 		},
@@ -636,16 +636,23 @@ var JsonScripts = []ScriptTest{
 				Query:    `select col1->'$.key1' from t;`,
 				Expected: []sql.Row{{types.MustJSON("1")}, {types.MustJSON("100")}},
 			},
+			{
+				Query: `select col1->'$.key2' from t;`,
+				Expected: []sql.Row{
+					{types.JSONDocument{Val: "\"abc\""}},
+					{types.JSONDocument{Val: "ghi"}},
+				},
+			},
 			{
 				Query:    `select col1->>'$.key2' from t;`,
-				Expected: []sql.Row{{"abc"}, {"ghi"}},
+				Expected: []sql.Row{{"\"abc\""}, {"ghi"}},
 			},
 			{
 				Query:    `select pk, col1 from t where col1->'$.key1' = 1;`,
 				Expected: []sql.Row{{1, types.MustJSON(`{"key1":1, "key2":"\"abc\""}`)}},
 			},
 			{
-				Query:    `select pk, col1 from t where col1->>'$.key2' = 'abc';`,
+				Query:    `select pk, col1 from t where col1->>'$.key2' = '"abc"';`,
 				Expected: []sql.Row{{1, types.MustJSON(`{"key1":1, "key2":"\"abc\""}`)}},
 			},
 			{

enginetest/queries/queries.go

@@ -5412,6 +5412,12 @@ SELECT * FROM cte WHERE  d = 2;`,
 			},
 		},
 	},
+	{
+		Query: `SELECT COALESCE(CAST('{"a": "one \\n two"}' as json), '');`,
+		Expected: []sql.Row{
+			{"{\"a\": \"one \\n two\"}"},
+		},
+	},
 	{
 		Query: "SELECT concat(s, i) FROM mytable",
 		Expected: []sql.Row{
@@ -5423,7 +5429,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: "SELECT version()",
 		Expected: []sql.Row{
-			{"8.0.23"},
+			{"8.0.31"},
 		},
 	},
 	{
@@ -5819,7 +5825,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: `SHOW VARIABLES WHERE Variable_name = 'version' || variable_name = 'autocommit'`,
 		Expected: []sql.Row{
-			{"autocommit", 1}, {"version", "8.0.23"},
+			{"autocommit", 1}, {"version", "8.0.31"},
 		},
 	},
 	{
@@ -5859,7 +5865,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: "SHOW VARIABLES LIKE 'VERSION'",
 		Expected: []sql.Row{
-			{"version", "8.0.23"},
+			{"version", "8.0.31"},
 		},
 	},
 	{
@@ -9854,6 +9860,18 @@ from typestable`,
 			{"NULL"},
 		},
 	},
+	{
+		Query: `SELECT json_type(json_extract('{"a": 123}', null));`,
+		Expected: []sql.Row{
+			{"NULL"},
+		},
+	},
+	{
+		Query: `SELECT json_type(json_extract('{"a": 123}', '$.a', null));`,
+		Expected: []sql.Row{
+			{"NULL"},
+		},
+	},
 	{
 		Query: "SELECT json_type(cast(cast('2001-01-01 12:34:56.123456' as datetime) as json));",
 		Expected: []sql.Row{

enginetest/queries/transaction_queries.go

@@ -1117,6 +1117,127 @@ var TransactionTests = []TransactionTest{
 			},
 		},
 	},
+	{
+		Name: "certain ddl queries on temporary tables are not implicitly committed",
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:    "/* client a */ create table t (pk int primary key);",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+
+			{
+				Query:    "/* client a */ set @@autocommit = 0;",
+				Expected: []sql.Row{{}},
+			},
+			{
+				Query:    "/* client a */ start transaction;",
+				Expected: []sql.Row{},
+			},
+			{
+				// This should not appear for client b until a transaction is committed
+				Query:    "/* client a */ insert into t values (1), (2), (3);",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 3}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ create temporary table tmp (pk int primary key);",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ insert into tmp values (1), (2), (3);",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 3}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ drop temporary table tmp;",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ create temporary table tmp (pk int primary key);",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				// Oddly, this does implicitly commit the transaction
+				Query:    "/* client a */ drop table tmp;",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				Query: "/* client b */ select * from t;",
+				Expected: []sql.Row{
+					{1},
+					{2},
+					{3},
+				},
+			},
+			{
+				Query:    "/* client a */ delete from t where true;",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 3}}},
+			},
+
+			{
+				// This should commit and reset table t
+				Query:    "/* client a */ start transaction;",
+				Expected: []sql.Row{},
+			},
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ insert into t values (1), (2), (3);",
+				Expected: []sql.Row{{types.OkResult{RowsAffected: 3}}},
+			},
+			{
+				// This should not implicitly commit the transaction
+				Query:    "/* client a */ create temporary table tmp (pk int primary key);",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				Query:    "/* client b */ select * from t;",
+				Expected: []sql.Row{},
+			},
+			{
+				// TODO: turns out we can't alter temporary tables; unskip tests when that is fixed
+				// Oddly, this does implicitly commit the transaction
+				Skip:     true,
+				Query:    "/* client a */ alter table tmp add column j int;",
+				Expected: []sql.Row{{types.OkResult{}}},
+			},
+			{
+				// TODO: turns out we can't alter temporary tables; unskip tests when that is fixed
+				Query: "/* client b */ select * from t;",
+				Skip:  true,
+				Expected: []sql.Row{
+					{1},
+					{2},
+					{3},
+				},
+			},
+		},
+	},
 	{
 		Name: "alter table queries are implicitly committed",
 		Assertions: []ScriptTestAssertion{

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-20250417230335-b8d80bc39341
+	github.com/dolthub/vitess v0.0.0-20250423221552-f731ee5c5379
 	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

@@ -64,6 +64,8 @@ github.com/dolthub/vitess v0.0.0-20250414165810-f0031a6472b7 h1:4Y043kZgAH1WhOER
 github.com/dolthub/vitess v0.0.0-20250414165810-f0031a6472b7/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
 github.com/dolthub/vitess v0.0.0-20250417230335-b8d80bc39341 h1:qebIGlJEgi/mSXVZ39P77cklPuuIl8gApyTVMnKm79s=
 github.com/dolthub/vitess v0.0.0-20250417230335-b8d80bc39341/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
+github.com/dolthub/vitess v0.0.0-20250423221552-f731ee5c5379 h1:3nPFx23Ol0djIPf9rDw/y38yEn1BXqTXOUkYrWfxrEI=
+github.com/dolthub/vitess v0.0.0-20250423221552-f731ee5c5379/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=

processlist.go

@@ -113,6 +113,9 @@ func (pl *ProcessList) BeginQuery(
 	ctx *sql.Context,
 	query string,
 ) (*sql.Context, error) {
+	if ctx.IsInterpreted() {
+		return ctx, nil
+	}
 	pl.mu.Lock()
 	defer pl.mu.Unlock()
 
@@ -144,6 +147,9 @@ func (pl *ProcessList) BeginQuery(
 }
 
 func (pl *ProcessList) EndQuery(ctx *sql.Context) {
+	if ctx.IsInterpreted() {
+		return
+	}
 	pl.mu.Lock()
 	defer pl.mu.Unlock()
 	id := ctx.Session.ID()
@@ -177,6 +183,9 @@ func (pl *ProcessList) EndQuery(ctx *sql.Context) {
 // bracketed with EndOperation(). Should certainly be used for any
 // Handler callbacks which may access the database, like Prepare.
 func (pl *ProcessList) BeginOperation(ctx *sql.Context) (*sql.Context, error) {
+	if ctx.IsInterpreted() {
+		return ctx, nil
+	}
 	pl.mu.Lock()
 	defer pl.mu.Unlock()
 	id := ctx.Session.ID()
@@ -193,6 +202,9 @@ func (pl *ProcessList) BeginOperation(ctx *sql.Context) (*sql.Context, error) {
 }
 
 func (pl *ProcessList) EndOperation(ctx *sql.Context) {
+	if ctx.IsInterpreted() {
+		return
+	}
 	pl.mu.Lock()
 	defer pl.mu.Unlock()
 	id := ctx.Session.ID()

server/handler.go

@@ -673,9 +673,14 @@ func (h *Handler) resultForDefaultIter(ctx *sql.Context, c *mysql.Conn, schema s
 	timer := time.NewTimer(waitTime)
 	defer timer.Stop()
 
-	// Wrap the callback to include a BytesBuffer.Reset() to clean out rows that have already been spooled
+	// Wrap the callback to include a BytesBuffer.Reset() for non-cursor requests, to
+	// clean out rows that have already been spooled.
 	resetCallback := func(r *sqltypes.Result, more bool) error {
-		defer buf.Reset()
+		// A server-side cursor allows the caller to fetch results cached on the server-side,
+		// so if a cursor exists, we can't release the buffer memory yet.
+		if c.StatusFlags&uint16(mysql.ServerCursorExists) != 0 {
+			defer buf.Reset()
+		}
 		return callback(r, more)
 	}
 

sql/analyzer/fix_exec_indexes.go

@@ -514,6 +514,10 @@ func (s *idxScope) visitSelf(n sql.Node) error {
 			newCheck.Expr = newE
 			s.checks = append(s.checks, &newCheck)
 		}
+		for _, r := range n.Returning {
+			newE := fixExprToScope(r, srcScope)
+			s.expressions = append(s.expressions, newE)
+		}
 	case *plan.LoadData:
 		scope := &idxScope{}
 		scope.addSchema(n.DestSch)
@@ -556,6 +560,10 @@ func (s *idxScope) finalizeSelf(n sql.Node) (sql.Node, error) {
 		nn.Returning = s.expressions[len(n.OnDupExprs):]
 		return nn.WithChecks(s.checks), nil
 	default:
+		if nn, ok := n.(*plan.Update); ok {
+			nn.Returning = s.expressions
+		}
+
 		s.ids = columnIdsForNode(n)
 
 		s.addSchema(n.Schema())

sql/expression/function/coalesce_test.go

@@ -152,6 +152,16 @@ func TestCoalesce(t *testing.T) {
 			typ:      types.Float64,
 			nullable: false,
 		},
+		{
+			name: "coalesce(json({'a': 'a \n b'}), '')",
+			input: []sql.Expression{
+				expression.NewLiteral("{\"a\": \"one \\n two\"}", types.JSON),
+				expression.NewLiteral("", types.LongText),
+			},
+			expected: "{\"a\": \"one \\n two\"}",
+			typ:      types.LongText,
+			nullable: false,
+		},
 		{
 			name: "coalesce(sysInt, sysInt)",
 			input: []sql.Expression{