Added regexp_instr and regexp_substr

enginetest/engine_only_test.go

@@ -781,6 +781,47 @@ func TestRegex(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name: "REGEXP caching behavior",
+			SetUpScript: []string{
+				"CREATE TABLE test (v1 TEXT, v2 INT, v3 INT);",
+				"INSERT INTO test VALUES ('abc', 1, 2), ('[d-i]+', 2, 3), ('ghi', 3, 4);",
+			},
+			Assertions: []queries.ScriptTestAssertion{
+				{
+					Query:    "SELECT REGEXP_LIKE('abc def ghi', 'abc') FROM test;",
+					Expected: []sql.Row{{1}, {1}, {1}},
+				},
+				{
+					Query:    "SELECT REGEXP_LIKE('abc def ghi', v1) FROM test;",
+					Expected: []sql.Row{{1}, {1}, {1}},
+				},
+				{
+					Query:    "SELECT REGEXP_INSTR('abc def ghi', '[a-z]+', 1, 2) FROM test;",
+					Expected: []sql.Row{{5}, {5}, {5}},
+				},
+				{
+					Query:    "SELECT REGEXP_INSTR('abc def ghi', v1, 1, 1) FROM test;",
+					Expected: []sql.Row{{1}, {5}, {9}},
+				},
+				{
+					Query:    "SELECT REGEXP_INSTR('abc def ghi', '[a-z]+', v2, v3) FROM test;",
+					Expected: []sql.Row{{5}, {9}, {0}},
+				},
+				{
+					Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 2) FROM test;",
+					Expected: []sql.Row{{"def"}, {"def"}, {"def"}},
+				},
+				{
+					Query:    "SELECT REGEXP_SUBSTR('abc def ghi', v1, 1, 1) FROM test;",
+					Expected: []sql.Row{{"abc"}, {"def"}, {"ghi"}},
+				},
+				{
+					Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', v2, v3) FROM test;",
+					Expected: []sql.Row{{"def"}, {"ghi"}, {nil}},
+				},
+			},
+		},
 	} {
 		enginetest.TestScript(t, harness, test)
 	}

enginetest/queries/regex_queries.go

@@ -2107,4 +2107,52 @@ var RegexTests = []RegexTest{
 		Query:    `SELECT REGEXP_LIKE("abc", "^([ab]*?)(?<!(a))c");`,
 		Expected: []sql.Row{{1}},
 	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'dog');",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'doggo');",
+		Expected: []sql.Row{{0}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'dog', 2);",
+		Expected: []sql.Row{{9}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'dog', 1, 2);",
+		Expected: []sql.Row{{9}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}');",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}');",
+		Expected: []sql.Row{{8}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'dog', 1, -1, 0);",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "SELECT REGEXP_INSTR('dog cat dog', 'dog', 1, 1, 1);",
+		Expected: []sql.Row{{4}},
+	},
+	{
+		Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+');",
+		Expected: []sql.Row{{"abc"}},
+	},
+	{
+		Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3);",
+		Expected: []sql.Row{{"ghi"}},
+	},
+	{
+		Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 2, 2);",
+		Expected: []sql.Row{{"def"}},
+	},
+	{
+		Query:    "SELECT REGEXP_SUBSTR('abc def ghi', '[j-z]+');",
+		Expected: []sql.Row{{nil}},
+	},
 }

go.mod

@@ -3,7 +3,7 @@ module github.com/dolthub/go-mysql-server
 require (
 	github.com/cespare/xxhash/v2 v2.2.0
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-icu-regex v0.0.0-20241215010122-db690dd53c90
+	github.com/dolthub/go-icu-regex v0.0.0-20250303123116-549b8d7cad00
 	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-20250228011932-c4f6bba87730

go.sum

@@ -52,16 +52,12 @@ github.com/denisenkom/go-mssqldb v0.10.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2 h1:u3PMzfF8RkKd3lB9pZ2bfn0qEG+1Gms9599cr0REMww=
 github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2/go.mod h1:mIEZOHnFx4ZMQeawhw9rhsj+0zwQj7adVsnBX7t+eKY=
-github.com/dolthub/go-icu-regex v0.0.0-20241215010122-db690dd53c90 h1:Sni8jrP0sy/w9ZYXoff4g/ixe+7bFCZlfCqXKJSU+zM=
-github.com/dolthub/go-icu-regex v0.0.0-20241215010122-db690dd53c90/go.mod h1:ylU4XjUpsMcvl/BKeRRMXSH7e7WBrPXdSLvnRJYrxEA=
+github.com/dolthub/go-icu-regex v0.0.0-20250303123116-549b8d7cad00 h1:rh2ij2yTYKJWlX+c8XRg4H5OzqPewbU1lPK8pcfVmx8=
+github.com/dolthub/go-icu-regex v0.0.0-20250303123116-549b8d7cad00/go.mod h1:ylU4XjUpsMcvl/BKeRRMXSH7e7WBrPXdSLvnRJYrxEA=
 github.com/dolthub/jsonpath v0.0.2-0.20240227200619-19675ab05c71 h1:bMGS25NWAGTEtT5tOBsCuCrlYnLRKpbJVJkDbrTRhwQ=
 github.com/dolthub/jsonpath v0.0.2-0.20240227200619-19675ab05c71/go.mod h1:2/2zjLQ/JOOSbbSboojeg+cAwcRV0fDLzIiWch/lhqI=
 github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81 h1:7/v8q9XGFa6q5Ap4Z/OhNkAMBaK5YeuEzwJt+NZdhiE=
 github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81/go.mod h1:siLfyv2c92W1eN/R4QqG/+RjjX5W2+gCTRjZxBjI3TY=
-github.com/dolthub/vitess v0.0.0-20250123002143-3b45b8cacbfa h1:kyoPzxViSXAyqfO0Mab7Qo1UogFIrxZKKyBU6kBOl+E=
-github.com/dolthub/vitess v0.0.0-20250123002143-3b45b8cacbfa/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
-github.com/dolthub/vitess v0.0.0-20250214225328-a0ed4612b41c h1:YsZuBsU5wKmwrXGfzhW6/a+XzP/LWfzayXC3nCz/kqQ=
-github.com/dolthub/vitess v0.0.0-20250214225328-a0ed4612b41c/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
 github.com/dolthub/vitess v0.0.0-20250228011932-c4f6bba87730 h1:GtlMVB7+Z7fZZj7BHRFd2rzxZ574dJ8cB/EHWdq1kbY=
 github.com/dolthub/vitess v0.0.0-20250228011932-c4f6bba87730/go.mod h1:1gQZs/byeHLMSul3Lvl3MzioMtOW1je79QYGyi2fd70=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=

sql/expression/function/regexp_instr.go

@@ -0,0 +1,266 @@
+// Copyright 2025 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package function
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	regex "github.com/dolthub/go-icu-regex"
+
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/expression"
+	"github.com/dolthub/go-mysql-server/sql/types"
+)
+
+// RegexpInstr implements the REGEXP_INSTR function.
+// https://dev.mysql.com/doc/refman/8.0/en/regexp.html#function_regexp-instr
+type RegexpInstr struct {
+	Text         sql.Expression
+	Pattern      sql.Expression
+	Position     sql.Expression
+	Occurrence   sql.Expression
+	ReturnOption sql.Expression
+	Flags        sql.Expression
+
+	cachedVal   any
+	cacheRegex  bool
+	cacheVal    bool
+	re          regex.Regex
+	compileOnce sync.Once
+	compileErr  error
+}
+
+var _ sql.FunctionExpression = (*RegexpInstr)(nil)
+var _ sql.CollationCoercible = (*RegexpInstr)(nil)
+var _ sql.Disposable = (*RegexpInstr)(nil)
+
+// NewRegexpInstr creates a new RegexpInstr expression.
+func NewRegexpInstr(args ...sql.Expression) (sql.Expression, error) {
+	var r *RegexpInstr
+	switch len(args) {
+	case 6:
+		r = &RegexpInstr{
+			Text:         args[0],
+			Pattern:      args[1],
+			Position:     args[2],
+			Occurrence:   args[3],
+			ReturnOption: args[4],
+			Flags:        args[5],
+		}
+	case 5:
+		r = &RegexpInstr{
+			Text:         args[0],
+			Pattern:      args[1],
+			Position:     args[2],
+			Occurrence:   args[3],
+			ReturnOption: args[4],
+		}
+	case 4:
+		r = &RegexpInstr{
+			Text:         args[0],
+			Pattern:      args[1],
+			Position:     args[2],
+			Occurrence:   args[3],
+			ReturnOption: expression.NewLiteral(0, types.Int32),
+		}
+	case 3:
+		r = &RegexpInstr{
+			Text:         args[0],
+			Pattern:      args[1],
+			Position:     args[2],
+			Occurrence:   expression.NewLiteral(1, types.Int32),
+			ReturnOption: expression.NewLiteral(0, types.Int32),
+		}
+	case 2:
+		r = &RegexpInstr{
+			Text:         args[0],
+			Pattern:      args[1],
+			Position:     expression.NewLiteral(1, types.Int32),
+			Occurrence:   expression.NewLiteral(1, types.Int32),
+			ReturnOption: expression.NewLiteral(0, types.Int32),
+		}
+	default:
+		return nil, sql.ErrInvalidArgumentNumber.New("regexp_instr", "2 to 6", len(args))
+	}
+	return r, nil
+}
+
+// FunctionName implements sql.FunctionExpression
+func (r *RegexpInstr) FunctionName() string {
+	return "regexp_instr"
+}
+
+// Description implements sql.FunctionExpression
+func (r *RegexpInstr) Description() string {
+	return "returns the starting index of the substring."
+}
+
+// Type implements the sql.Expression interface.
+func (r *RegexpInstr) Type() sql.Type { return types.Int32 }
+
+// CollationCoercibility implements the interface sql.CollationCoercible.
+func (r *RegexpInstr) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
+	leftCollation, leftCoercibility := sql.GetCoercibility(ctx, r.Text)
+	rightCollation, rightCoercibility := sql.GetCoercibility(ctx, r.Pattern)
+	return sql.ResolveCoercibility(leftCollation, leftCoercibility, rightCollation, rightCoercibility)
+}
+
+// IsNullable implements the sql.Expression interface.
+func (r *RegexpInstr) IsNullable() bool { return true }
+
+// Children implements the sql.Expression interface.
+func (r *RegexpInstr) Children() []sql.Expression {
+	var result = []sql.Expression{r.Text, r.Pattern, r.Position, r.Occurrence, r.ReturnOption}
+	if r.Flags != nil {
+		result = append(result, r.Flags)
+	}
+	return result
+}
+
+// Resolved implements the sql.Expression interface.
+func (r *RegexpInstr) Resolved() bool {
+	return r.Text.Resolved() && r.Pattern.Resolved() && r.Position.Resolved() && r.Occurrence.Resolved() &&
+		r.ReturnOption.Resolved() && (r.Flags == nil || r.Flags.Resolved())
+}
+
+// WithChildren implements the sql.Expression interface.
+func (r *RegexpInstr) WithChildren(children ...sql.Expression) (sql.Expression, error) {
+	required := 5
+	if r.Flags != nil {
+		required = 6
+	}
+	if len(children) != required {
+		return nil, sql.ErrInvalidChildrenNumber.New(r, len(children), required)
+	}
+	return NewRegexpInstr(children...)
+}
+
+// String implements the sql.Expression interface.
+func (r *RegexpInstr) String() string {
+	var args []string
+	for _, e := range r.Children() {
+		args = append(args, e.String())
+	}
+	return fmt.Sprintf("%s(%s)", r.FunctionName(), strings.Join(args, ","))
+}
+
+// compile handles compilation of the regex.
+func (r *RegexpInstr) compile(ctx *sql.Context, row sql.Row) {
+	r.compileOnce.Do(func() {
+		r.cacheRegex = canBeCached(r.Text, r.Pattern, r.Flags)
+		r.cacheVal = canBeCached(r.Text, r.Pattern, r.Position, r.Occurrence, r.ReturnOption, r.Flags)
+		if r.cacheRegex {
+			r.re, r.compileErr = compileRegex(ctx, r.Pattern, r.Text, r.Flags, r.FunctionName(), row)
+		}
+	})
+	if !r.cacheRegex {
+		if r.re != nil {
+			if r.compileErr = r.re.Close(); r.compileErr != nil {
+				return
+			}
+		}
+		r.re, r.compileErr = compileRegex(ctx, r.Pattern, r.Text, r.Flags, r.FunctionName(), row)
+	}
+}
+
+// Eval implements the sql.Expression interface.
+func (r *RegexpInstr) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("function.RegexpInstr")
+	defer span.End()
+
+	if r.cachedVal != nil {
+		return r.cachedVal, nil
+	}
+
+	r.compile(ctx, row)
+	if r.compileErr != nil {
+		return nil, r.compileErr
+	}
+	if r.re == nil {
+		return nil, nil
+	}
+
+	text, err := r.Text.Eval(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+	if text == nil {
+		return nil, nil
+	}
+	text, _, err = types.LongText.Convert(text)
+	if err != nil {
+		return nil, err
+	}
+
+	pos, err := r.Position.Eval(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+	if pos == nil {
+		return nil, nil
+	}
+	pos, _, err = types.Int32.Convert(pos)
+	if err != nil {
+		return nil, err
+	}
+
+	occurrence, err := r.Occurrence.Eval(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+	if occurrence == nil {
+		return nil, nil
+	}
+	occurrence, _, err = types.Int32.Convert(occurrence)
+	if err != nil {
+		return nil, err
+	}
+
+	returnOption, err := r.ReturnOption.Eval(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+	if returnOption == nil {
+		return nil, nil
+	}
+	returnOption, _, err = types.Int32.Convert(returnOption)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r.re.SetMatchString(ctx, text.(string))
+	if err != nil {
+		return nil, err
+	}
+	index, err := r.re.IndexOf(ctx, int(pos.(int32)), int(occurrence.(int32)), returnOption.(int32) == 1)
+	if err != nil {
+		return nil, err
+	}
+
+	outVal := int32(index)
+	if r.cacheVal {
+		r.cachedVal = outVal
+	}
+	return outVal, nil
+}
+
+// Dispose implements the sql.Disposable interface.
+func (r *RegexpInstr) Dispose() {
+	if r.re != nil {
+		_ = r.re.Close()
+	}
+}