sql: Add generic SQL AST

The three new experimental parsers turn engine-specific ASTs into a
generic AST shared by the type-checking and code-gen phases.

Author: kyleconroy

internal/sql/ast/ast.go

@@ -0,0 +1,96 @@
+package ast
+
+type Node interface {
+	Pos() int
+}
+
+type Statement struct {
+	Raw *RawStmt
+}
+
+type RawStmt struct {
+	Stmt Node
+}
+
+func (n *RawStmt) Pos() int {
+	return 0
+}
+
+type TableName struct {
+	Catalog string
+	Schema  string
+	Name    string
+}
+
+func (n *TableName) Pos() int {
+	return 0
+}
+
+type CreateTableStmt struct {
+	IfNotExists bool
+	Name        *TableName
+	Cols        []*ColumnDef
+}
+
+func (n *CreateTableStmt) Pos() int {
+	return 0
+}
+
+type DropTableStmt struct {
+	IfExists bool
+	Tables   []*TableName
+}
+
+func (n *DropTableStmt) Pos() int {
+	return 0
+}
+
+type ColumnDef struct {
+	Colname  string
+	TypeName *TypeName
+}
+
+func (n *ColumnDef) Pos() int {
+	return 0
+}
+
+type TypeName struct {
+	Name string
+}
+
+func (n *TypeName) Pos() int {
+	return 0
+}
+
+type SelectStmt struct {
+	Fields *List
+	From   *List
+}
+
+func (n *SelectStmt) Pos() int {
+	return 0
+}
+
+type List struct {
+	Items []Node
+}
+
+func (n *List) Pos() int {
+	return 0
+}
+
+type ResTarget struct {
+	Val Node
+}
+
+func (n *ResTarget) Pos() int {
+	return 0
+}
+
+type ColumnRef struct {
+	Name string
+}
+
+func (n *ColumnRef) Pos() int {
+	return 0
+}

internal/sql/catalog/catalog.go

@@ -0,0 +1,130 @@
+package catalog
+
+import (
+	"errors"
+
+	"github.com/kyleconroy/sqlc/internal/sql/ast"
+)
+
+func Build(stmts []ast.Statement) (*Catalog, error) {
+	c := &Catalog{
+		DefaultSchema: "main", // TODO: Needs to be public for PostgreSQL
+		Schemas: []*Schema{
+			&Schema{Name: "main"},
+		},
+	}
+	for i := range stmts {
+		if stmts[i].Raw == nil {
+			continue
+		}
+		var err error
+		switch n := stmts[i].Raw.Stmt.(type) {
+		case *ast.CreateTableStmt:
+			err = c.createTable(n)
+		case *ast.DropTableStmt:
+			err = c.dropTable(n)
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+	return c, nil
+}
+
+var ErrRelationNotFound = errors.New("relation not found")
+var ErrSchemaNotFound = errors.New("schema not found")
+
+func (c *Catalog) getSchema(name string) (*Schema, error) {
+	for i := range c.Schemas {
+		if c.Schemas[i].Name == name {
+			return c.Schemas[i], nil
+		}
+	}
+	return nil, ErrSchemaNotFound
+}
+
+func (c *Catalog) createTable(stmt *ast.CreateTableStmt) error {
+	ns := stmt.Name.Schema
+	if ns == "" {
+		ns = c.DefaultSchema
+	}
+	schema, err := c.getSchema(ns)
+	if err != nil {
+		return err
+	}
+	if _, _, err := schema.getTable(stmt.Name); err != nil {
+		if !errors.Is(err, ErrRelationNotFound) {
+			return err
+		}
+	} else if stmt.IfNotExists {
+		return nil
+	}
+	tbl := Table{Rel: stmt.Name}
+	for _, col := range stmt.Cols {
+		tbl.Columns = append(tbl.Columns, &Column{
+			Name: col.Colname,
+			Type: *col.TypeName,
+		})
+	}
+	schema.Tables = append(schema.Tables, &tbl)
+	return nil
+}
+
+func (c *Catalog) dropTable(stmt *ast.DropTableStmt) error {
+	for _, name := range stmt.Tables {
+		ns := name.Schema
+		if ns == "" {
+			ns = c.DefaultSchema
+		}
+		schema, err := c.getSchema(ns)
+		if errors.Is(err, ErrSchemaNotFound) && stmt.IfExists {
+			continue
+		} else if err != nil {
+			return err
+		}
+
+		_, idx, err := schema.getTable(name)
+		if errors.Is(err, ErrRelationNotFound) && stmt.IfExists {
+			continue
+		} else if err != nil {
+			return err
+		}
+
+		schema.Tables = append(schema.Tables[:idx], schema.Tables[idx+1:]...)
+	}
+	return nil
+}
+
+type Catalog struct {
+	Name    string
+	Schemas []*Schema
+	Comment string
+
+	DefaultSchema string
+}
+
+type Schema struct {
+	Name    string
+	Tables  []*Table
+	Comment string
+}
+
+func (s *Schema) getTable(rel *ast.TableName) (*Table, int, error) {
+	for i := range s.Tables {
+		if s.Tables[i].Rel.Name == rel.Name {
+			return s.Tables[i], i, nil
+		}
+	}
+	return nil, 0, ErrRelationNotFound
+}
+
+type Table struct {
+	Rel     *ast.TableName
+	Columns []*Column
+	Comment string
+}
+
+type Column struct {
+	Name string
+	Type ast.TypeName
+}

internal/sql/info/info.go

@@ -0,0 +1,59 @@
+package info
+
+import (
+	"github.com/kyleconroy/sqlc/internal/sql/catalog"
+)
+
+// Provide a read-only view into the catalog
+func Newo(c *catalog.Catalog) InformationSchema {
+	return InformationSchema{c: c}
+}
+
+type InformationSchema struct {
+	c *catalog.Catalog
+}
+
+type Table struct {
+	Catalog string
+	Schema  string
+	Name    string
+}
+
+// SELECT * FROM information_schema.tables;
+func (i *InformationSchema) Tables() []Table {
+	var tables []Table
+	for _, s := range i.c.Schemas {
+		for _, t := range s.Tables {
+			tables = append(tables, Table{
+				Catalog: i.c.Name,
+				Schema:  s.Name,
+				Name:    t.Rel.Name,
+			})
+		}
+	}
+	return tables
+}
+
+type Column struct {
+	Catalog    string
+	Schema     string
+	Table      string
+	Name       string
+	DataType   string
+	IsNullable bool
+}
+
+// SELECT * FROM information_schema.columns;
+func (i *InformationSchema) Columns() []Column {
+	return []Column{}
+}
+
+type Schema struct {
+	Catalog string
+	Name    string
+}
+
+// SELECT * FROM information_schema.schemata;
+func (i *InformationSchema) Schemata() []Schema {
+	return []Schema{}
+}