diff --git a/enginetest/engine_only_test.go b/enginetest/engine_only_test.go
index 8e8866dfd1..4ea075ca3d 100644
--- a/enginetest/engine_only_test.go
+++ b/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)
 	}
diff --git a/enginetest/queries/regex_queries.go b/enginetest/queries/regex_queries.go
index cb82dfeaaa..830ba6fd3f 100644
--- a/enginetest/queries/regex_queries.go
+++ b/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}},
+	},
 }
diff --git a/go.mod b/go.mod
index a25b4c043e..ea2d40f0a0 100644
--- a/go.mod
+++ b/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
diff --git a/go.sum b/go.sum
index 52c0220b6a..e73a8a2d03 100644
--- a/go.sum
+++ b/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=
diff --git a/sql/expression/function/regexp_instr.go b/sql/expression/function/regexp_instr.go
new file mode 100644
index 0000000000..e56593d791
--- /dev/null
+++ b/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()
+	}
+}
diff --git a/sql/expression/function/regexp_like.go b/sql/expression/function/regexp_like.go
index 85eb525aa6..3939a15643 100644
--- a/sql/expression/function/regexp_like.go
+++ b/sql/expression/function/regexp_like.go
@@ -18,7 +18,6 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-	"sync/atomic"
 
 	regex "github.com/dolthub/go-icu-regex"
 	"gopkg.in/src-d/go-errors.v1"
@@ -35,7 +34,8 @@ type RegexpLike struct {
 	Pattern sql.Expression
 	Flags   sql.Expression
 
-	cachedVal   atomic.Value
+	cachedVal   any
+	cacheable   bool
 	re          regex.Regex
 	compileOnce sync.Once
 	compileErr  error
@@ -43,7 +43,7 @@ type RegexpLike struct {
 
 var _ sql.FunctionExpression = (*RegexpLike)(nil)
 var _ sql.CollationCoercible = (*RegexpLike)(nil)
-var _ sql.Closer = (*RegexpLike)(nil)
+var _ sql.Disposable = (*RegexpLike)(nil)
 
 // NewRegexpLike creates a new RegexpLike expression.
 func NewRegexpLike(args ...sql.Expression) (sql.Expression, error) {
@@ -115,6 +115,7 @@ func (r *RegexpLike) WithChildren(children ...sql.Expression) (sql.Expression, e
 	return NewRegexpLike(children...)
 }
 
+// String implements the sql.Expression interface.
 func (r *RegexpLike) String() string {
 	var args []string
 	for _, e := range r.Children() {
@@ -123,10 +124,22 @@ func (r *RegexpLike) String() string {
 	return fmt.Sprintf("%s(%s)", r.FunctionName(), strings.Join(args, ","))
 }
 
-func (r *RegexpLike) compile(ctx *sql.Context) {
+// compile handles compilation of the regex.
+func (r *RegexpLike) compile(ctx *sql.Context, row sql.Row) {
 	r.compileOnce.Do(func() {
-		r.re, r.compileErr = compileRegex(ctx, r.Pattern, r.Text, r.Flags, r.FunctionName(), nil)
+		r.cacheable = canBeCached(r.Text, r.Pattern, r.Flags)
+		if r.cacheable {
+			r.re, r.compileErr = compileRegex(ctx, r.Pattern, r.Text, r.Flags, r.FunctionName(), row)
+		}
 	})
+	if !r.cacheable {
+		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.
@@ -134,12 +147,11 @@ func (r *RegexpLike) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	span, ctx := ctx.Span("function.RegexpLike")
 	defer span.End()
 
-	cached := r.cachedVal.Load()
-	if cached != nil {
-		return cached, nil
+	if r.cachedVal != nil {
+		return r.cachedVal, nil
 	}
 
-	r.compile(ctx)
+	r.compile(ctx, row)
 	if r.compileErr != nil {
 		return nil, r.compileErr
 	}
@@ -174,18 +186,17 @@ func (r *RegexpLike) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		outVal = int8(0)
 	}
 
-	if canBeCached(r.Text) {
-		r.cachedVal.Store(outVal)
+	if r.cacheable {
+		r.cachedVal = outVal
 	}
 	return outVal, nil
 }
 
-// Close implements the sql.Closer interface.
-func (r *RegexpLike) Close(ctx *sql.Context) error {
+// Dispose implements the sql.Disposable interface.
+func (r *RegexpLike) Dispose() {
 	if r.re != nil {
-		return r.re.Close()
+		_ = r.re.Close()
 	}
-	return nil
 }
 
 func compileRegex(ctx *sql.Context, pattern, text, flags sql.Expression, funcName string, row sql.Row) (regex.Regex, error) {
@@ -293,14 +304,24 @@ func consolidateRegexpFlags(flags, funcName string) (string, error) {
 	return flags, nil
 }
 
-func canBeCached(e sql.Expression) bool {
+// canBeCached returns whether the expression(s) can be cached
+func canBeCached(exprs ...sql.Expression) bool {
 	hasCols := false
-	sql.Inspect(e, func(e sql.Expression) bool {
-		switch e.(type) {
-		case *expression.GetField, *expression.UserVar, *expression.SystemVar, *expression.ProcedureParam:
-			hasCols = true
+	for _, expr := range exprs {
+		if expr == nil {
+			continue
 		}
-		return true
-	})
+		sql.Inspect(expr, func(e sql.Expression) bool {
+			switch e.(type) {
+			case *expression.GetField, *expression.UserVar, *expression.SystemVar, *expression.ProcedureParam:
+				hasCols = true
+			default:
+				if nonDet, ok := expr.(sql.NonDeterministicExpression); ok {
+					hasCols = hasCols || nonDet.IsNonDeterministic()
+				}
+			}
+			return true
+		})
+	}
 	return !hasCols
 }
diff --git a/sql/expression/function/regexp_like_test.go b/sql/expression/function/regexp_like_test.go
index d80984d8ea..2a23ee641e 100644
--- a/sql/expression/function/regexp_like_test.go
+++ b/sql/expression/function/regexp_like_test.go
@@ -222,7 +222,7 @@ func TestRegexpLikeWithoutFlags(t *testing.T) {
 				expression.NewLiteral(test.pattern, types.LongText),
 			)
 			require.NoError(t, err)
-			defer f.(*RegexpLike).Close(ctx)
+			defer f.(*RegexpLike).Dispose()
 			res, err := f.Eval(ctx, nil)
 			require.Equal(t, test.expected, res)
 		})
@@ -277,7 +277,7 @@ func TestRegexpLikeWithFlags(t *testing.T) {
 				expression.NewLiteral(test.flags, types.LongText),
 			)
 			require.NoError(t, err)
-			defer f.(*RegexpLike).Close(ctx)
+			defer f.(*RegexpLike).Dispose()
 			res, err := f.Eval(ctx, nil)
 			require.Equal(t, test.expected, res)
 		})
@@ -308,7 +308,7 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	require.NoError(t, err)
 	_, err = f.Eval(ctx, nil)
 	require.True(t, sql.ErrInvalidArgument.Is(err))
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 
 	f, err = NewRegexpLike(
 		expression.NewLiteral(nil, types.Null),
@@ -319,7 +319,7 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	res, err := f.Eval(ctx, nil)
 	require.NoError(t, err)
 	require.Equal(t, nil, res)
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 
 	f, err = NewRegexpLike(
 		expression.NewLiteral("foo", types.LongText),
@@ -330,7 +330,7 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	res, err = f.Eval(ctx, nil)
 	require.NoError(t, err)
 	require.Equal(t, nil, res)
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 
 	f, err = NewRegexpLike(
 		expression.NewLiteral("foo", types.LongText),
@@ -341,7 +341,7 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	res, err = f.Eval(ctx, nil)
 	require.NoError(t, err)
 	require.Equal(t, nil, res)
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 
 	f, err = NewRegexpLike(
 		expression.NewLiteral(nil, types.Null),
@@ -351,7 +351,7 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	res, err = f.Eval(ctx, nil)
 	require.NoError(t, err)
 	require.Equal(t, nil, res)
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 
 	f, err = NewRegexpLike(
 		expression.NewLiteral("foo", types.LongText),
@@ -361,5 +361,5 @@ func TestRegexpLikeNilAndErrors(t *testing.T) {
 	res, err = f.Eval(ctx, nil)
 	require.NoError(t, err)
 	require.Equal(t, nil, res)
-	require.NoError(t, f.(*RegexpLike).Close(ctx))
+	f.(*RegexpLike).Dispose()
 }
diff --git a/sql/expression/function/regexp_substr.go b/sql/expression/function/regexp_substr.go
new file mode 100644
index 0000000000..4493cbc301
--- /dev/null
+++ b/sql/expression/function/regexp_substr.go
@@ -0,0 +1,243 @@
+// 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"
+)
+
+// RegexpSubstr implements the REGEXP_SUBSTR function.
+// https://dev.mysql.com/doc/refman/8.0/en/regexp.html#function_regexp-substr
+type RegexpSubstr struct {
+	Text       sql.Expression
+	Pattern    sql.Expression
+	Position   sql.Expression
+	Occurrence sql.Expression
+	Flags      sql.Expression
+
+	cachedVal   any
+	cacheRegex  bool
+	cacheVal    bool
+	re          regex.Regex
+	compileOnce sync.Once
+	compileErr  error
+}
+
+var _ sql.FunctionExpression = (*RegexpSubstr)(nil)
+var _ sql.CollationCoercible = (*RegexpSubstr)(nil)
+var _ sql.Disposable = (*RegexpSubstr)(nil)
+
+// NewRegexpSubstr creates a new RegexpSubstr expression.
+func NewRegexpSubstr(args ...sql.Expression) (sql.Expression, error) {
+	var r *RegexpSubstr
+	switch len(args) {
+	case 5:
+		r = &RegexpSubstr{
+			Text:       args[0],
+			Pattern:    args[1],
+			Position:   args[2],
+			Occurrence: args[3],
+			Flags:      args[4],
+		}
+	case 4:
+		r = &RegexpSubstr{
+			Text:       args[0],
+			Pattern:    args[1],
+			Position:   args[2],
+			Occurrence: args[3],
+		}
+	case 3:
+		r = &RegexpSubstr{
+			Text:       args[0],
+			Pattern:    args[1],
+			Position:   args[2],
+			Occurrence: expression.NewLiteral(1, types.Int32),
+		}
+	case 2:
+		r = &RegexpSubstr{
+			Text:       args[0],
+			Pattern:    args[1],
+			Position:   expression.NewLiteral(1, types.Int32),
+			Occurrence: expression.NewLiteral(1, types.Int32),
+		}
+	default:
+		return nil, sql.ErrInvalidArgumentNumber.New("regexp_substr", "2 to 5", len(args))
+	}
+	return r, nil
+}
+
+// FunctionName implements sql.FunctionExpression
+func (r *RegexpSubstr) FunctionName() string {
+	return "regexp_substr"
+}
+
+// Description implements sql.FunctionExpression
+func (r *RegexpSubstr) Description() string {
+	return "returns the matching substring."
+}
+
+// Type implements the sql.Expression interface.
+func (r *RegexpSubstr) Type() sql.Type { return types.LongText }
+
+// CollationCoercibility implements the interface sql.CollationCoercible.
+func (r *RegexpSubstr) 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 *RegexpSubstr) IsNullable() bool { return true }
+
+// Children implements the sql.Expression interface.
+func (r *RegexpSubstr) Children() []sql.Expression {
+	var result = []sql.Expression{r.Text, r.Pattern, r.Position, r.Occurrence}
+	if r.Flags != nil {
+		result = append(result, r.Flags)
+	}
+	return result
+}
+
+// Resolved implements the sql.Expression interface.
+func (r *RegexpSubstr) Resolved() bool {
+	return r.Text.Resolved() && r.Pattern.Resolved() && r.Position.Resolved() && r.Occurrence.Resolved() &&
+		(r.Flags == nil || r.Flags.Resolved())
+}
+
+// WithChildren implements the sql.Expression interface.
+func (r *RegexpSubstr) WithChildren(children ...sql.Expression) (sql.Expression, error) {
+	required := 4
+	if r.Flags != nil {
+		required = 5
+	}
+	if len(children) != required {
+		return nil, sql.ErrInvalidChildrenNumber.New(r, len(children), required)
+	}
+	return NewRegexpSubstr(children...)
+}
+
+// String implements the sql.Expression interface.
+func (r *RegexpSubstr) 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 *RegexpSubstr) 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.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 *RegexpSubstr) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("function.RegexpSubstr")
+	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
+	}
+
+	err = r.re.SetMatchString(ctx, text.(string))
+	if err != nil {
+		return nil, err
+	}
+	substring, ok, err := r.re.Substring(ctx, int(pos.(int32)), int(occurrence.(int32)))
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		return nil, nil
+	}
+
+	if r.cacheVal {
+		r.cachedVal = substring
+	}
+	return substring, nil
+}
+
+// Dispose implements the sql.Disposable interface.
+func (r *RegexpSubstr) Dispose() {
+	if r.re != nil {
+		_ = r.re.Close()
+	}
+}
diff --git a/sql/expression/function/registry.go b/sql/expression/function/registry.go
index cdbd365a46..53050e846f 100644
--- a/sql/expression/function/registry.go
+++ b/sql/expression/function/registry.go
@@ -191,8 +191,10 @@ var BuiltIns = []sql.Function{
 	sql.Function1{Name: "quarter", Fn: NewQuarter},
 	sql.Function1{Name: "radians", Fn: NewRadians},
 	sql.FunctionN{Name: "rand", Fn: NewRand},
+	sql.FunctionN{Name: "regexp_instr", Fn: NewRegexpInstr},
 	sql.FunctionN{Name: "regexp_like", Fn: NewRegexpLike},
 	sql.FunctionN{Name: "regexp_replace", Fn: NewRegexpReplace},
+	sql.FunctionN{Name: "regexp_substr", Fn: NewRegexpSubstr},
 	sql.Function2{Name: "repeat", Fn: NewRepeat},
 	sql.Function3{Name: "replace", Fn: NewReplace},
 	sql.Function1{Name: "reverse", Fn: NewReverse},