First working version

Author: kyleconroy

cmd/strongdb/main.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"flag"
+	"log"
+
+	"github.com/kyleconroy/strongdb"
+)
+
+func main() {
+	pkg := flag.String("package", "db", "package name for Go code")
+	sch := flag.String("schema", "", "input directory of SQL migrations")
+	out := flag.String("out", "db.go", "output file")
+	flag.Parse()
+
+	if err := strongdb.Exec(*sch, flag.Arg(0), *pkg, *out); err != nil {
+		log.Fatal(err)
+	}
+}

exec.go

@@ -0,0 +1,20 @@
+package strongdb
+
+import (
+	"io/ioutil"
+)
+
+func Exec(schemaDir, queryDir, pkg, out string) error {
+	s, err := ParseSchmea(schemaDir)
+	if err != nil {
+		return err
+	}
+
+	q, err := ParseQueries(s, queryDir)
+	if err != nil {
+		return err
+	}
+
+	source := generate(q, pkg)
+	return ioutil.WriteFile(out, []byte(source), 0644)
+}

parser.go

@@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"log"
 	"path/filepath"
+	"sort"
 	"strings"
 	"text/template"
 	"unicode"
@@ -186,6 +187,7 @@ func parseFuncs(s *postgres.Schema, r *Result, tree pg.ParsetreeList) {
 func where(q *sq.SelectBuilder, n nodes.SelectStmt, args []string) (*sq.SelectBuilder, []string) {
 	// Only equality supported
 	eq := sq.Eq{}
+	found := false
 	switch a := n.WhereClause.(type) {
 	case nodes.A_Expr:
 		switch n := a.Lexpr.(type) {
@@ -197,13 +199,17 @@ func where(q *sq.SelectBuilder, n nodes.SelectStmt, args []string) (*sq.SelectBu
 					key += n.Str
 				}
 			}
+			found = true
 			args = append(args, key)
 			eq[key] = "?"
 		}
 		// switch n := a.Lexpr.(type) {
 		// case nodes.ParamRef:
 		// }
 	}
+	if !found {
+		return q, args
+	}
 	return q.Where(eq), args
 }
 
@@ -280,6 +286,20 @@ type dbtx interface {
 	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
 }
 
+func New(db dbtx) *Queries {
+	return &Queries{db: db}
+}
+
+func Prepare(ctx context.Context, db dbtx) (*Queries, error) {
+	q := Queries{db: db}
+	var err error{{range .Queries}}
+	if q.{{.StmtName}}, err = db.PrepareContext(ctx, {{.QueryName}}); err != nil {
+		return nil, err
+	}
+	{{- end}}
+	return &q, nil
+}
+
 type Queries struct {
 	db dbtx
 
@@ -289,6 +309,16 @@ type Queries struct {
 	{{- end}}
 }
 
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		tx: tx,
+		db: tx,
+		{{- range .Queries}}
+		{{.StmtName}}: q.{{.StmtName}},
+		{{- end}}
+	}
+}
+
 {{range .Queries}}
 const {{.QueryName}} = {{$.Q}}
 {{.SQL}}
@@ -382,6 +412,8 @@ func lowerTitle(s string) string {
 }
 
 func generate(r *Result, pkg string) string {
+	sort.Slice(r.Queries, func(i, j int) bool { return r.Queries[i].MethodName < r.Queries[j].MethodName })
+
 	funcMap := template.FuncMap{
 		"lowerTitle": lowerTitle,
 	}

parser_test.go

@@ -1,6 +1,7 @@
 package strongdb
 
 import (
+	"fmt"
 	"io/ioutil"
 	"log"
 	"path/filepath"
@@ -27,5 +28,6 @@ func TestParseSchema(t *testing.T) {
 
 	if source != string(blob) {
 		t.Errorf("output differs")
+		fmt.Println(source)
 	}
 }

testdata/ondeck/db.go

@@ -25,17 +25,65 @@ type dbtx interface {
 	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
 }
 
+func New(db dbtx) *Queries {
+	return &Queries{db: db}
+}
+
+func Prepare(ctx context.Context, db dbtx) (*Queries, error) {
+	q := Queries{db: db}
+	var err error
+	if q.getCity, err = db.PrepareContext(ctx, getCity); err != nil {
+		return nil, err
+	}
+	if q.listCities, err = db.PrepareContext(ctx, listCities); err != nil {
+		return nil, err
+	}
+	if q.listVenues, err = db.PrepareContext(ctx, listVenues); err != nil {
+		return nil, err
+	}
+	return &q, nil
+}
+
 type Queries struct {
 	db dbtx
 
 	tx         *sql.Tx
-	listCities *sql.Stmt
 	getCity    *sql.Stmt
+	listCities *sql.Stmt
 	listVenues *sql.Stmt
 }
 
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		tx:         tx,
+		db:         tx,
+		getCity:    q.getCity,
+		listCities: q.listCities,
+		listVenues: q.listVenues,
+	}
+}
+
+const getCity = `
+SELECT slug, name FROM city WHERE slug = $1
+`
+
+func (q *Queries) GetCity(ctx context.Context, slug string) (City, error) {
+	var row *sql.Row
+	switch {
+	case q.getCity != nil && q.tx != nil:
+		row = q.tx.StmtContext(ctx, q.getCity).QueryRowContext(ctx, slug)
+	case q.getCity != nil:
+		row = q.getCity.QueryRowContext(ctx, slug)
+	default:
+		row = q.db.QueryRowContext(ctx, getCity, slug)
+	}
+	i := City{}
+	err := row.Scan(&i.Slug, &i.Name)
+	return i, err
+}
+
 const listCities = `
-SELECT slug, name FROM city WHERE  ORDER BY name
+SELECT slug, name FROM city ORDER BY name
 `
 
 func (q *Queries) ListCities(ctx context.Context) ([]City, error) {
@@ -70,25 +118,6 @@ func (q *Queries) ListCities(ctx context.Context) ([]City, error) {
 	return items, nil
 }
 
-const getCity = `
-SELECT slug, name FROM city WHERE slug = $1
-`
-
-func (q *Queries) GetCity(ctx context.Context, slug string) (City, error) {
-	var row *sql.Row
-	switch {
-	case q.getCity != nil && q.tx != nil:
-		row = q.tx.StmtContext(ctx, q.getCity).QueryRowContext(ctx, slug)
-	case q.getCity != nil:
-		row = q.getCity.QueryRowContext(ctx, slug)
-	default:
-		row = q.db.QueryRowContext(ctx, getCity, slug)
-	}
-	i := City{}
-	err := row.Scan(&i.Slug, &i.Name)
-	return i, err
-}
-
 const listVenues = `
 SELECT slug, name, city, spotify_playlist, songkick_id FROM venue WHERE city = $1 ORDER BY name
 `