Create new metadata-pkg (#508)

* Create new metadata-pkg

* sql/validate: Port over validateCmd

Author: kyleconroy

internal/compiler/runtime/parse.go

@@ -2,7 +2,9 @@ package runtime
 
 import (
 	"errors"
+	"strings"
 
+	"github.com/kyleconroy/sqlc/internal/metadata"
 	"github.com/kyleconroy/sqlc/internal/source"
 	"github.com/kyleconroy/sqlc/internal/sql/ast"
 	"github.com/kyleconroy/sqlc/internal/sql/ast/pg"
@@ -49,6 +51,13 @@ func parseQuery(c *catalog.Catalog, stmt ast.Node, src string, rewriteParameters
 	if err := validate.FuncCall(c, raw); err != nil {
 		return nil, err
 	}
+	name, cmd, err := metadata.Parse(strings.TrimSpace(rawSQL), metadata.CommentSyntaxDash)
+	if err != nil {
+		return nil, err
+	}
+	if err := validate.Cmd(raw.Stmt, name, cmd); err != nil {
+		return nil, err
+	}
 
 	return &Query{}, nil
 }

internal/dinosql/parser.go

@@ -9,13 +9,13 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"unicode"
 
 	"github.com/davecgh/go-spew/spew"
 	pg "github.com/lfittl/pg_query_go"
 	nodes "github.com/lfittl/pg_query_go/nodes"
 
 	"github.com/kyleconroy/sqlc/internal/catalog"
+	"github.com/kyleconroy/sqlc/internal/metadata"
 	"github.com/kyleconroy/sqlc/internal/migrations"
 	"github.com/kyleconroy/sqlc/internal/multierr"
 	core "github.com/kyleconroy/sqlc/internal/pg"
@@ -210,67 +210,6 @@ func rangeVars(root nodes.Node) []nodes.RangeVar {
 	return vars
 }
 
-// A query name must be a valid Go identifier
-//
-// https://golang.org/ref/spec#Identifiers
-func validateQueryName(name string) error {
-	if len(name) == 0 {
-		return fmt.Errorf("invalid query name: %q", name)
-	}
-	for i, c := range name {
-		isLetter := unicode.IsLetter(c) || c == '_'
-		isDigit := unicode.IsDigit(c)
-		if i == 0 && !isLetter {
-			return fmt.Errorf("invalid query name %q", name)
-		} else if !(isLetter || isDigit) {
-			return fmt.Errorf("invalid query name %q", name)
-		}
-	}
-	return nil
-}
-
-type CommentSyntax int
-
-const (
-	CommentSyntaxDash CommentSyntax = iota
-	CommentSyntaxStar               // Note: this is the only style supported by the MySQL sqlparser
-	CommentSyntaxHash
-)
-
-func ParseMetadata(t string, commentStyle CommentSyntax) (string, string, error) {
-	for _, line := range strings.Split(t, "\n") {
-		if commentStyle == CommentSyntaxDash && !strings.HasPrefix(line, "-- name:") {
-			continue
-		}
-		if commentStyle == CommentSyntaxStar && !strings.HasPrefix(line, "/* name:") {
-			continue
-		}
-		part := strings.Split(strings.TrimSpace(line), " ")
-
-		if commentStyle == CommentSyntaxStar {
-			part = part[:len(part)-1] // removes the trailing "*/" element
-		}
-		if len(part) == 2 {
-			return "", "", fmt.Errorf("missing query type [':one', ':many', ':exec', ':execrows']: %s", line)
-		}
-		if len(part) != 4 {
-			return "", "", fmt.Errorf("invalid query comment: %s", line)
-		}
-		queryName := part[2]
-		queryType := strings.TrimSpace(part[3])
-		switch queryType {
-		case ":one", ":many", ":exec", ":execrows":
-		default:
-			return "", "", fmt.Errorf("invalid query type: %s", queryType)
-		}
-		if err := validateQueryName(queryName); err != nil {
-			return "", "", err
-		}
-		return queryName, queryType, nil
-	}
-	return "", "", nil
-}
-
 func validateCmd(n nodes.Node, name, cmd string) error {
 	// TODO: Convert cmd to an enum
 	if !(cmd == ":many" || cmd == ":one") {
@@ -331,7 +270,7 @@ func parseQuery(c core.Catalog, stmt nodes.Node, src string, rewriteParameters b
 	if err := validate.FuncCall(&c, raw); err != nil {
 		return nil, err
 	}
-	name, cmd, err := ParseMetadata(strings.TrimSpace(rawSQL), CommentSyntaxDash)
+	name, cmd, err := metadata.Parse(strings.TrimSpace(rawSQL), metadata.CommentSyntaxDash)
 	if err != nil {
 		return nil, err
 	}

internal/dinosql/parser_test.go

@@ -158,21 +158,6 @@ func TestRewriteParameters(t *testing.T) {
 	}
 }
 
-func TestParseMetadata(t *testing.T) {
-	for _, query := range []string{
-		`-- name: CreateFoo, :one`,
-		`-- name: 9Foo_, :one`,
-		`-- name: CreateFoo :two`,
-		`-- name: CreateFoo`,
-		`-- name: CreateFoo :one something`,
-		`-- name: `,
-	} {
-		if _, _, err := ParseMetadata(query, CommentSyntaxDash); err == nil {
-			t.Errorf("expected invalid metadata: %q", query)
-		}
-	}
-}
-
 func TestExpand(t *testing.T) {
 	// pretend that foo has two columns, a and b
 	raw := `SELECT *, *, foo.* FROM foo`

internal/metadata/meta.go

@@ -0,0 +1,68 @@
+package metadata
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+type CommentSyntax int
+
+const (
+	CommentSyntaxDash CommentSyntax = iota
+	CommentSyntaxStar               // Note: this is the only style supported by the MySQL sqlparser
+	CommentSyntaxHash
+)
+
+// A query name must be a valid Go identifier
+//
+// https://golang.org/ref/spec#Identifiers
+func validateQueryName(name string) error {
+	if len(name) == 0 {
+		return fmt.Errorf("invalid query name: %q", name)
+	}
+	for i, c := range name {
+		isLetter := unicode.IsLetter(c) || c == '_'
+		isDigit := unicode.IsDigit(c)
+		if i == 0 && !isLetter {
+			return fmt.Errorf("invalid query name %q", name)
+		} else if !(isLetter || isDigit) {
+			return fmt.Errorf("invalid query name %q", name)
+		}
+	}
+	return nil
+}
+
+func Parse(t string, commentStyle CommentSyntax) (string, string, error) {
+	for _, line := range strings.Split(t, "\n") {
+		if commentStyle == CommentSyntaxDash && !strings.HasPrefix(line, "-- name:") {
+			continue
+		}
+		if commentStyle == CommentSyntaxStar && !strings.HasPrefix(line, "/* name:") {
+			continue
+		}
+		part := strings.Split(strings.TrimSpace(line), " ")
+
+		if commentStyle == CommentSyntaxStar {
+			part = part[:len(part)-1] // removes the trailing "*/" element
+		}
+		if len(part) == 2 {
+			return "", "", fmt.Errorf("missing query type [':one', ':many', ':exec', ':execrows']: %s", line)
+		}
+		if len(part) != 4 {
+			return "", "", fmt.Errorf("invalid query comment: %s", line)
+		}
+		queryName := part[2]
+		queryType := strings.TrimSpace(part[3])
+		switch queryType {
+		case ":one", ":many", ":exec", ":execrows":
+		default:
+			return "", "", fmt.Errorf("invalid query type: %s", queryType)
+		}
+		if err := validateQueryName(queryName); err != nil {
+			return "", "", err
+		}
+		return queryName, queryType, nil
+	}
+	return "", "", nil
+}

internal/metadata/meta_test.go

@@ -0,0 +1,18 @@
+package metadata
+
+import "testing"
+
+func TestParseMetadata(t *testing.T) {
+	for _, query := range []string{
+		`-- name: CreateFoo, :one`,
+		`-- name: 9Foo_, :one`,
+		`-- name: CreateFoo :two`,
+		`-- name: CreateFoo`,
+		`-- name: CreateFoo :one something`,
+		`-- name: `,
+	} {
+		if _, _, err := Parse(query, CommentSyntaxDash); err == nil {
+			t.Errorf("expected invalid metadata: %q", query)
+		}
+	}
+}

internal/mysql/parse.go

@@ -10,7 +10,7 @@ import (
 	"vitess.io/vitess/go/vt/sqlparser"
 
 	"github.com/kyleconroy/sqlc/internal/config"
-	"github.com/kyleconroy/sqlc/internal/dinosql"
+	"github.com/kyleconroy/sqlc/internal/metadata"
 	"github.com/kyleconroy/sqlc/internal/migrations"
 	"github.com/kyleconroy/sqlc/internal/multierr"
 	"github.com/kyleconroy/sqlc/internal/sql/sqlpath"
@@ -143,7 +143,7 @@ func (q *Query) parseNameAndCmd() error {
 		return fmt.Errorf("cannot parse name and cmd from null query")
 	}
 	_, comments := sqlparser.SplitMarginComments(q.SQL)
-	name, cmd, err := dinosql.ParseMetadata(comments.Leading, dinosql.CommentSyntaxStar)
+	name, cmd, err := metadata.Parse(comments.Leading, metadata.CommentSyntaxStar)
 	if err != nil {
 		return err
 	} else if name == "" || cmd == "" {

internal/sql/validate/cmd.go

@@ -0,0 +1,32 @@
+package validate
+
+import (
+	"fmt"
+
+	"github.com/kyleconroy/sqlc/internal/sql/ast"
+	"github.com/kyleconroy/sqlc/internal/sql/ast/pg"
+)
+
+func Cmd(n ast.Node, name, cmd string) error {
+	// TODO: Convert cmd to an enum
+	if !(cmd == ":many" || cmd == ":one") {
+		return nil
+	}
+	var list *ast.List
+	switch stmt := n.(type) {
+	case *pg.SelectStmt:
+		return nil
+	case *pg.DeleteStmt:
+		list = stmt.ReturningList
+	case *pg.InsertStmt:
+		list = stmt.ReturningList
+	case *pg.UpdateStmt:
+		list = stmt.ReturningList
+	default:
+		return nil
+	}
+	if list == nil || len(list.Items) == 0 {
+		return fmt.Errorf("query %q specifies parameter %q without containing a RETURNING clause", name, cmd)
+	}
+	return nil
+}