feat(compiler): Support subqueries in the FROM clause

internal/compiler/output_columns.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"errors"
 	"fmt"
+	"math/rand"
 
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/astutils"
@@ -596,10 +597,14 @@ func (c *Compiler) sourceTables(qc *QueryCatalog, node ast.Node) ([]*Table, erro
 			if err != nil {
 				return nil, err
 			}
+			rel := &ast.TableName{}
+			if n.Alias != nil && n.Alias.Aliasname != nil {
+				rel.Name = *n.Alias.Aliasname
+			} else {
+				rel.Name = fmt.Sprintf("unnamed_subquery_%d", rand.Int63())
+			}
 			tables = append(tables, &Table{
-				Rel: &ast.TableName{
-					Name: *n.Alias.Aliasname,
-				},
+				Rel:     rel,
 				Columns: cols,
 			})
 

internal/compiler/query_catalog.go

@@ -2,33 +2,44 @@ package compiler
 
 import (
 	"fmt"
+	"math/rand"
 
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
 	"github.com/sqlc-dev/sqlc/internal/sql/rewrite"
 )
 
 type QueryCatalog struct {
-	catalog *catalog.Catalog
-	ctes    map[string]*Table
-	embeds  rewrite.EmbedSet
+	catalog     *catalog.Catalog
+	ctes        map[string]*Table
+	fromClauses map[string]*Table
+	embeds      rewrite.EmbedSet
 }
 
 func (comp *Compiler) buildQueryCatalog(c *catalog.Catalog, node ast.Node, embeds rewrite.EmbedSet) (*QueryCatalog, error) {
 	var with *ast.WithClause
+	var from *ast.List
 	switch n := node.(type) {
 	case *ast.DeleteStmt:
 		with = n.WithClause
 	case *ast.InsertStmt:
 		with = n.WithClause
 	case *ast.UpdateStmt:
 		with = n.WithClause
+		from = n.FromClause
 	case *ast.SelectStmt:
 		with = n.WithClause
+		from = n.FromClause
 	default:
 		with = nil
+		from = nil
+	}
+	qc := &QueryCatalog{
+		catalog:     c,
+		ctes:        map[string]*Table{},
+		fromClauses: map[string]*Table{},
+		embeds:      embeds,
 	}
-	qc := &QueryCatalog{catalog: c, ctes: map[string]*Table{}, embeds: embeds}
 	if with != nil {
 		for _, item := range with.Ctes.Items {
 			if cte, ok := item.(*ast.CommonTableExpr); ok {
@@ -60,6 +71,42 @@ func (comp *Compiler) buildQueryCatalog(c *catalog.Catalog, node ast.Node, embed
 			}
 		}
 	}
+	if from != nil {
+		for _, item := range from.Items {
+			if rs, ok := item.(*ast.RangeSubselect); ok {
+				cols, err := comp.outputColumns(qc, rs.Subquery)
+				if err != nil {
+					return nil, err
+				}
+				var names []string
+				if rs.Alias != nil && rs.Alias.Colnames != nil {
+					for _, item := range rs.Alias.Colnames.Items {
+						if val, ok := item.(*ast.String); ok {
+							names = append(names, val.Str)
+						} else {
+							names = append(names, "")
+						}
+					}
+				}
+				rel := &ast.TableName{}
+				if rs.Alias != nil && rs.Alias.Aliasname != nil {
+					rel.Name = *rs.Alias.Aliasname
+				} else {
+					rel.Name = fmt.Sprintf("unaliased_table_%d", rand.Int63())
+				}
+				for i := range cols {
+					cols[i].Table = rel
+					if len(names) > i {
+						cols[i].Name = names[i]
+					}
+				}
+				qc.fromClauses[rel.Name] = &Table{
+					Rel:     rel,
+					Columns: cols,
+				}
+			}
+		}
+	}
 	return qc, nil
 }
 

internal/compiler/resolve.go

@@ -80,6 +80,30 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 			aliasMap[*rv.Alias.Aliasname] = fqn
 		}
 	}
+	if qc != nil {
+		for _, f := range qc.fromClauses {
+			catCols := make([]*catalog.Column, 0, len(f.Columns))
+			for _, col := range f.Columns {
+				catCols = append(catCols, &catalog.Column{
+					Name:       col.Name,
+					Type:       ast.TypeName{Name: col.DataType},
+					IsNotNull:  col.NotNull,
+					IsUnsigned: col.Unsigned,
+					IsArray:    col.IsArray,
+					ArrayDims:  col.ArrayDims,
+					Comment:    col.Comment,
+					Length:     col.Length,
+				})
+			}
+
+			if err := indexTable(catalog.Table{
+				Rel:     f.Rel,
+				Columns: catCols,
+			}); err != nil {
+				return nil, err
+			}
+		}
+	}
 
 	// resolve a table for an embed
 	for _, embed := range embeds {

internal/endtoend/testdata/join_alias/mysql/query.sql

@@ -9,3 +9,12 @@ SELECT *
 FROM foo f
 JOIN bar b ON b.id = f.id
 WHERE f.id = ?;
+
+-- name: SubqueryAlias :many
+SELECT * FROM (SELECT 1 AS n) AS x WHERE x.n <= ?;
+
+-- name: ColumnAlias :many
+SELECT * FROM (SELECT 1 AS n) WHERE n <= ?;
+
+-- name: ColumnAndQueryAlias :many
+SELECT * FROM (SELECT 1 AS n) AS x WHERE n <= ?;