Revert "feat(compiler): Support subqueries in the FROM clause (#3227)" (#3299)

This reverts commit 3f129e7.

Author: kyleconroy

internal/compiler/query_catalog.go

@@ -9,36 +9,26 @@ import (
 )
 
 type QueryCatalog struct {
-	catalog     *catalog.Catalog
-	ctes        map[string]*Table
-	fromClauses map[string]*Table
-	embeds      rewrite.EmbedSet
+	catalog *catalog.Catalog
+	ctes    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 {
@@ -70,37 +60,6 @@ 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.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{Name: *rs.Alias.Aliasname}
-				for i := range cols {
-					cols[i].Table = rel
-					if len(names) > i {
-						cols[i].Name = names[i]
-					}
-				}
-				qc.fromClauses[*rs.Alias.Aliasname] = &Table{
-					Rel:     rel,
-					Columns: cols,
-				}
-			}
-		}
-	}
 	return qc, nil
 }
 

internal/compiler/resolve.go

@@ -67,38 +67,7 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 				continue
 			}
 			// If the table name doesn't exist, first check if it's a CTE
-			catTable, qcerr := qc.GetTable(fqn)
-			if qcerr != nil {
-				return nil, err
-			}
-
-			// If it's a CTE, add it to the alias map and add its columns to
-			// the type map. This is to allow us to resolve references to the
-			// CTE's columns in a query.
-			aliasMap[fqn.Name] = fqn
-			if rv.Alias != nil {
-				aliasMap[*rv.Alias.Aliasname] = fqn
-			}
-
-			catCols := make([]*catalog.Column, 0, len(catTable.Columns))
-			for _, col := range catTable.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,
-				})
-			}
-
-			err = indexTable(catalog.Table{
-				Rel:     catTable.Rel,
-				Columns: catCols,
-			})
-			if err != nil {
+			if _, qcerr := qc.GetTable(fqn); qcerr != nil {
 				return nil, err
 			}
 			continue
@@ -111,28 +80,6 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 			aliasMap[*rv.Alias.Aliasname] = fqn
 		}
 	}
-	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 {