Add TRIM functionality

go/vt/sqlparser/ast.go

@@ -3529,6 +3529,7 @@ func (*CaseExpr) iExpr()          {}
 func (*ValuesFuncExpr) iExpr()    {}
 func (*ConvertExpr) iExpr()       {}
 func (*SubstrExpr) iExpr()        {}
+func (*TrimExpr) iExpr()          {}
 func (*ConvertUsingExpr) iExpr()  {}
 func (*MatchExpr) iExpr()         {}
 func (*GroupConcatExpr) iExpr()   {}
@@ -4531,6 +4532,48 @@ func (node *SubstrExpr) walkSubtree(visit Visit) error {
 	)
 }
 
+// Options for Trim
+const (
+	Leading  string = "l"
+	Trailing string = "r"
+	Both     string = "b"
+)
+
+type TrimExpr struct {
+	Str     Expr
+	Pattern Expr
+	Dir     string
+}
+
+// Format formats the node
+func (node *TrimExpr) Format(buf *TrackedBuffer) {
+	if node.Dir == Leading {
+		buf.Myprintf("trim(leading %v from %v)", node.Pattern, node.Str)
+	} else if node.Dir == Trailing {
+		buf.Myprintf("trim(trailing %v from %v)", node.Pattern, node.Str)
+	} else {
+		buf.Myprintf("trim(both %v from %v)", node.Pattern, node.Str)
+	}
+}
+
+func (node *TrimExpr) replace(from, to Expr) bool {
+	if replaceExprs(from, to, &node.Pattern) {
+		return true
+	}
+	if replaceExprs(from, to, &node.Str) {
+		return true
+	}
+
+	return false
+}
+
+func (node *TrimExpr) walkSubtree(visit Visit) error {
+	if node == nil || node.Str == nil {
+		return nil
+	}
+	return Walk(visit, node.Str, node.Pattern)
+}
+
 // ConvertExpr represents a call to CONVERT(expr, type)
 // or it's equivalent CAST(expr AS type). Both are rewritten to the former.
 type ConvertExpr struct {

go/vt/sqlparser/parse_test.go

@@ -2643,8 +2643,8 @@ func TestKeywords(t *testing.T) {
 			input:  "select /* share and mode as cols */ share, mode from t where share = 'foo'",
 			output: "select /* share and mode as cols */ `share`, `mode` from t where `share` = 'foo'",
 		}, {
-			input:  "select /* unused keywords as cols */ write, virtual from t where trailing = 'foo'",
-			output: "select /* unused keywords as cols */ `write`, `virtual` from t where `trailing` = 'foo'",
+			input:  "select /* unused keywords as cols */ write, virtual from t where varcharacter = 'foo'",
+			output: "select /* unused keywords as cols */ `write`, `virtual` from t where `varcharacter` = 'foo'",
 		}, {
 			input:  "insert into x (status) values (42)",
 			output: "insert into x(`status`) values (42)",
@@ -3489,6 +3489,44 @@ func TestLoadData(t *testing.T) {
 	}
 }
 
+func TestTrim(t *testing.T) {
+	testCases := []parseTest{
+		{
+			input:                `SELECT TRIM("foo")`,
+			output:               `select trim(both ' ' from 'foo') from dual`,
+			serializeSelectExprs: true,
+		},
+		{
+			input:                `SELECT TRIM("bar" FROM "foo")`,
+			output:               `select trim(both 'bar' from 'foo') from dual`,
+			serializeSelectExprs: true,
+		},
+		{
+			input:                `SELECT TRIM(LEADING "bar" FROM "foo")`,
+			output:               `select trim(leading 'bar' from 'foo') from dual`,
+			serializeSelectExprs: true,
+		},
+		{
+			input:                `SELECT TRIM(TRAILING "bar" FROM "foo")`,
+			output:               `select trim(trailing 'bar' from 'foo') from dual`,
+			serializeSelectExprs: true,
+		},
+		{
+			input:                `SELECT TRIM(BOTH "bar" FROM "foo")`,
+			output:               `select trim(both 'bar' from 'foo') from dual`,
+			serializeSelectExprs: true,
+		},
+		{
+			input:                `SELECT TRIM(TRIM("foobar"))`,
+			output:               `select trim(both ' ' from trim(both ' ' from 'foobar')) from dual`,
+			serializeSelectExprs: true,
+		},
+	}
+	for _, tcase := range testCases {
+		runParseTestCase(t, tcase)
+	}
+}
+
 func TestCreateTableLike(t *testing.T) {
 	normal := "create table a like b"
 	testCases := []struct {