Detect slice/array element kinds in Eq/Neq via reflection

Author: Januth Nimnal

clause/expression.go

@@ -234,11 +234,29 @@ type Eq struct {
 	Value  interface{}
 }
 
+// isValueList reports whether value should be rendered as an IN (...) list
+// rather than as a single bind variable.
+//
+// Any slice or array is a list, except for byte slices (including named byte
+// slice types) which databases bind as a single binary value.
+func isValueList(value interface{}) bool {
+	if _, ok := value.(driver.Valuer); ok {
+		return false
+	}
+
+	rv := reflect.ValueOf(value)
+	switch rv.Kind() {
+	case reflect.Slice, reflect.Array:
+		return rv.Type().Elem().Kind() != reflect.Uint8
+	default:
+		return false
+	}
+}
+
 func (eq Eq) Build(builder Builder) {
 	builder.WriteQuoted(eq.Column)
 
-	switch eq.Value.(type) {
-	case []string, []int, []int32, []int64, []uint, []uint32, []uint64, []interface{}:
+	if isValueList(eq.Value) {
 		rv := reflect.ValueOf(eq.Value)
 		if rv.Len() == 0 {
 			builder.WriteString(" IN (NULL)")
@@ -252,7 +270,7 @@ func (eq Eq) Build(builder Builder) {
 			}
 			builder.WriteByte(')')
 		}
-	default:
+	} else {
 		if eqNil(eq.Value) {
 			builder.WriteString(" IS NULL")
 		} else {
@@ -272,8 +290,7 @@ type Neq Eq
 func (neq Neq) Build(builder Builder) {
 	builder.WriteQuoted(neq.Column)
 
-	switch neq.Value.(type) {
-	case []string, []int, []int32, []int64, []uint, []uint32, []uint64, []interface{}:
+	if isValueList(neq.Value) {
 		builder.WriteString(" NOT IN (")
 		rv := reflect.ValueOf(neq.Value)
 		for i := 0; i < rv.Len(); i++ {
@@ -283,7 +300,7 @@ func (neq Neq) Build(builder Builder) {
 			builder.AddVar(builder, rv.Index(i).Interface())
 		}
 		builder.WriteByte(')')
-	default:
+	} else {
 		if eqNil(neq.Value) {
 			builder.WriteString(" IS NOT NULL")
 		} else {

clause/expression_test.go

@@ -160,6 +160,9 @@ func TestNamedExpr(t *testing.T) {
 	}
 }
 
+type namedFloat64s []float64
+type namedBytes []byte
+
 func TestExpression(t *testing.T) {
 	column := "column-name"
 	results := []struct {
@@ -214,6 +217,58 @@ func TestExpression(t *testing.T) {
 			clause.Eq{Column: column, Value: []string{}},
 		},
 		Result: "`column-name` IN (NULL)",
+	}, {
+		// slice element types other than the hard-coded ones in Eq/Neq must
+		// still render as an IN/NOT IN list, not `= (?,?)`
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: []float64{1.5, 2.5}},
+		},
+		ExpectedVars: []interface{}{1.5, 2.5},
+		Result:       "`column-name` IN (?,?)",
+	}, {
+		Expressions: []clause.Expression{
+			clause.Neq{Column: column, Value: []float64{1.5, 2.5}},
+		},
+		ExpectedVars: []interface{}{1.5, 2.5},
+		Result:       "`column-name` NOT IN (?,?)",
+	}, {
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: []int8{1, 2}},
+		},
+		ExpectedVars: []interface{}{int8(1), int8(2)},
+		Result:       "`column-name` IN (?,?)",
+	}, {
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: []bool{true, false}},
+		},
+		ExpectedVars: []interface{}{true, false},
+		Result:       "`column-name` IN (?,?)",
+	}, {
+		// a named slice type must behave the same as its underlying type
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: namedFloat64s{1.5, 2.5}},
+		},
+		ExpectedVars: []interface{}{1.5, 2.5},
+		Result:       "`column-name` IN (?,?)",
+	}, {
+		// []byte is a single value, never a list
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: []byte{1, 2}},
+		},
+		ExpectedVars: []interface{}{[]byte{1, 2}},
+		Result:       "`column-name` = ?",
+	}, {
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: namedBytes{1, 2}},
+		},
+		ExpectedVars: []interface{}{namedBytes{1, 2}},
+		Result:       "`column-name` = ?",
+	}, {
+		// an empty list of any element type must still be IN (NULL)
+		Expressions: []clause.Expression{
+			clause.Eq{Column: column, Value: []float64{}},
+		},
+		Result: "`column-name` IN (NULL)",
 	}, {
 		Expressions: []clause.Expression{
 			clause.Eq{Column: clause.Expr{SQL: "SUM(?)", Vars: []interface{}{clause.Column{Name: "id"}}}, Value: 100},