Implement per-column type overrides. (sqlc-dev#123)

* Implement per-column type overrides.

Often a user may want to override the Go type used for model
generation and query generation, but it's not a 1-to-1 mapping
of SQL types to Go type. Instead, the override to use depends
entirely on the column of a particular table. This commit adds the
functionality to override types of generated columns in models and query
parameters by adding a new 'overrides' configuration settings object
on a per-package basis.

This required tracking down a number of places where the column's Table
FQN wasn't properly propagated through to the the model or query
parameter Column. This change necessitated updating a bunch of tests to
match.

Lastly, I've added a test to prove the functionality works (in addition
to testing it on a large code base) and added a documentation section in
the README.

* update docs

Author: inconshreveable

README.md

@@ -324,8 +324,7 @@ instead.
   "packages": [...],
   "overrides": [
       {
-          "go_type": "uuid.UUID",
-          "package": "github.com/gofrs/uuid",
+          "go_type": "github.com/gofrs/uuid.UUID",
           "postgres_type": "uuid"
       }
   ]
@@ -336,12 +335,50 @@ Each override document has the following keys:
 - `postgres_type`:
   - The PostgreSQL type to override. Find the full list of supported types in [gen.go](https://github.com/kyleconroy/sqlc/blob/master/internal/dinosql/gen.go#L438).
 - `go_type`:
-  - The Go type, with package name, to use in the generated code.
-- `package`:
-  - The full import path for the package.
+  - A fully qualified name to a Go type to use in the generated code.
 - `null`:
   - If true, use this type when a column in nullable. Defaults to `false`.
 
+### Per-Column Type Overrides
+
+Sometimes you would like to override the Go type used in model or query generation for
+a specific field of a table and not on a type basis as described in the previous section.
+
+This may be configured by specifying the `column` property in the override definition. `column`
+should be of the form `table.column` buy you may be even more specify by specifying `schema.table.column`
+or `catalog.schema.table.column`.
+
+```
+{
+  "version": "1",
+  "packages": [...],
+  "overrides": [
+    {
+      "column": "authors.id",
+      "go_type": "github.com/segmentio/ksuid.KSUID"
+    }
+  ]
+}
+```
+
+### Package Level Overrides
+
+Overrides can be configured globally, as demonstrated in the previous sections, or they can be configured on a per-package which
+scopes the override behavior to just a single package:
+
+```
+{
+  "version": "1",
+  "packages": [
+    {
+      ...
+      "overrides": [...]
+    }
+  ],
+}
+```
+
+
 ### Renaming Struct Fields
 
 Struct field names are generated from column names using a simple algorithm:

internal/catalog/build.go

@@ -151,6 +151,7 @@ func Update(c *pg.Catalog, stmt nodes.Node) error {
 						DataType: join(d.TypeName.Names, "."),
 						NotNull:  isNotNull(d),
 						IsArray:  isArray(d.TypeName),
+						Table:    fqn,
 					})
 
 				case nodes.AT_AlterColumnType:
@@ -197,6 +198,7 @@ func Update(c *pg.Catalog, stmt nodes.Node) error {
 					DataType: join(n.TypeName.Names, "."),
 					NotNull:  isNotNull(n),
 					IsArray:  isArray(n.TypeName),
+					Table:    fqn,
 				})
 			}
 		}

internal/catalog/build_test.go

@@ -105,7 +105,7 @@ func TestUpdate(t *testing.T) {
 						Tables: map[string]pg.Table{
 							"foo": pg.Table{
 								Name:    "foo",
-								Columns: []pg.Column{{Name: "bar", DataType: "text", NotNull: true}},
+								Columns: []pg.Column{{Name: "bar", DataType: "text", NotNull: true, Table: pg.FQN{Schema: "public", Rel: "foo"}}},
 							},
 						},
 					},
@@ -123,7 +123,7 @@ func TestUpdate(t *testing.T) {
 							"foo": pg.Table{
 								Name: "foo",
 								Columns: []pg.Column{
-									{Name: "bar", DataType: "text", IsArray: true, NotNull: true},
+									{Name: "bar", DataType: "text", IsArray: true, NotNull: true, Table: pg.FQN{Schema: "public", Rel: "foo"}},
 								},
 							},
 						},
@@ -142,7 +142,7 @@ func TestUpdate(t *testing.T) {
 						Tables: map[string]pg.Table{
 							"foo": pg.Table{
 								Name:    "foo",
-								Columns: []pg.Column{{Name: "bar", DataType: "text"}},
+								Columns: []pg.Column{{Name: "bar", DataType: "text", Table: pg.FQN{Schema: "public", Rel: "foo"}}},
 							},
 						},
 					},
@@ -160,7 +160,7 @@ func TestUpdate(t *testing.T) {
 						Tables: map[string]pg.Table{
 							"foo": pg.Table{
 								Name:    "foo",
-								Columns: []pg.Column{{Name: "bar", DataType: "text"}},
+								Columns: []pg.Column{{Name: "bar", DataType: "text", Table: pg.FQN{Schema: "public", Rel: "foo"}}},
 							},
 						},
 					},
@@ -178,7 +178,7 @@ func TestUpdate(t *testing.T) {
 						Tables: map[string]pg.Table{
 							"foo": pg.Table{
 								Name:    "foo",
-								Columns: []pg.Column{{Name: "baz", DataType: "text"}},
+								Columns: []pg.Column{{Name: "baz", DataType: "text", Table: pg.FQN{Schema: "public", Rel: "foo"}}},
 							},
 						},
 					},
@@ -196,7 +196,7 @@ func TestUpdate(t *testing.T) {
 						Tables: map[string]pg.Table{
 							"foo": pg.Table{
 								Name:    "foo",
-								Columns: []pg.Column{{Name: "bar", DataType: "bool"}},
+								Columns: []pg.Column{{Name: "bar", DataType: "bool", Table: pg.FQN{Schema: "public", Rel: "foo"}}},
 							},
 						},
 					},
@@ -335,7 +335,7 @@ func TestUpdate(t *testing.T) {
 							"venues": pg.Table{
 								Name: "venues",
 								Columns: []pg.Column{
-									{Name: "id", DataType: "serial", NotNull: true},
+									{Name: "id", DataType: "serial", NotNull: true, Table: pg.FQN{Schema: "public", Rel: "venues"}},
 								},
 							},
 						},

internal/dinosql/config.go

@@ -3,25 +3,96 @@ package dinosql
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
-)
+	"strings"
 
-type PackageSettings struct {
-	Name                string `json:"name"`
-	Path                string `json:"path"`
-	Schema              string `json:"schema"`
-	Queries             string `json:"queries"`
-	EmitPreparedQueries bool   `json:"emit_prepared_queries"`
-	EmitJSONTags        bool   `json:"emit_json_tags"`
-}
+	"github.com/kyleconroy/sqlc/internal/pg"
+)
 
 type GenerateSettings struct {
 	Version   string            `json:"version"`
 	Packages  []PackageSettings `json:"packages"`
-	Overrides []TypeOverride    `json:"overrides,omitempty"`
+	Overrides []Override        `json:"overrides,omitempty"`
 	Rename    map[string]string `json:"rename,omitempty"`
 }
 
+type PackageSettings struct {
+	Name                string     `json:"name"`
+	Path                string     `json:"path"`
+	Schema              string     `json:"schema"`
+	Queries             string     `json:"queries"`
+	EmitPreparedQueries bool       `json:"emit_prepared_queries"`
+	EmitJSONTags        bool       `json:"emit_json_tags"`
+	Overrides           []Override `json:"overrides"`
+}
+
+type Override struct {
+	// name of the golang type to use, e.g. `github.com/segmentio/ksuid.KSUID`
+	GoType string `json:"go_type"`
+
+	// fully qualified name of the Go type, e.g. `github.com/segmentio/ksuid.KSUID`
+	PostgresType string `json:"postgres_type"`
+
+	// True if the GoType should override if the maching postgres type is nullable
+	Null bool `json:"null"`
+
+	// fully qualified name of the column, e.g. `accounts.id`
+	Column string `json:"column"`
+
+	columnName string
+	table      pg.FQN
+	goTypeName string
+	goPackage  string
+}
+
+func (o *Override) Parse() error {
+	// validate option combinations
+	switch {
+	case o.Column != "" && o.PostgresType != "":
+		return fmt.Errorf("Override specifying both `column` (%q) and `postgres_type` (%q) is not valid.", o.Column, o.PostgresType)
+	case o.Column == "" && o.PostgresType == "":
+		return fmt.Errorf("Override must specify one of either `column` or `postgres_type`")
+	}
+
+	// validate Column
+	if o.Column != "" {
+		colParts := strings.Split(o.Column, ".")
+		switch len(colParts) {
+		case 2:
+			o.columnName = colParts[1]
+			o.table = pg.FQN{Schema: "public", Rel: colParts[0]}
+		case 3:
+			o.columnName = colParts[2]
+			o.table = pg.FQN{Schema: colParts[0], Rel: colParts[1]}
+		case 4:
+			o.columnName = colParts[3]
+			o.table = pg.FQN{Catalog: colParts[0], Schema: colParts[1], Rel: colParts[2]}
+		default:
+			return fmt.Errorf("Override `column` specifier %q is not the proper format, expected '[catalog.][schema.]colname.tablename'", o.Column)
+		}
+	}
+
+	// validate GoType
+	lastDot := strings.LastIndex(o.GoType, ".")
+	if lastDot == -1 {
+		return fmt.Errorf("Package override `go_type` specificier %q is not the proper format, expected 'package.type', e.g. 'github.com/segmentio/ksuid.KSUID'", o.GoType)
+	}
+	lastSlash := strings.LastIndex(o.GoType, "/")
+	if lastSlash == -1 {
+		return fmt.Errorf("Package override `go_type` specificier %q is not the proper format, expected 'package.type', e.g. 'github.com/segmentio/ksuid.KSUID'", o.GoType)
+	}
+	o.goTypeName = o.GoType[lastSlash+1:]
+	o.goPackage = o.GoType[:lastDot]
+	isPointer := o.GoType[0] == '*'
+	if isPointer {
+		o.goPackage = o.goPackage[1:]
+		o.goTypeName = "*" + o.goTypeName
+	}
+
+	return nil
+}
+
 var ErrMissingVersion = errors.New("no version number")
 var ErrUnknownVersion = errors.New("invalid version number")
 var ErrNoPackages = errors.New("no packages")
@@ -42,5 +113,17 @@ func ParseConfig(rd io.Reader) (GenerateSettings, error) {
 	if len(config.Packages) == 0 {
 		return config, ErrNoPackages
 	}
+	for i := range config.Overrides {
+		if err := config.Overrides[i].Parse(); err != nil {
+			return config, err
+		}
+	}
+	for j := range config.Packages {
+		for i := range config.Packages[j].Overrides {
+			if err := config.Packages[j].Overrides[i].Parse(); err != nil {
+				return config, err
+			}
+		}
+	}
 	return config, nil
 }

internal/dinosql/gen.go

@@ -208,8 +208,8 @@ func (r Result) ModelImports() [][]string {
 	// Custom imports
 	var pkg []string
 	overrideTypes := map[string]string{}
-	for _, o := range r.Settings.Overrides {
-		overrideTypes[o.GoType] = o.Package
+	for _, o := range append(r.Settings.Overrides, r.packageSettings.Overrides...) {
+		overrideTypes[o.goTypeName] = o.goPackage
 	}
 
 	_, overrideNullTime := overrideTypes["pq.NullTime"]
@@ -321,8 +321,8 @@ func (r Result) QueryImports(filename string) [][]string {
 
 	var pkg []string
 	overrideTypes := map[string]string{}
-	for _, o := range r.Settings.Overrides {
-		overrideTypes[o.GoType] = o.Package
+	for _, o := range append(r.Settings.Overrides, r.packageSettings.Overrides...) {
+		overrideTypes[o.goTypeName] = o.goPackage
 	}
 
 	if sliceScan() {
@@ -432,17 +432,24 @@ func (r Result) Structs() []GoStruct {
 }
 
 func (r Result) goType(col core.Column) string {
-	typ := r.goInnerType(col.DataType, col.NotNull || col.IsArray)
+	typ := r.goInnerType(col)
 	if col.IsArray {
 		return "[]" + typ
 	}
 	return typ
 }
 
-func (r Result) goInnerType(columnType string, notNull bool) string {
-	for _, oride := range r.Settings.Overrides {
+func (r Result) goInnerType(col core.Column) string {
+	columnType := col.DataType
+	notNull := col.NotNull || col.IsArray
+
+	// package overrides have a higher precedence
+	for _, oride := range append(r.Settings.Overrides, r.packageSettings.Overrides...) {
 		if oride.PostgresType == columnType && oride.Null != notNull {
-			return oride.GoType
+			return oride.goTypeName
+		}
+		if oride.columnName == col.Name && oride.table == col.Table {
+			return oride.goTypeName
 		}
 	}
 
@@ -964,6 +971,7 @@ func lowerTitle(s string) string {
 }
 
 func Generate(r *Result, global GenerateSettings, settings PackageSettings) (map[string]string, error) {
+	r.packageSettings = settings
 	funcMap := template.FuncMap{
 		"lowerTitle": lowerTitle,
 		"imports":    r.Imports(settings),

internal/dinosql/gen_test.go

@@ -35,9 +35,30 @@ func TestColumnsToStruct(t *testing.T) {
 			DataType: "bytea",
 			NotNull:  true,
 		},
+		{
+			Name:     "retyped",
+			DataType: "text",
+			NotNull:  true,
+		},
+	}
+
+	// all of the columns are on the 'foo' table
+	for i := range cols {
+		cols[i].Table = pg.FQN{Schema: "public", Rel: "foo"}
 	}
 
 	r := Result{}
+
+	// set up column-based override test
+	o := Override{
+		GoType: "example.com/pkg.CustomType",
+		Column: "foo.retyped",
+	}
+	o.Parse()
+	r.packageSettings = PackageSettings{
+		Overrides: []Override{o},
+	}
+
 	actual := r.columnsToStruct("Foo", cols)
 	expected := &GoStruct{
 		Name: "Foo",
@@ -47,6 +68,7 @@ func TestColumnsToStruct(t *testing.T) {
 			{Name: "Count_2", Type: "int64", Tags: map[string]string{"json:": "count_2"}},
 			{Name: "Tags", Type: "[]string", Tags: map[string]string{"json:": "tags"}},
 			{Name: "ByteSeq", Type: "[]byte", Tags: map[string]string{"json:": "byte_seq"}},
+			{Name: "Retyped", Type: "pkg.CustomType", Tags: map[string]string{"json:": "retyped"}},
 		},
 	}
 	if diff := cmp.Diff(expected, actual); diff != "" {