Add feature LIKE & NOT LIKE condition.

README.md

@@ -245,6 +245,8 @@ One common reason to use this is to prevent string concatenation in a loop.
 * Gte
 * Lt
 * Lte
+* Like
+* NotLike
 
 ```go
 dbr.And(

condition.go

@@ -1,6 +1,9 @@
 package dbr
 
-import "reflect"
+import (
+	"fmt"
+	"reflect"
+)
 
 func buildCond(d Dialect, buf Buffer, pred string, cond ...Builder) error {
 	for i, c := range cond {
@@ -117,3 +120,44 @@ func Lte(column string, value interface{}) Builder {
 		return buildCmp(d, buf, "<=", column, value)
 	})
 }
+
+func buildLikeCmp(d Dialect, buf Buffer, pred string, column string, value interface{}) error {
+	if value == nil {
+		return fmt.Errorf("Column %s %s nil is Not Supported", column, pred)
+	}
+
+	v := reflect.ValueOf(value)
+	switch {
+	case v.Kind() == reflect.TypeOf([]rune{}).Kind() && v.Len() != 0:
+		return buildCmp(d, buf, pred, column, string(value.([]rune)))
+
+	case v.Kind() == reflect.TypeOf([0]rune{}).Kind() && v.Len() != 0:
+		return buildCmp(d, buf, pred, column, string(value.([]rune)[:]))
+
+	case v.Kind() == reflect.Slice || v.Kind() == reflect.Array:
+		return fmt.Errorf("Column %s %s Multiple Value is Not Supported", column, pred)
+
+	default:
+		return buildCmp(d, buf, pred, column, value)
+	}
+}
+
+// Lk is `LIKE`.
+// When value is nil, do nothing.
+// When value is a slice, do nothing.
+// Otherwise it will be translated to `LIKE`.
+func Like(column string, value interface{}) Builder {
+	return BuildFunc(func(d Dialect, buf Buffer) error {
+		return buildLikeCmp(d, buf, "LIKE", column, value)
+	})
+}
+
+// Nlk is `NOT LIKE`.
+// When value is nil, do nothing.
+// When value is a slice, do nothing.
+// Otherwise it will be translated to `NOT LIKE`.
+func NotLike(column string, value interface{}) Builder {
+	return BuildFunc(func(d Dialect, buf Buffer) error {
+		return buildLikeCmp(d, buf, "NOT LIKE", column, value)
+	})
+}

condition_test.go

@@ -12,61 +12,134 @@ func TestCondition(t *testing.T) {
 		cond  Builder
 		query string
 		value []interface{}
+		isErr bool
 	}{
 		{
 			cond:  Eq("col", 1),
 			query: "`col` = ?",
 			value: []interface{}{1},
+			isErr: false,
 		},
 		{
 			cond:  Eq("col", nil),
 			query: "`col` IS NULL",
 			value: nil,
+			isErr: false,
 		},
 		{
 			cond:  Eq("col", []int{}),
 			query: "0",
 			value: nil,
+			isErr: false,
 		},
 		{
 			cond:  Neq("col", 1),
 			query: "`col` != ?",
 			value: []interface{}{1},
+			isErr: false,
 		},
 		{
 			cond:  Neq("col", nil),
 			query: "`col` IS NOT NULL",
 			value: nil,
+			isErr: false,
 		},
 		{
 			cond:  Gt("col", 1),
 			query: "`col` > ?",
 			value: []interface{}{1},
+			isErr: false,
 		},
 		{
 			cond:  Gte("col", 1),
 			query: "`col` >= ?",
 			value: []interface{}{1},
+			isErr: false,
 		},
 		{
 			cond:  Lt("col", 1),
 			query: "`col` < ?",
 			value: []interface{}{1},
+			isErr: false,
 		},
 		{
 			cond:  Lte("col", 1),
 			query: "`col` <= ?",
 			value: []interface{}{1},
+			isErr: false,
+		},
+		{
+			cond:  Like("col", 1),
+			query: "`col` LIKE ?",
+			value: []interface{}{1},
+			isErr: false,
+		},
+		{
+			cond:  Like("col", "like"),
+			query: "`col` LIKE ?",
+			value: []interface{}{"like"},
+			isErr: false,
+		},
+		{
+			cond:  Like("col", []rune{'l', 'i', 'k', 'e'}),
+			query: "`col` LIKE ?",
+			value: []interface{}{"like"},
+			isErr: false,
+		},
+		{
+			cond:  Like("col", []int{}),
+			query: "",
+			value: nil,
+			isErr: true,
+		},
+		{
+			cond:  Like("col", nil),
+			query: "",
+			value: nil,
+			isErr: true,
+		},
+		{
+			cond:  NotLike("col", 1),
+			query: "`col` NOT LIKE ?",
+			value: []interface{}{1},
+			isErr: false,
+		},
+		{
+			cond:  NotLike("col", "not like"),
+			query: "`col` NOT LIKE ?",
+			value: []interface{}{"not like"},
+			isErr: false,
+		},
+		{
+			cond:  NotLike("col", []rune{'n', 'o', 't', ' ', 'l', 'i', 'k', 'e'}),
+			query: "`col` NOT LIKE ?",
+			value: []interface{}{"not like"},
+			isErr: false,
+		},
+		{
+			cond:  NotLike("col", []int{}),
+			query: "",
+			value: nil,
+			isErr: true,
+		},
+		{
+			cond:  NotLike("col", nil),
+			query: "",
+			value: nil,
+			isErr: true,
 		},
 		{
 			cond:  And(Lt("a", 1), Or(Gt("b", 2), Neq("c", 3))),
 			query: "(`a` < ?) AND ((`b` > ?) OR (`c` != ?))",
 			value: []interface{}{1, 2, 3},
+			isErr: false,
 		},
 	} {
 		buf := NewBuffer()
 		err := test.cond.Build(dialect.MySQL, buf)
-		assert.NoError(t, err)
+		if !test.isErr {
+			assert.NoError(t, err)
+		}
 		assert.Equal(t, test.query, buf.String())
 		assert.Equal(t, test.value, buf.Value())
 	}