Unwrap inputs to REGEXP_LIKE, REPLACE, and RPAD/LPAD functions.

Author: nicktobey

enginetest/engine_only_test.go

@@ -717,7 +717,8 @@ func TestCollationCoercion(t *testing.T) {
 
 func TestRegex(t *testing.T) {
 	harness := enginetest.NewDefaultMemoryHarness()
-	harness.Setup(setup.SimpleSetup...)
+	setupsScripts := append(setup.SimpleSetup, queries.RegexSetup)
+	harness.Setup(setupsScripts...)
 	engine, err := harness.NewEngine(t)
 	require.NoError(t, err)
 	defer engine.Close()

enginetest/enginetests.go

@@ -3046,7 +3046,7 @@ func TestRenameColumn(t *testing.T, harness Harness) {
 		TestQueryWithContext(t, ctx, e, harness, "ALTER TABLE mydb.tabletest RENAME COLUMN s TO i1", []sql.Row{{types.NewOkResult(0)}}, nil, nil, nil)
 		TestQueryWithContext(t, ctx, e, harness, "SHOW FULL COLUMNS FROM mydb.tabletest", []sql.Row{
 			{"i", "int", nil, "NO", "PRI", nil, "", "", ""},
-			{"i1", "varchar(20)", "utf8mb4_0900_bin", "NO", "", nil, "", "", ""},
+			{"i1", "text", "utf8mb4_0900_bin", "NO", "", nil, "", "", ""},
 		}, nil, nil, nil)
 	})
 }

enginetest/queries/queries.go

@@ -6772,6 +6772,10 @@ SELECT * FROM cte WHERE  d = 2;`,
 		Query:    "select replace(s, 'row', '') from mytable order by i",
 		Expected: []sql.Row{{"first "}, {"second "}, {"third "}},
 	},
+	{
+		Query:    "select replace(s, 'row', '') from tabletest order by i",
+		Expected: []sql.Row{{"first "}, {"second "}, {"third "}},
+	},
 	{
 		Query:    "select rpad(s, 13, ' ') from mytable order by i",
 		Expected: []sql.Row{{"first row    "}, {"second row   "}, {"third row    "}},
@@ -6780,6 +6784,10 @@ SELECT * FROM cte WHERE  d = 2;`,
 		Query:    "select lpad(s, 13, ' ') from mytable order by i",
 		Expected: []sql.Row{{"    first row"}, {"   second row"}, {"    third row"}},
 	},
+	{
+		Query:    "select lpad(s, 13, ' ') from tabletest order by i",
+		Expected: []sql.Row{{"    first row"}, {"   second row"}, {"    third row"}},
+	},
 	{
 		Query:    "select sqrt(i) from mytable order by i",
 		Expected: []sql.Row{{1.0}, {1.4142135623730951}, {1.7320508075688772}},

enginetest/queries/regex_queries.go

@@ -21,6 +21,7 @@
 package queries
 
 import (
+	"github.com/dolthub/go-mysql-server/enginetest/scriptgen/setup"
 	"gopkg.in/src-d/go-errors.v1"
 
 	regex "github.com/dolthub/go-icu-regex"
@@ -34,6 +35,13 @@ type RegexTest struct {
 	ExpectedErr *errors.Kind
 }
 
+var RegexSetup = []setup.SetupScript{
+	{
+		"CREATE TABLE tests(pk int primary key, str text, pattern text, flags text);",
+		"INSERT INTO tests VALUES (1, 'testing', 'TESTING', 'ci');",
+	},
+}
+
 var RegexTests = []RegexTest{
 	{
 		Query:    "SELECT REGEXP_LIKE('testing', 'TESTING');",
@@ -55,6 +63,10 @@ var RegexTests = []RegexTest{
 		Query:    "SELECT REGEXP_LIKE('testing', 'TESTING', 'ic');",
 		Expected: []sql.Row{{0}},
 	},
+	{
+		Query:    "SELECT REGEXP_LIKE(str, pattern, flags) from tests;",
+		Expected: []sql.Row{{1}},
+	},
 	{
 		Query:    "SELECT REGEXP_LIKE('testing', 'TESTING' COLLATE utf8mb4_0900_ai_ci);",
 		Expected: []sql.Row{{1}},

enginetest/scriptgen/setup/scripts/tabletest

@@ -1,7 +1,7 @@
 exec
 create table tabletest (
     i int primary key,
-    s varchar(20) not null
+    s text not null
 )
 ----
 

enginetest/scriptgen/setup/setup_data.sg.go

@@ -179,8 +179,12 @@ func (r *RegexpLike) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
+	textStr, _, err := sql.Unwrap[string](ctx, text)
+	if err != nil {
+		return nil, err
+	}
 
-	err = r.re.SetMatchString(ctx, text.(string))
+	err = r.re.SetMatchString(ctx, textStr)
 	if err != nil {
 		return nil, err
 	}
@@ -220,9 +224,13 @@ func compileRegex(ctx *sql.Context, pattern, text, flags sql.Expression, funcNam
 	if err != nil {
 		return nil, err
 	}
+	patternValStr, _, err := sql.Unwrap[string](ctx, patternVal)
+	if err != nil {
+		return nil, err
+	}
 
 	// Empty regex, throw illegal argument
-	if len(patternVal.(string)) == 0 {
+	if len(patternValStr) == 0 {
 		return nil, errors.NewKind("Illegal argument to regular expression.").New()
 	}
 
@@ -250,7 +258,10 @@ func compileRegex(ctx *sql.Context, pattern, text, flags sql.Expression, funcNam
 			return nil, err
 		}
 
-		flagsStr = f.(string)
+		flagsStr, _, err = sql.Unwrap[string](ctx, f)
+		if err != nil {
+			return nil, err
+		}
 		flagsStr, err = consolidateRegexpFlags(flagsStr, funcName)
 		if err != nil {
 			return nil, err
@@ -279,7 +290,7 @@ func compileRegex(ctx *sql.Context, pattern, text, flags sql.Expression, funcNam
 		ctx.Warn(1193, `System variable for regular expressions "regexp_buffer_size" is missing`)
 	}
 	re := regex.CreateRegex(bufferSize)
-	if err = re.SetRegexString(ctx, patternVal.(string), regexFlags); err != nil {
+	if err = re.SetRegexString(ctx, patternValStr, regexFlags); err != nil {
 		_ = re.Close()
 		return nil, err
 	}

sql/expression/function/regexp_like.go

@@ -280,9 +280,26 @@ func (r *Replace) Eval(
 		return nil, err
 	}
 
-	if fromStr.(string) == "" {
-		return str, nil
+	{
+		str, _, err := sql.Unwrap[string](ctx, str)
+		if err != nil {
+			return nil, err
+		}
+
+		fromStr, _, err := sql.Unwrap[string](ctx, fromStr)
+		if err != nil {
+			return nil, err
+		}
+
+		toStr, _, err := sql.Unwrap[string](ctx, toStr)
+		if err != nil {
+			return nil, err
+		}
+
+		if fromStr == "" {
+			return str, nil
+		}
+
+		return strings.Replace(str, fromStr, toStr, -1), nil
 	}
-
-	return strings.Replace(str.(string), fromStr.(string), toStr.(string), -1), nil
 }

sql/expression/function/reverse_repeat_replace.go

@@ -169,7 +169,19 @@ func (p *Pad) Eval(
 		return nil, err
 	}
 
-	return padString(str.(string), length.(int64), padStr.(string), p.padType)
+	{
+		str, _, err := sql.Unwrap[string](ctx, str)
+		if err != nil {
+			return nil, err
+		}
+
+		padStr, _, err := sql.Unwrap[string](ctx, padStr)
+		if err != nil {
+			return nil, err
+		}
+
+		return padString(str, length.(int64), padStr, p.padType)
+	}
 }
 
 func padString(str string, length int64, padStr string, padType padType) (string, error) {