Handle convertPatternInExpr. (#1088)

* Handle convertPatternInExpr.

This can be handled just by calling convert on the subquery, and it is
necessary for some kinds of queries.

Like the following, without this we don't pickup the parameter, and thus
can't handle the query at all:

select * from foo where field in (select substring(?, 1, seq) from seq_1_to_19)

* Add ast.In

This is used for queries like the following:

SELECT a, b from foo where foo.a in (select a from bar where bar.b = ?);

SELECT a, b from foo where foo.a in (?, ?);

SELECT a, b from foo where foo.a not in (?, ?);

SELECT a, b from foo where ? in (foo.a, foo.b);

The support is heavily based on that found in the fork found at:
https://github.com/xiazemin/sqlc.git

However it should be noted that this is not just a straight copy and
paste job, there are several pieces from that branch for features that
don't exist in the main sqlc repository, the sqlc repository has changed
a bit since the fork, and the fork version does not handle the latter
case at all.

* Adapt convertPatternInExpr to use ast.In

This is used for queries like the following:

SELECT a, b from foo where foo.a in (select a from bar where bar.b = ?);

SELECT a, b from foo where foo.a in (?, ?);

SELECT a, b from foo where foo.a not in (?, ?);

SELECT a, b from foo where ? in (foo.a, foo.b);

The support is heavily based on that found in the fork found at:
https://github.com/xiazemin/sqlc.git

However it should be noted that this is not just a straight copy and
paste job, there are several pieces from that branch for features that
don't exist in the main sqlc repository, the sqlc repository has changed
a bit since the fork, and the fork version does not handle the latter
case at all.

* Add test cases for convertPatternInExpr.

This covers all the cases I can think of, though if I missed some, it's
quite possible that they are broken in the code as well as absent in the
tests.

* Only check for duplicate c.id on query outputs.

That is, we want to deduplicate the same column from showing up multiple
times, and thus we want to avoid adding a suffix, when we are getting
the results from a query, however we most definitely do not want to do
this for query parameters.

Especially since the logic for handling this in the query parameters is
missing the deduplication, but also because the database itself expects
the same number of parameters as we have placeholders in the query.

* Make seen use fieldName instead of colName.

fieldName is after any mangilng to make it fit go variable standards,
and since that is the name that we are actually using, that is the name
that we should be checking for conflicts.

This only matters when we have multiple fields that differ only by
things that are changed when we are converting to the go variable
standards.

* Update test files for A_2 vs A.

This should now build a little better, now that we have fixed the
generator.

* Make seen use the pre-modification fieldName.

Oops, this fixes a bug introduced in
885bd3d.

* DefaultSchema support for ast.In.

Needed now that we're merging in master.

Co-authored-by: Zephaniah E. Loss-Cutler-Hull <warp@aehallh.com>
Co-authored-by: Kyle Conroy <kyle@conroy.org>

Author: 3 people

internal/codegen/golang/result.go

@@ -181,7 +181,7 @@ func buildQueries(r *compiler.Result, settings config.CombinedSettings, structs
 			gq.Arg = QueryValue{
 				Emit:       true,
 				Name:       "arg",
-				Struct:     columnsToStruct(r, gq.MethodName+"Params", cols, settings),
+				Struct:     columnsToStruct(r, gq.MethodName+"Params", cols, settings, false),
 				SQLPackage: sqlpkg,
 			}
 		}
@@ -225,7 +225,7 @@ func buildQueries(r *compiler.Result, settings config.CombinedSettings, structs
 						Column: c,
 					})
 				}
-				gs = columnsToStruct(r, gq.MethodName+"Row", columns, settings)
+				gs = columnsToStruct(r, gq.MethodName+"Row", columns, settings, true)
 				emit = true
 			}
 			gq.Ret = QueryValue{
@@ -249,7 +249,7 @@ func buildQueries(r *compiler.Result, settings config.CombinedSettings, structs
 // JSON tags: count, count_2, count_2
 //
 // This is unlikely to happen, so don't fix it yet
-func columnsToStruct(r *compiler.Result, name string, columns []goColumn, settings config.CombinedSettings) *Struct {
+func columnsToStruct(r *compiler.Result, name string, columns []goColumn, settings config.CombinedSettings, useID bool) *Struct {
 	gs := Struct{
 		Name: name,
 	}
@@ -259,12 +259,13 @@ func columnsToStruct(r *compiler.Result, name string, columns []goColumn, settin
 		colName := columnName(c.Column, i)
 		tagName := colName
 		fieldName := StructName(colName, settings)
+		baseFieldName := fieldName
 		// Track suffixes by the ID of the column, so that columns referring to the same numbered parameter can be
 		// reused.
 		suffix := 0
-		if o, ok := suffixes[c.id]; ok {
+		if o, ok := suffixes[c.id]; ok && useID {
 			suffix = o
-		} else if v := seen[colName]; v > 0 {
+		} else if v := seen[fieldName]; v > 0 {
 			suffix = v + 1
 		}
 		suffixes[c.id] = suffix
@@ -284,7 +285,8 @@ func columnsToStruct(r *compiler.Result, name string, columns []goColumn, settin
 			Type: goType(r, c.Column, settings),
 			Tags: tags,
 		})
-		seen[colName]++
+		seen[baseFieldName]++
 	}
+
 	return &gs
 }

internal/compiler/find_params.go

@@ -142,6 +142,25 @@ func (p paramSearch) Visit(node ast.Node) astutils.Visitor {
 			p.seen[n.Location] = struct{}{}
 		}
 		return nil
+
+	case *ast.In:
+		if n.Sel == nil {
+			p.parent = node
+		} else {
+			if sel, ok := n.Sel.(*ast.SelectStmt); ok && sel.FromClause != nil {
+				from := sel.FromClause
+				if schema, ok := from.Items[0].(*ast.RangeVar); ok && schema != nil {
+					p.rangeVar = &ast.RangeVar{
+						Catalogname: schema.Catalogname,
+						Schemaname:  schema.Schemaname,
+						Relname:     schema.Relname,
+					}
+				}
+			}
+		}
+		if _, ok := n.Expr.(*ast.ParamRef); ok {
+			p.Visit(n.Expr)
+		}
 	}
 	return p
 }

internal/compiler/resolve.go

@@ -370,6 +370,104 @@ func resolveCatalogRefs(c *catalog.Catalog, qc *QueryCatalog, rvs []*ast.RangeVa
 		case *ast.ParamRef:
 			a = append(a, Parameter{Number: ref.ref.Number})
 
+		case *ast.In:
+			if n == nil || n.List == nil {
+				fmt.Println("ast.In is nil")
+				continue
+			}
+
+			number := 0
+			if pr, ok := n.List[0].(*ast.ParamRef); ok {
+				number = pr.Number
+			}
+
+			location := 0
+			var key, alias string
+			var items []string
+
+			if left, ok := n.Expr.(*ast.ColumnRef); ok {
+				location = left.Location
+				items = stringSlice(left.Fields)
+			} else if left, ok := n.Expr.(*ast.ParamRef); ok {
+				if len(n.List) <= 0 {
+					continue
+				}
+				if right, ok := n.List[0].(*ast.ColumnRef); ok {
+					location = left.Location
+					items = stringSlice(right.Fields)
+				} else {
+					continue
+				}
+			} else {
+				continue
+			}
+
+			switch len(items) {
+			case 1:
+				key = items[0]
+			case 2:
+				alias = items[0]
+				key = items[1]
+			default:
+				panic("too many field items: " + strconv.Itoa(len(items)))
+			}
+
+			var found int
+			if n.Sel == nil {
+				search := tables
+				if alias != "" {
+					if original, ok := aliasMap[alias]; ok {
+						search = []*ast.TableName{original}
+					} else {
+						for _, fqn := range tables {
+							if fqn.Name == alias {
+								search = []*ast.TableName{fqn}
+							}
+						}
+					}
+				}
+
+				for _, table := range search {
+					schema := table.Schema
+					if schema == "" {
+						schema = c.DefaultSchema
+					}
+					if c, ok := typeMap[schema][table.Name][key]; ok {
+						found += 1
+						if ref.name != "" {
+							key = ref.name
+						}
+						a = append(a, Parameter{
+							Number: number,
+							Column: &Column{
+								Name:     parameterName(ref.ref.Number, key),
+								DataType: dataType(&c.Type),
+								NotNull:  c.IsNotNull,
+								IsArray:  c.IsArray,
+								Table:    table,
+							},
+						})
+					}
+				}
+			} else {
+				fmt.Println("------------------------")
+			}
+
+			if found == 0 {
+				return nil, &sqlerr.Error{
+					Code:     "42703",
+					Message:  fmt.Sprintf("396: column \"%s\" does not exist", key),
+					Location: location,
+				}
+			}
+			if found > 1 {
+				return nil, &sqlerr.Error{
+					Code:     "42703",
+					Message:  fmt.Sprintf("in same name column reference \"%s\" is ambiguous", key),
+					Location: location,
+				}
+			}
+
 		default:
 			fmt.Printf("unsupported reference type: %T", n)
 		}

internal/endtoend/testdata/pattern_in_expr/mysql/go/db.go

@@ -0,0 +1,13 @@
+CREATE TABLE foo (a text, b text);
+CREATE TABLE bar (a text, b text);
+/* name: FooByBarB :many */
+SELECT a, b from foo where foo.a in (select a from bar where bar.b = ?);
+
+/* name: FooByList :many */
+SELECT a, b from foo where foo.a in (?, ?);
+
+/* name: FooByNotList :many */
+SELECT a, b from foo where foo.a not in (?, ?);
+
+/* name: FooByParamList :many */
+SELECT a, b from foo where ? in (foo.a, foo.b);

internal/endtoend/testdata/pattern_in_expr/mysql/go/models.go

@@ -0,0 +1,12 @@
+{
+  "version": "1",
+  "packages": [
+    {
+      "engine": "mysql",
+      "path": "go",
+      "name": "querytest",
+      "schema": "query.sql",
+      "queries": "query.sql"
+    }
+  ]
+}