Support array/slice expansion for named SQL parameters in parentheses (#7614)

* feat: support array/slice expansion for named parameters in parentheses

* feat: support array/slice expansion for named parameters in parentheses, add testing

* refactor: Extract slice/array processing logic into independent functions and replace duplicate code

* test: Modify SQL expression test case Vars value type

* refactor(expression): merge conditional branches, add parameter value processing functions and optimize the process

* style: properly formatted

Author: bafflingbug

clause/expression.go

@@ -34,25 +34,7 @@ func (expr Expr) Build(builder Builder) {
 	for _, v := range []byte(expr.SQL) {
 		if v == '?' && len(expr.Vars) > idx {
 			if afterParenthesis || expr.WithoutParentheses {
-				if _, ok := expr.Vars[idx].(driver.Valuer); ok {
-					builder.AddVar(builder, expr.Vars[idx])
-				} else {
-					switch rv := reflect.ValueOf(expr.Vars[idx]); rv.Kind() {
-					case reflect.Slice, reflect.Array:
-						if rv.Len() == 0 {
-							builder.AddVar(builder, nil)
-						} else {
-							for i := 0; i < rv.Len(); i++ {
-								if i > 0 {
-									builder.WriteByte(',')
-								}
-								builder.AddVar(builder, rv.Index(i).Interface())
-							}
-						}
-					default:
-						builder.AddVar(builder, expr.Vars[idx])
-					}
-				}
+				processValue(builder, expr.Vars[idx])
 			} else {
 				builder.AddVar(builder, expr.Vars[idx])
 			}
@@ -130,7 +112,11 @@ func (expr NamedExpr) Build(builder Builder) {
 		} else if v == ' ' || v == ',' || v == ')' || v == '"' || v == '\'' || v == '`' || v == '\r' || v == '\n' || v == ';' {
 			if inName {
 				if nv, ok := namedMap[string(name)]; ok {
-					builder.AddVar(builder, nv)
+					if afterParenthesis {
+						processValue(builder, nv)
+					} else {
+						builder.AddVar(builder, nv)
+					}
 				} else {
 					builder.WriteByte('@')
 					builder.WriteString(string(name))
@@ -142,25 +128,7 @@ func (expr NamedExpr) Build(builder Builder) {
 			builder.WriteByte(v)
 		} else if v == '?' && len(expr.Vars) > idx {
 			if afterParenthesis {
-				if _, ok := expr.Vars[idx].(driver.Valuer); ok {
-					builder.AddVar(builder, expr.Vars[idx])
-				} else {
-					switch rv := reflect.ValueOf(expr.Vars[idx]); rv.Kind() {
-					case reflect.Slice, reflect.Array:
-						if rv.Len() == 0 {
-							builder.AddVar(builder, nil)
-						} else {
-							for i := 0; i < rv.Len(); i++ {
-								if i > 0 {
-									builder.WriteByte(',')
-								}
-								builder.AddVar(builder, rv.Index(i).Interface())
-							}
-						}
-					default:
-						builder.AddVar(builder, expr.Vars[idx])
-					}
-				}
+				processValue(builder, expr.Vars[idx])
 			} else {
 				builder.AddVar(builder, expr.Vars[idx])
 			}
@@ -188,6 +156,31 @@ func (expr NamedExpr) Build(builder Builder) {
 	}
 }
 
+// processValue handles different value types appropriately for SQL parameter binding
+// It checks for driver.Valuer first, then handles slices/arrays, and finally adds single values
+func processValue(builder Builder, value interface{}) {
+	if _, ok := value.(driver.Valuer); ok {
+		builder.AddVar(builder, value)
+		return
+	}
+
+	switch rv := reflect.ValueOf(value); rv.Kind() {
+	case reflect.Slice, reflect.Array:
+		if rv.Len() == 0 {
+			builder.AddVar(builder, nil)
+		} else {
+			for i := 0; i < rv.Len(); i++ {
+				if i > 0 {
+					builder.WriteByte(',')
+				}
+				builder.AddVar(builder, rv.Index(i).Interface())
+			}
+		}
+	default:
+		builder.AddVar(builder, value)
+	}
+}
+
 // IN Whether a value is within a set of values
 type IN struct {
 	Column interface{}

clause/expression_test.go

@@ -85,6 +85,16 @@ func TestNamedExpr(t *testing.T) {
 		Vars:         []interface{}{NamedArgument{Name1: "jinzhu", Base: Base{Name2: "jinzhu2"}}},
 		Result:       "@@test AND name1 = ? AND name2 = ? AND name3 = ? @notexist",
 		ExpectedVars: []interface{}{"jinzhu", "jinzhu2", "jinzhu"},
+	}, {
+		SQL:          "name in (@names)",
+		Vars:         []interface{}{map[string]interface{}{"names": []interface{}{"jinzhu", "jinzhu2"}}},
+		Result:       "name in (?,?)",
+		ExpectedVars: []interface{}{"jinzhu", "jinzhu2"},
+	}, {
+		SQL:          "name in (@names)",
+		Vars:         []interface{}{map[string]interface{}{"names": "jinzhu"}},
+		Result:       "name in (?)",
+		ExpectedVars: []interface{}{"jinzhu"},
 	}, {
 		SQL:    "create table ? (? ?, ? ?)",
 		Vars:   []interface{}{},