Merge pull request #185 from upper/issue-176-v2

Using Raw and Function in update statements.

builder/convert.go

@@ -131,6 +131,28 @@ func (tu *templateWithUtils) ToWhereWithArguments(term interface{}) (where exql.
 	panic(fmt.Sprintf("Unknown condition type %T", term))
 }
 
+func (tu *templateWithUtils) PlaceholderValue(in interface{}) (exql.Fragment, []interface{}) {
+	switch t := in.(type) {
+	case db.RawValue:
+		return exql.RawValue(t.String()), nil
+	case db.Function:
+		fnName := t.Name()
+		fnArgs := []interface{}{}
+
+		args := tu.ToInterfaceArguments(t.Arguments())
+		fragments := []string{}
+		for i := range args {
+			frag, args := tu.PlaceholderValue(args[i])
+			fragments = append(fragments, frag.Compile(tu.Template))
+			fnArgs = append(fnArgs, args...)
+		}
+		return exql.RawValue(fnName + `(` + strings.Join(fragments, `, `) + `)`), fnArgs
+	default:
+		// Value must be escaped.
+		return sqlPlaceholder, []interface{}{in}
+	}
+}
+
 // ToInterfaceArguments converts the given value into an array of interfaces.
 func (tu *templateWithUtils) ToInterfaceArguments(value interface{}) (args []interface{}) {
 	if value == nil {

builder/update.go

@@ -20,17 +20,26 @@ func (qu *updater) Set(terms ...interface{}) Updater {
 	if len(terms) == 1 {
 		ff, vv, _ := Map(terms[0])
 
-		cvs := make([]exql.Fragment, len(ff))
+		cvs := make([]exql.Fragment, 0, len(ff))
+		args := make([]interface{}, 0, len(vv))
 
 		for i := range ff {
-			cvs[i] = &exql.ColumnValue{
+			cv := &exql.ColumnValue{
 				Column:   exql.ColumnWithName(ff[i]),
 				Operator: qu.builder.t.AssignmentOperator,
-				Value:    sqlPlaceholder,
 			}
+
+			var localArgs []interface{}
+			cv.Value, localArgs = qu.builder.t.PlaceholderValue(vv[i])
+
+			args = append(args, localArgs...)
+			cvs = append(cvs, cv)
 		}
+
+		args = append(args, qu.arguments...)
+
 		qu.columnValues.Insert(cvs...)
-		qu.arguments = append(qu.arguments, vv...)
+		qu.arguments = append(qu.arguments, args...)
 	} else if len(terms) > 1 {
 		cv, arguments := qu.builder.t.ToColumnValues(terms)
 		qu.columnValues.Insert(cv.ColumnValues...)

db.go

@@ -79,6 +79,7 @@ const (
 // care.
 type RawValue interface {
 	fmt.Stringer
+	Raw() string
 }
 
 // Function interface defines methods for representing database functions.
@@ -153,10 +154,14 @@ type rawValue struct {
 	v string
 }
 
-func (r rawValue) String() string {
+func (r rawValue) Raw() string {
 	return r.v
 }
 
+func (r rawValue) String() string {
+	return r.Raw()
+}
+
 type compound struct {
 	conds []Compound
 }

internal/sqladapter/testing/adapter.go.tpl

@@ -564,6 +564,49 @@ func TestUpdate(t *testing.T) {
 	// Verifying.
 	assert.Equal(t, value.Name, rowMap["name"])
 
+	if Adapter != "ql" {
+
+		// Updating using raw
+		if err = res.Update(map[string]interface{}{"name": db.Raw("LOWER(name)")}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Pulling it again.
+		err = res.One(&value)
+		assert.NoError(t, err)
+
+		// Verifying.
+		assert.Equal(t, value.Name, strings.ToLower(rowMap["name"].(string)))
+
+		// Updating using raw
+		if err = res.Update(struct {
+			Name db.RawValue `db:"name"`
+		}{db.Raw(`UPPER(name)`)}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Pulling it again.
+		err = res.One(&value)
+		assert.NoError(t, err)
+
+		// Verifying.
+		assert.Equal(t, value.Name, strings.ToUpper(rowMap["name"].(string)))
+
+		// Updating using raw
+		if err = res.Update(struct {
+			Name db.Function `db:"name"`
+		}{db.Func("LOWER", db.Raw("name"))}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Pulling it again.
+		err = res.One(&value)
+		assert.NoError(t, err)
+
+		// Verifying.
+		assert.Equal(t, value.Name, strings.ToLower(rowMap["name"].(string)))
+	}
+
 	// Updating set with a struct
 	rowStruct := struct {
 		Name string `db:"name"`