Merge branch 'main' into james/proc

Author: James Cor

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{
@@ -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{

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

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{

sql/expression/function/json/json_extract.go

@@ -102,6 +102,10 @@ func (j *JSONExtract) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			return nil, err
 		}
 
+		if path == nil {
+			return nil, nil
+		}
+
 		results[i], err = types.LookupJSONValue(searchable, path.(string))
 		if err != nil {
 			return nil, fmt.Errorf("failed to extract from expression '%s'; %s", j.JSON.String(), err.Error())

sql/rowexec/transaction_iters.go

@@ -78,7 +78,7 @@ type TransactionCommittingIter struct {
 
 func AddTransactionCommittingIter(ctx *sql.Context, qFlags *sql.QueryFlags, iter sql.RowIter) (sql.RowIter, error) {
 	// TODO: This is a bit of a hack. Need to figure out better relationship between new transaction node and warnings.
-	if qFlags != nil && qFlags.IsSet(sql.QFlagShowWarnings) {
+	if (qFlags != nil && qFlags.IsSet(sql.QFlagShowWarnings)) || ctx.IsInterpreted() {
 		return iter, nil
 	}
 

sql/session.go

@@ -262,6 +262,7 @@ type Context struct {
 	queryTime   time.Time
 	tracer      trace.Tracer
 	rootSpan    trace.Span
+	interpreted bool
 	Version     AnalyzerVersion
 }
 
@@ -335,6 +336,17 @@ func RunWithNowFunc(nowFunc func() time.Time, fn func() error) error {
 	return fn()
 }
 
+// RunInterpreted modifies the context such that all calls to Context.IsInterpreted will return `true`. It is safe to
+// recursively call this.
+func RunInterpreted[T any](ctx *Context, f func(ctx *Context) (T, error)) (T, error) {
+	current := ctx.interpreted
+	ctx.interpreted = true
+	defer func() {
+		ctx.interpreted = current
+	}()
+	return f(ctx)
+}
+
 func swapNowFunc(newNowFunc func() time.Time) func() time.Time {
 	ctxNowFuncMutex.Lock()
 	defer ctxNowFuncMutex.Unlock()
@@ -395,6 +407,13 @@ func (c *Context) ApplyOpts(opts ...ContextOption) {
 // NewEmptyContext returns a default context with default values.
 func NewEmptyContext() *Context { return NewContext(context.TODO()) }
 
+// IsInterpreted returns `true` when this is being called from within RunInterpreted. In such cases, GMS will choose to
+// handle logic differently, as running from within an interpreted function requires different considerations than
+// running in a standard environment.
+func (c *Context) IsInterpreted() bool {
+	return c.interpreted
+}
+
 // Pid returns the process id associated with this context.
 func (c *Context) Pid() uint64 {
 	if c == nil {

sql/types/json_value.go

@@ -43,7 +43,7 @@ func JsonToMySqlString(jsonWrapper sql.JSONWrapper) (string, error) {
 	return marshalToMySqlString(val)
 }
 
-// JsonToMySqlString generates a byte slice representation of a sql.JSONWrapper that is compatible with MySQL's JSON output, including spaces.
+// JsonToMySqlBytes generates a byte slice representation of a sql.JSONWrapper that is compatible with MySQL's JSON output, including spaces.
 func JsonToMySqlBytes(jsonWrapper sql.JSONWrapper) ([]byte, error) {
 	val, err := jsonWrapper.ToInterface()
 	if err != nil {

sql/types/strings.go

@@ -29,7 +29,6 @@ import (
 	"github.com/shopspring/decimal"
 	"gopkg.in/src-d/go-errors.v1"
 
-	"github.com/dolthub/go-mysql-server/internal/strings"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/encodings"
 )
@@ -416,10 +415,6 @@ func ConvertToBytes(ctx context.Context, v interface{}, t sql.StringType, dest [
 		if err != nil {
 			return nil, err
 		}
-		val, err = strings.UnquoteBytes(val)
-		if err != nil {
-			return nil, err
-		}
 		start = 0
 	case sql.Wrapper[string]:
 		unwrapped, err := s.Unwrap(ctx)