sql/ast: Port support for COMMENT ON (#391)

Author: kyleconroy

internal/compiler/compile.go

@@ -87,21 +87,23 @@ func Run(conf config.SQL, combo config.CombinedSettings) (*Result, error) {
 	for _, schema := range c.Schemas {
 		for _, table := range schema.Tables {
 			s := dinosql.GoStruct{
-				Table: pg.FQN{Schema: schema.Name, Rel: table.Rel.Name},
-				Name:  strings.Title(table.Rel.Name),
+				Table:   pg.FQN{Schema: schema.Name, Rel: table.Rel.Name},
+				Name:    strings.Title(table.Rel.Name),
+				Comment: table.Comment,
 			}
 			for _, col := range table.Columns {
 				s.Fields = append(s.Fields, dinosql.GoField{
-					Name: structName(col.Name),
-					Type: "string",
-					Tags: map[string]string{"json:": col.Name},
+					Name:    structName(col.Name),
+					Type:    "string",
+					Tags:    map[string]string{"json:": col.Name},
+					Comment: col.Comment,
 				})
 			}
 			structs = append(structs, s)
 		}
 		for _, typ := range schema.Types {
 			switch t := typ.(type) {
-			case catalog.Enum:
+			case *catalog.Enum:
 				var name string
 				// TODO: This name should be public, not main
 				if schema.Name == "main" {
@@ -110,7 +112,8 @@ func Run(conf config.SQL, combo config.CombinedSettings) (*Result, error) {
 					name = schema.Name + "_" + t.Name
 				}
 				e := dinosql.GoEnum{
-					Name: structName(name),
+					Name:    structName(name),
+					Comment: t.Comment,
 				}
 				for _, v := range t.Vals {
 					e.Constants = append(e.Constants, dinosql.GoConstant{

internal/endtoend/testdata/comment_on/go/db.go

@@ -0,0 +1,12 @@
+CREATE SCHEMA foo;
+
+CREATE TABLE foo.bar (
+        baz text NOT NULL 
+);
+
+CREATE TYPE foo.mood AS ENUM ('sad', 'ok', 'happy');
+
+COMMENT ON SCHEMA foo IS 'this is the foo schema';
+COMMENT ON TYPE foo.mood IS 'this is the mood type';
+COMMENT ON TABLE foo.bar IS 'this is the bar table';
+COMMENT ON COLUMN foo.bar.baz IS 'this is the baz column';

internal/endtoend/testdata/comment_on/go/models.go

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

internal/endtoend/testdata/comment_on/query.sql

@@ -1,6 +1,7 @@
 package postgresql
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -25,6 +26,9 @@ func stringSlice(list nodes.List) []string {
 func parseTypeName(node nodes.Node) (*ast.TypeName, error) {
 	switch n := node.(type) {
 
+	case nodes.TypeName:
+		return parseTypeName(n.Names)
+
 	case nodes.List:
 		parts := stringSlice(n)
 		switch len(parts) {
@@ -42,7 +46,7 @@ func parseTypeName(node nodes.Node) (*ast.TypeName, error) {
 		}
 
 	default:
-		return nil, fmt.Errorf("unexpected node type: %T", n)
+		return nil, fmt.Errorf("parseTypeName: unexpected node type: %T", n)
 	}
 }
 
@@ -85,7 +89,32 @@ func parseTableName(node nodes.Node) (*ast.TableName, error) {
 		return &name, nil
 
 	default:
-		return nil, fmt.Errorf("unexpected node type: %T", n)
+		return nil, fmt.Errorf("parseTableName: unexpected node type: %T", n)
+	}
+}
+
+func parseColName(node nodes.Node) (*ast.ColumnRef, *ast.TableName, error) {
+	switch n := node.(type) {
+	case nodes.List:
+		parts := stringSlice(n)
+		var tbl *ast.TableName
+		var ref *ast.ColumnRef
+		switch len(parts) {
+		case 2:
+			tbl = &ast.TableName{Name: parts[0]}
+			ref = &ast.ColumnRef{Name: parts[1]}
+		case 3:
+			tbl = &ast.TableName{Schema: parts[0], Name: parts[1]}
+			ref = &ast.ColumnRef{Name: parts[2]}
+		case 4:
+			tbl = &ast.TableName{Catalog: parts[0], Schema: parts[1], Name: parts[2]}
+			ref = &ast.ColumnRef{Name: parts[3]}
+		default:
+			return nil, nil, fmt.Errorf("column specifier %q is not the proper format, expected '[catalog.][schema.]colname.tablename'", strings.Join(parts, "."))
+		}
+		return ref, tbl, nil
+	default:
+		return nil, nil, fmt.Errorf("parseColName: unexpected node type: %T", n)
 	}
 }
 
@@ -100,6 +129,8 @@ func NewParser() *Parser {
 type Parser struct {
 }
 
+var errSkip = errors.New("skip stmt")
+
 func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
 	contents, err := ioutil.ReadAll(r)
 	if err != nil {
@@ -117,14 +148,18 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
 			return nil, fmt.Errorf("expected RawStmt; got %T", stmt)
 		}
 		n, err := translate(raw.Stmt)
+		if err == errSkip {
+			continue
+		}
 		if err != nil {
 			return nil, err
 		}
-		if n != nil {
-			stmts = append(stmts, ast.Statement{
-				Raw: &ast.RawStmt{Stmt: n},
-			})
+		if n == nil {
+			return nil, fmt.Errorf("unexpected nil node")
 		}
+		stmts = append(stmts, ast.Statement{
+			Raw: &ast.RawStmt{Stmt: n},
+		})
 	}
 	return stmts, nil
 }
@@ -183,6 +218,54 @@ func translate(node nodes.Node) (ast.Node, error) {
 		}
 		return at, nil
 
+	case nodes.CommentStmt:
+		switch n.Objtype {
+
+		case nodes.OBJECT_COLUMN:
+			col, tbl, err := parseColName(n.Object)
+			if err != nil {
+				return nil, fmt.Errorf("COMMENT ON COLUMN: %w", err)
+			}
+			return &ast.CommentOnColumnStmt{
+				Col:     col,
+				Table:   tbl,
+				Comment: n.Comment,
+			}, nil
+
+		case nodes.OBJECT_SCHEMA:
+			o, ok := n.Object.(nodes.String)
+			if !ok {
+				return nil, fmt.Errorf("COMMENT ON SCHEMA: unexpected node type: %T", n.Object)
+			}
+			return &ast.CommentOnSchemaStmt{
+				Schema:  &ast.String{Str: o.Str},
+				Comment: n.Comment,
+			}, nil
+
+		case nodes.OBJECT_TABLE:
+			name, err := parseTableName(n.Object)
+			if err != nil {
+				return nil, fmt.Errorf("COMMENT ON TABLE: %w", err)
+			}
+			return &ast.CommentOnTableStmt{
+				Table:   name,
+				Comment: n.Comment,
+			}, nil
+
+		case nodes.OBJECT_TYPE:
+			name, err := parseTypeName(n.Object)
+			if err != nil {
+				return nil, err
+			}
+			return &ast.CommentOnTypeStmt{
+				Type:    name,
+				Comment: n.Comment,
+			}, nil
+
+		}
+
+		return nil, errSkip
+
 	case nodes.CreateStmt:
 		name, err := parseTableName(*n.Relation)
 		if err != nil {
@@ -259,9 +342,9 @@ func translate(node nodes.Node) (ast.Node, error) {
 			return drop, nil
 
 		}
-		return nil, nil
+		return nil, errSkip
 
 	default:
-		return nil, nil
+		return nil, errSkip
 	}
 }

internal/endtoend/testdata/comment_on/sqlc.json

@@ -163,3 +163,40 @@ type String struct {
 func (n *String) Pos() int {
 	return 0
 }
+
+type CommentOnSchemaStmt struct {
+	Schema  *String
+	Comment *string
+}
+
+func (n *CommentOnSchemaStmt) Pos() int {
+	return 0
+}
+
+type CommentOnTableStmt struct {
+	Table   *TableName
+	Comment *string
+}
+
+func (n *CommentOnTableStmt) Pos() int {
+	return 0
+}
+
+type CommentOnTypeStmt struct {
+	Type    *TypeName
+	Comment *string
+}
+
+func (n *CommentOnTypeStmt) Pos() int {
+	return 0
+}
+
+type CommentOnColumnStmt struct {
+	Table   *TableName
+	Col     *ColumnRef
+	Comment *string
+}
+
+func (n *CommentOnColumnStmt) Pos() int {
+	return 0
+}