Allow Raw helper to accept named arguments

mysql/expressions.go

@@ -70,9 +70,22 @@ var DateTimeExp = jet.TimestampExp
 // Does not add sql cast to generated sql builder output.
 var TimestampExp = jet.TimestampExp
 
-// Raw can be used for any unsupported functions, operators or expressions.
-// For example: Raw("current_database()")
-var Raw = jet.Raw
+// RawArgs is type used to pass optional arguments to Raw method
+type RawArgs = map[string]interface{}
+
+var (
+	// Raw can be used for any unsupported functions, operators or expressions.
+	// For example: Raw("current_database()")
+	Raw = jet.Raw
+
+	// Raw helper methods for each of the mysql type
+	RawInt       = jet.RawInt
+	RawFloat     = jet.RawFloat
+	RawString    = jet.RawString
+	RawTime      = jet.RawTime
+	RawTimestamp = jet.RawTimestamp
+	RawDate      = jet.RawDate
+)
 
 // Func can be used to call an custom or as of yet unsupported function in the database.
 var Func = jet.Func

mysql/expressions_test.go

@@ -0,0 +1,56 @@
+package mysql
+
+import (
+	"testing"
+	time2 "time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestRaw(t *testing.T) {
+	assertSerialize(t, Raw("current_database()"), "(current_database())")
+
+	assertSerialize(t, Raw(":first_arg + table.colInt + :second_arg", RawArgs{":first_arg": 11, ":second_arg": 22}),
+		"(? + table.colInt + ?)", 11, 22)
+
+	assertSerialize(t,
+		Int(700).ADD(RawInt("#1 + table.colInt + #2", RawArgs{"#1": 11, "#2": 22})),
+		"(? + (? + table.colInt + ?))",
+		int64(700), 11, 22)
+}
+
+func TestRawDuplicateArguments(t *testing.T) {
+	assertSerialize(t, Raw(":arg + table.colInt + :arg", RawArgs{":arg": 11}),
+		"(? + table.colInt + ?)", 11, 11)
+
+	assertSerialize(t, Raw("#age + table.colInt + #year + #age + #year + 11", RawArgs{"#age": 11, "#year": 2000}),
+		"(? + table.colInt + ? + ? + ? + 11)", 11, 2000, 11, 2000)
+
+	assertSerialize(t, Raw("#1 + all_types.integer + #2 + #1 + #2 + #3 + #4",
+		RawArgs{"#1": 11, "#2": 22, "#3": 33, "#4": 44}),
+		`(? + all_types.integer + ? + ? + ? + ? + ?)`, 11, 22, 11, 22, 33, 44)
+}
+
+func TestRawInvalidArguments(t *testing.T) {
+	defer func() {
+		r := recover()
+		require.Equal(t, "jet: named argument 'first_arg' does not appear in raw query", r)
+	}()
+
+	assertSerialize(t, Raw("table.colInt + :second_arg", RawArgs{"first_arg": 11}), "(table.colInt + ?)", 22)
+}
+
+func TestRawType(t *testing.T) {
+	assertSerialize(t, RawFloat("table.colInt + &float", RawArgs{"&float": 11.22}).EQ(Float(3.14)),
+		"((table.colInt + ?) = ?)", 11.22, 3.14)
+	assertSerialize(t, RawString("table.colStr || str", RawArgs{"str": "doe"}).EQ(String("john doe")),
+		"((table.colStr || ?) = ?)", "doe", "john doe")
+
+	time := time2.Now()
+	assertSerialize(t, RawTime("table.colTime").EQ(TimeT(time)),
+		"((table.colTime) = CAST(? AS TIME))", time)
+	assertSerialize(t, RawTimestamp("table.colTimestamp").EQ(TimestampT(time)),
+		"((table.colTimestamp) = TIMESTAMP(?))", time)
+	assertSerialize(t, RawDate("table.colDate").EQ(DateT(time)),
+		"((table.colDate) = CAST(? AS DATE))", time)
+}

mysql/interval.go

@@ -97,7 +97,7 @@ func INTERVAL(value interface{}, unitType unitType) Interval {
 // INTERVALe creates new temporal interval from expresion and unit type.
 func INTERVALe(expr Expression, unitType unitType) Interval {
 	return jet.NewInterval(jet.ListSerializer{
-		Serializers: []jet.Serializer{expr, jet.Raw(string(unitType))},
+		Serializers: []jet.Serializer{expr, jet.RawWithParent(string(unitType))},
 		Separator:   " ",
 	})
 }

mysql/select_statement_test.go

@@ -136,15 +136,15 @@ LOCK IN SHARE MODE;
 func TestSelect_NOT_EXISTS(t *testing.T) {
 	testutils.AssertStatementSql(t,
 		SELECT(table1ColInt).
-		FROM(table1).
-		WHERE(
-			NOT(EXISTS(
-				SELECT(table2ColInt).
-				FROM(table2).
-				WHERE(
-					table1ColInt.EQ(table2ColInt),
-				),
-		))), `
+			FROM(table1).
+			WHERE(
+				NOT(EXISTS(
+					SELECT(table2ColInt).
+						FROM(table2).
+						WHERE(
+							table1ColInt.EQ(table2ColInt),
+						),
+				))), `
 SELECT table1.col_int AS "table1.col_int"
 FROM db.table1
 WHERE (NOT (EXISTS (