feat: supprt where in

Author: dongyu

internal/dinosql/gen.go

@@ -66,6 +66,8 @@ type GoQueryValue struct {
 	Name   string
 	Struct *GoStruct
 	Typ    string
+	// LocalSQLQuery 函数内部SQL
+	LocalSQLQuery string
 }
 
 func (v GoQueryValue) EmitStruct() bool {
@@ -513,6 +515,7 @@ func queryImports(r Generateable, settings config.CombinedSettings, filename str
 	}
 
 	if sliceScan() {
+		std["strings"] = struct{}{}
 		pkg["github.com/lib/pq"] = struct{}{}
 	}
 	_, overrideNullTime := overrideTypes["pq.NullTime"]
@@ -1233,9 +1236,10 @@ import (
 {{define "queryCode"}}
 {{range .GoQueries}}
 {{if $.OutputQuery .SourceName}}
+{{if not .Arg.LocalSQLQuery}}
 // {{.ConstantName}} -- name: {{.MethodName}} {{.Cmd}}
 const {{.ConstantName}} = "{{.SQL}}"
-
+{{end}}
 {{if .Arg.EmitStruct}}
 type {{.Arg.Type}} struct { {{- range .Arg.Struct.Fields}}
   {{.Name}} {{.Type}} {{if $.EmitJSONTags}}{{$.Q}}{{.Tag}}{{$.Q}}{{end}}
@@ -1269,16 +1273,20 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ({{.Ret.Ty
 {{range .Comments}}//{{.}}
 {{end -}}
 func (q *Queries) {{.MethodName}}(ctx context.Context, {{.Arg.Pair}}) ([]{{.Ret.Type}}, error) {
+	var items []{{.Ret.Type}}
+	{{if .Arg.LocalSQLQuery}}
+	querySQL := "{{.Arg.LocalSQLQuery}}"
+	{{end}}
   	{{- if $.EmitPreparedQueries}}
-	rows, err := q.query(ctx, q.{{.FieldName}}, {{.ConstantName}}, {{.Arg.Params}})
+	rows, err := q.query(ctx, q.{{.FieldName}},{{if .Arg.LocalSQLQuery}} querySQL {{else}} {{.ConstantName}} {{end}}, {{.Arg.Params}})
   	{{- else}}
-	rows, err := q.db.QueryContext(ctx, {{.ConstantName}}, {{.Arg.Params}})
+	rows, err := q.db.QueryContext(ctx, {{if .Arg.LocalSQLQuery}} querySQL {{else}} {{.ConstantName}} {{end}}, {{.Arg.Params}})
   	{{- end}}
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []{{.Ret.Type}}
+
 	for rows.Next() {
 		var {{.Ret.Name}} {{.Ret.Type}}
 		if err := rows.Scan({{.Ret.Scan}}); err != nil {

internal/mysql/gen.go

@@ -161,20 +161,33 @@ func (r *Result) GoQueries(settings config.CombinedSettings) []dinosql.GoQuery {
 			// Comments:     query.Comments,
 			Meta: query.Meta,
 		}
-
 		if len(query.Params) == 1 {
 			p := query.Params[0]
+
 			gq.Arg = dinosql.GoQueryValue{
-				Name: p.Name,
-				Typ:  p.Typ,
+				Name: p.GetVariableName(),
+				Typ:  p.GetTypeName(),
+			}
+			if p.IsLikeInStmt() {
+				old, newer := p.ReplaceLikeInStmt("\"", "")
+				if old != "" && newer != "" {
+					gq.Arg.LocalSQLQuery = strings.Replace(query.SQL, old, newer, 1)
+				}
 			}
 		} else if len(query.Params) > 1 {
-
 			structInfo := make([]structParams, len(query.Params))
+			localSQLQuery := query.SQL
 			for i := range query.Params {
+				item := query.Params[i]
+				originalName := item.GetVariableName()
+				goTypeName := item.GetTypeName()
+				old, newer := item.ReplaceLikeInStmt("\"", "arg."+strings.Title(originalName))
+				if old != "" && newer != "" {
+					localSQLQuery = strings.Replace(localSQLQuery, old, newer, 1)
+				}
 				structInfo[i] = structParams{
-					originalName: query.Params[i].Name,
-					goType:       query.Params[i].Typ,
+					originalName: originalName,
+					goType:       goTypeName,
 				}
 			}
 
@@ -183,6 +196,9 @@ func (r *Result) GoQueries(settings config.CombinedSettings) []dinosql.GoQuery {
 				Name:   "arg",
 				Struct: r.columnsToStruct(gq.MethodName+"Params", structInfo, settings),
 			}
+			if localSQLQuery != query.SQL {
+				gq.Arg.LocalSQLQuery = localSQLQuery
+			}
 		}
 
 		if len(query.Columns) == 1 {

internal/mysql/param.go

@@ -15,6 +15,56 @@ type Param struct {
 	OriginalName string
 	Name         string
 	Typ          string
+	// ComparisonExpr 比较表达式
+	ComparisonExpr *sqlparser.ComparisonExpr
+}
+
+// IsLikeInStmt 是否为in/not in表达式
+func (p Param) IsLikeInStmt() bool {
+	if p.ComparisonExpr == nil {
+		return false
+	}
+	op := p.ComparisonExpr.Operator
+	return op == sqlparser.InStr || op == sqlparser.NotInStr
+}
+
+// ReplaceLikeInStmt like stmt reaplce
+func (p Param) ReplaceLikeInStmt(quote string, paramsName string) (string, string) {
+	if !p.IsLikeInStmt() {
+		return "", ""
+	}
+	op := p.ComparisonExpr.Operator
+	var old string
+	if op == sqlparser.InStr {
+		old = fmt.Sprintf("%s in (?)", p.Name)
+
+	}
+	if op == sqlparser.NotInStr {
+		old = fmt.Sprintf("%s not in (?)", p.Name)
+	}
+	if old == "" {
+		return "", ""
+	}
+	if paramsName == "" {
+		paramsName = p.GetVariableName()
+	}
+	newer := strings.Replace(old, "?", fmt.Sprintf("?%s + strings.Repeat(\",?\",len(%s)-1)+%s", quote, paramsName, quote), 1)
+	return old, newer
+}
+
+// GetVariableName 获取变量名称
+func (p Param) GetVariableName() string {
+	if p.IsLikeInStmt() {
+		return p.Name + "List"
+	}
+	return p.Name
+}
+
+func (p Param) GetTypeName() string {
+	if p.IsLikeInStmt() {
+		return "[]" + p.Typ
+	}
+	return p.Typ
 }
 
 func (pGen PackageGenerator) paramsInLimitExpr(limit *sqlparser.Limit, tableAliasMap FromTables) ([]*Param, error) {
@@ -70,6 +120,7 @@ func (pGen PackageGenerator) paramsInWhereExpr(e sqlparser.SQLNode, tableAliasMa
 			return params, nil
 		}
 		e = expr.Expr
+
 	}
 	switch v := e.(type) {
 	case *sqlparser.Where:
@@ -82,6 +133,9 @@ func (pGen PackageGenerator) paramsInWhereExpr(e sqlparser.SQLNode, tableAliasMa
 		if err != nil {
 			return nil, err
 		}
+		if p != nil {
+			p.ComparisonExpr = v
+		}
 		if found {
 			params = append(params, p)
 		}

internal/mysql/parse.go

@@ -190,6 +190,7 @@ func (pGen PackageGenerator) parseSelect(tree *sqlparser.Select, query string) (
 	parsedQuery.Columns = cols
 
 	whereParams, err := pGen.paramsInWhereExpr(tree.Where, tableAliasMap, defaultTableName)
+
 	if err != nil {
 		return nil, err
 	}