MySQL support

README.md

@@ -307,6 +307,8 @@ Each package document has the following keys:
   - Directory of SQL queries or path to single SQL file
 - `schema`:
   - Directory of SQL migrations or path to single SQL file
+- `engine`:
+  - Either `postgresql` or `mysql`. Defaults to `postgresql`. MySQL support is experimental
 
 ### Type Overrides
 
@@ -411,13 +413,17 @@ Each commit is deployed to the [`devel` channel on Equinox](https://dl.equinox.i
 - [Linux](https://bin.equinox.io/c/gvM95th6ps1/sqlc-devel-linux-amd64.tgz)
 - [macOS](https://bin.equinox.io/c/gvM95th6ps1/sqlc-devel-darwin-amd64.zip)
 
-## Other Database Engines
+## Other Databases and Languages
 
-sqlc currently only supports PostgreSQL. If you'd like to support another database, we'd welcome a contribution.
+sqlc currently only supports PostgreSQL / Go. MySQL support has been merged,
+but it's marked as experimental. SQLite and TypeScript support are planned.
 
-## Other Language Backends
+| Language     | PostgreSQL       | MySQL            | SQLite           |
+| ------------ |:----------------:|:----------------:|:----------------:|
+| Go           |:white_check_mark:|:warning:         |:timer_clock:     |
+| TypeScript   |:timer_clock:     |:timer_clock:     |:timer_clock:     |
 
-sqlc currently only generates Go code, but if you'd like to build another language backend, we'd welcome a contribution.
+If you'd like to add another database or language, we'd welcome a contribution.
 
 ## Acknowledgements
 

go.mod

@@ -8,4 +8,10 @@ require (
 	github.com/jinzhu/inflection v1.0.0
 	github.com/lfittl/pg_query_go v1.0.0
 	github.com/spf13/cobra v0.0.5
+	github.com/spf13/pflag v1.0.5 // indirect
+	golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 // indirect
+	golang.org/x/sys v0.0.0-20191220220014-0732a990476f // indirect
+	google.golang.org/genproto v0.0.0-20191223191004-3caeed10a8bf // indirect
+	google.golang.org/grpc v1.26.0 // indirect
+	vitess.io/vitess v0.0.0-20191113025808-0629f0da20ab
 )

internal/cmd/cmd.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 
 	"github.com/kyleconroy/sqlc/internal/dinosql"
+	"github.com/kyleconroy/sqlc/internal/mysql"
 
 	"github.com/davecgh/go-spew/spew"
 	pg "github.com/lfittl/pg_query_go"
@@ -126,48 +127,57 @@ var genCmd = &cobra.Command{
 
 		output := map[string]string{}
 
-		for i, pkg := range settings.Packages {
+		for _, pkg := range settings.Packages {
 			name := pkg.Name
 
-			if pkg.Path == "" {
-				fmt.Fprintf(os.Stderr, "package[%d]: path must be set\n", i)
-				errored = true
-				continue
-			}
+			var result dinosql.Generateable
 
-			if name == "" {
-				name = filepath.Base(pkg.Path)
-			}
+			switch pkg.Engine {
 
-			c, err := dinosql.ParseCatalog(pkg.Schema)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "# package %s\n", name)
-				if parserErr, ok := err.(*dinosql.ParserErr); ok {
-					for _, fileErr := range parserErr.Errs {
-						fmt.Fprintf(os.Stderr, "%s:%d:%d: %s\n", fileErr.Filename, fileErr.Line, fileErr.Column, fileErr.Err)
+			case dinosql.EngineMySQL:
+				// Experimental MySQL support
+				q, err := mysql.GeneratePkg(name, pkg.Schema, pkg.Queries, settings)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "# package %s\n", name)
+					fmt.Fprintf(os.Stderr, "error parsing file: %s\n", err)
+					errored = true
+					continue
+				}
+				result = q
+
+			case dinosql.EnginePostgreSQL:
+				c, err := dinosql.ParseCatalog(pkg.Schema)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "# package %s\n", name)
+					if parserErr, ok := err.(*dinosql.ParserErr); ok {
+						for _, fileErr := range parserErr.Errs {
+							fmt.Fprintf(os.Stderr, "%s:%d:%d: %s\n", fileErr.Filename, fileErr.Line, fileErr.Column, fileErr.Err)
+						}
+					} else {
+						fmt.Fprintf(os.Stderr, "error parsing schema: %s\n", err)
 					}
-				} else {
-					fmt.Fprintf(os.Stderr, "error parsing schema: %s\n", err)
+					errored = true
+					continue
 				}
-				errored = true
-				continue
-			}
 
-			q, err := dinosql.ParseQueries(c, settings, pkg)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "# package %s\n", name)
-				if parserErr, ok := err.(*dinosql.ParserErr); ok {
-					for _, fileErr := range parserErr.Errs {
-						fmt.Fprintf(os.Stderr, "%s:%d:%d: %s\n", fileErr.Filename, fileErr.Line, fileErr.Column, fileErr.Err)
+				q, err := dinosql.ParseQueries(c, pkg)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "# package %s\n", name)
+					if parserErr, ok := err.(*dinosql.ParserErr); ok {
+						for _, fileErr := range parserErr.Errs {
+							fmt.Fprintf(os.Stderr, "%s:%d:%d: %s\n", fileErr.Filename, fileErr.Line, fileErr.Column, fileErr.Err)
+						}
+					} else {
+						fmt.Fprintf(os.Stderr, "error parsing queries: %s\n", err)
 					}
-				} else {
-					fmt.Fprintf(os.Stderr, "error parsing queries: %s\n", err)
+					errored = true
+					continue
 				}
-				errored = true
-				continue
+				result = q
+
 			}
 
-			files, err := dinosql.Generate(q, settings, pkg)
+			files, err := dinosql.Generate(result, settings)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "# package %s\n", name)
 				fmt.Fprintf(os.Stderr, "error generating code: %s\n", err)
@@ -199,13 +209,13 @@ var checkCmd = &cobra.Command{
 	Use:   "compile",
 	Short: "Statically check SQL for syntax and type errors",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		blob, err := ioutil.ReadFile("sqlc.json")
+		file, err := os.Open("sqlc.json")
 		if err != nil {
 			return err
 		}
 
-		var settings dinosql.GenerateSettings
-		if err := json.Unmarshal(blob, &settings); err != nil {
+		settings, err := dinosql.ParseConfig(file)
+		if err != nil {
 			return err
 		}
 
@@ -214,7 +224,7 @@ var checkCmd = &cobra.Command{
 			if err != nil {
 				return err
 			}
-			if _, err := dinosql.ParseQueries(c, settings, pkg); err != nil {
+			if _, err := dinosql.ParseQueries(c, pkg); err != nil {
 				return err
 			}
 		}

internal/dinosql/checks_test.go

@@ -12,7 +12,6 @@ import (
 func TestFuncs(t *testing.T) {
 	_, err := ParseQueries(
 		pg.NewCatalog(),
-		GenerateSettings{},
 		PackageSettings{
 			Queries: filepath.Join("testdata", "funcs"),
 		},

internal/dinosql/config.go

@@ -5,20 +5,45 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"path/filepath"
 	"strings"
 
 	"github.com/kyleconroy/sqlc/internal/pg"
 )
 
+const errMessageNoVersion = `The configuration file must have a version number.
+Set the version to 1 at the top of sqlc.json:
+
+{
+  "version": "1"
+  ...
+}
+`
+
+const errMessageUnknownVersion = `The configuration file has an invalid version number.
+The only supported version is "1".
+`
+
+const errMessageNoPackages = `No packages are configured`
+
 type GenerateSettings struct {
-	Version   string            `json:"version"`
-	Packages  []PackageSettings `json:"packages"`
-	Overrides []Override        `json:"overrides,omitempty"`
-	Rename    map[string]string `json:"rename,omitempty"`
+	Version    string            `json:"version"`
+	Packages   []PackageSettings `json:"packages"`
+	Overrides  []Override        `json:"overrides,omitempty"`
+	Rename     map[string]string `json:"rename,omitempty"`
+	PackageMap map[string]PackageSettings
 }
 
+type Engine string
+
+const (
+	EngineMySQL      Engine = "mysql"
+	EnginePostgreSQL Engine = "postgresql"
+)
+
 type PackageSettings struct {
 	Name                string     `json:"name"`
+	Engine              Engine     `json:"engine,omitempty"`
 	Path                string     `json:"path"`
 	Schema              string     `json:"schema"`
 	Queries             string     `json:"queries"`
@@ -96,6 +121,8 @@ func (o *Override) Parse() error {
 var ErrMissingVersion = errors.New("no version number")
 var ErrUnknownVersion = errors.New("invalid version number")
 var ErrNoPackages = errors.New("no packages")
+var ErrNoPackageName = errors.New("missing package name")
+var ErrNoPackagePath = errors.New("missing package path")
 
 func ParseConfig(rd io.Reader) (GenerateSettings, error) {
 	dec := json.NewDecoder(rd)
@@ -119,11 +146,36 @@ func ParseConfig(rd io.Reader) (GenerateSettings, error) {
 		}
 	}
 	for j := range config.Packages {
+		if config.Packages[j].Path == "" {
+			return config, ErrNoPackagePath
+		}
 		for i := range config.Packages[j].Overrides {
 			if err := config.Packages[j].Overrides[i].Parse(); err != nil {
 				return config, err
 			}
 		}
+		if config.Packages[j].Name == "" {
+			config.Packages[j].Name = filepath.Base(config.Packages[j].Path)
+		}
+		if config.Packages[j].Engine == "" {
+			config.Packages[j].Engine = EnginePostgreSQL
+		}
 	}
-	return config, nil
+	err := config.PopulatePkgMap()
+
+	return config, err
+}
+
+func (s *GenerateSettings) PopulatePkgMap() error {
+	packageMap := make(map[string]PackageSettings)
+
+	for _, c := range s.Packages {
+		if c.Name == "" {
+			return ErrNoPackageName
+		}
+		packageMap[c.Name] = c
+	}
+	s.PackageMap = packageMap
+
+	return nil
 }