Merge branch 'dev'

Author: aarondl

CHANGELOG.md

@@ -4,6 +4,30 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic
 Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+- Add types.DecimalContext to control the context with which new decimals
+  are created. This is important if your application uses a special context
+  with more precision or requires the Go operating mode for example.
+- Add WhereNotIn/AndNotIn/OrNotIn query mods to help solve a bug
+- Add alias struct case type (uses the columns alias) (thanks @Darkclainer)
+- Add ability to type replace on tables (thanks @stephenafamo)
+
+### Changed
+
+- Change the way column cache keys are created and looked up, improving memory
+  performance of sqlboiler's caching layer (thanks @zikaeroh)
+
+### Fixed
+
+- Fix the psql driver to correctly ignore generated columns (thanks @chochihim)
+- Fix an issue with mariadb ssl-mode when running generated tests
+  (thanks @tooolbox)
+- Fix $1 placeholder in mysql DeleteAll() when using soft delete
+  (thanks @mfzy602)
+- Fix boilingcore tests to use current module via replace instead of the
+  published v4 module
+
 ## [v4.1.2] - 2020-05-18
 
 ### Fixed

README.md

@@ -444,7 +444,7 @@ Flags:
       --no-tests                   Disable generated go test files
   -o, --output string              The name of the folder to output to (default "models")
   -p, --pkgname string             The name you wish to assign to your generated package (default "models")
-      --struct-tag-casing string   Decides the casing for go structure tag names. camel, title or snake (default snake) (default "snake")
+      --struct-tag-casing string   Decides the casing for go structure tag names. camel, title, alias or snake (default "snake")
   -t, --tag strings                Struct tags to be included on your models in addition to json, yaml, toml
       --tag-ignore strings         List of column names that should have tags values set to '-' (ignored during parsing)
       --templates strings          A templates directory, overrides the bindata'd template folders in sqlboiler
@@ -639,10 +639,17 @@ The way to accomplish this is through the config file.
 [[types]]
   # The match is a drivers.Column struct, and matches on almost all fields.
   # Notable exception for the unique bool. Matches are done
-  # with "logical and" meaning it must match all specified matchers. Boolean values
-  # are only checked if all the string specifiers match first, and they
-  # must always match.
+  # with "logical and" meaning it must match all specified matchers.
+  # Boolean values are only checked if all the string specifiers match first,
+  # and they must always match.
+  #
   # Not shown here: db_type is the database type and a very useful matcher
+  # We can also whitelist tables for this replace by adding to the types.match:
+  # tables = ['users', 'videos']
+  #
+  # Note there is precedence for types.match, more specific things should appear
+  # further down in the config as once a matching rule is found it is executed
+  # immediately.
   [types.match]
     type = "null.String"
     nullable = true

boilingcore/boilingcore.go

@@ -420,6 +420,10 @@ func (s *State) processTypeReplacements() error {
 		for i := range s.Tables {
 			t := s.Tables[i]
 
+			if !shouldReplaceInTable(t, r) {
+				continue
+			}
+
 			for j := range t.Columns {
 				c := t.Columns[j]
 				if matchColumn(c, r.Match) {
@@ -521,6 +525,22 @@ func columnMerge(dst, src drivers.Column) drivers.Column {
 	return ret
 }
 
+// shouldReplaceInTable checks if tables were specified in types.match in the config.
+// If tables were set, it checks if the given table is among the specified tables.
+func shouldReplaceInTable(t drivers.Table, r TypeReplace) bool {
+	if len(r.Tables) == 0 {
+		return true
+	}
+
+	for _, replaceInTable := range r.Tables {
+		if replaceInTable == t.Name {
+			return true
+		}
+	}
+
+	return false
+}
+
 // initOutFolders creates the folders that will hold the generated output.
 func (s *State) initOutFolders(lazyTemplates []lazyTemplate) error {
 	if s.Config.Wipe {

boilingcore/boilingcore_test.go

@@ -65,7 +65,23 @@ func TestNew(t *testing.T) {
 
 	buf := &bytes.Buffer{}
 
-	cmd := exec.Command("go", "mod", "init", "github.com/volatiletech/sqlboiler-test")
+	cmd := exec.Command("go", "env", "GOMOD")
+	goModFilePath, err := cmd.Output()
+	if err != nil {
+		t.Fatalf("go env GOMOD cmd execution failed: %s", err)
+	}
+
+	cmd = exec.Command("go", "mod", "init", "github.com/volatiletech/sqlboiler-test")
+	cmd.Dir = state.Config.OutFolder
+	cmd.Stderr = buf
+
+	if err = cmd.Run(); err != nil {
+		t.Errorf("go mod init cmd execution failed: %s", err)
+		outputCompileErrors(buf, state.Config.OutFolder)
+		fmt.Println()
+	}
+
+	cmd = exec.Command("go", "mod", "edit", fmt.Sprintf("-replace=github.com/volatiletech/sqlboiler/v4=%s", filepath.Dir(string(goModFilePath))))
 	cmd.Dir = state.Config.OutFolder
 	cmd.Stderr = buf
 
@@ -192,6 +208,18 @@ func TestProcessTypeReplacements(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name: "named_table",
+			Columns: []drivers.Column{
+				{
+					Name:     "id",
+					Type:     "int",
+					DBType:   "serial",
+					Default:  "some db nonsense",
+					Nullable: false,
+				},
+			},
+		},
 	}
 
 	s.Config.TypeReplaces = []TypeReplace{
@@ -206,6 +234,18 @@ func TestProcessTypeReplacements(t *testing.T) {
 				ThirdParty: []string{`"rock.com/excellent"`},
 			},
 		},
+		{
+			Tables: []string{"named_table"},
+			Match: drivers.Column{
+				DBType: "serial",
+			},
+			Replace: drivers.Column{
+				Type: "excellent.NamedType",
+			},
+			Imports: importers.Set{
+				ThirdParty: []string{`"rock.com/excellent-name"`},
+			},
+		},
 		{
 			Match: drivers.Column{
 				Type:     "null.String",
@@ -255,4 +295,11 @@ func TestProcessTypeReplacements(t *testing.T) {
 	if i := s.Config.Imports.BasedOnType["big.Int"].Standard[0]; i != `"math/big"` {
 		t.Error("imports were not adjusted")
 	}
+
+	if typ := s.Tables[1].Columns[0].Type; typ != "excellent.NamedType" {
+		t.Error("type was wrong:", typ)
+	}
+	if i := s.Config.Imports.BasedOnType["excellent.NamedType"].ThirdParty[0]; i != `"rock.com/excellent-name"` {
+		t.Error("imports were not adjusted")
+	}
 }

boilingcore/config.go

@@ -45,6 +45,7 @@ type Config struct {
 
 // TypeReplace replaces a column type with something else
 type TypeReplace struct {
+	Tables  []string       `toml:"tables,omitempty" json:"tables,omitempty"`
 	Match   drivers.Column `toml:"match,omitempty" json:"match,omitempty"`
 	Replace drivers.Column `toml:"replace,omitempty" json:"replace,omitempty"`
 	Imports importers.Set  `toml:"imports,omitempty" json:"imports,omitempty"`
@@ -194,6 +195,8 @@ func ConvertTypeReplace(i interface{}) []TypeReplace {
 		replace.Match = columnFromInterface(replaceIntf["match"])
 		replace.Replace = columnFromInterface(replaceIntf["replace"])
 
+		replace.Tables = tablesOfTypeReplace(replaceIntf["match"])
+
 		if imps := replaceIntf["imports"]; imps != nil {
 			imps = cast.ToStringMap(imps)
 			var err error
@@ -209,6 +212,17 @@ func ConvertTypeReplace(i interface{}) []TypeReplace {
 	return replaces
 }
 
+func tablesOfTypeReplace(i interface{}) []string {
+	tables := []string{}
+
+	m := cast.ToStringMap(i)
+	if s := m["tables"]; s != nil {
+		tables = cast.ToStringSlice(s)
+	}
+
+	return tables
+}
+
 func columnFromInterface(i interface{}) (col drivers.Column) {
 	m := cast.ToStringMap(i)
 	if s := m["name"]; s != nil {

boilingcore/config_test.go

@@ -1,6 +1,7 @@
 package boilingcore
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/volatiletech/sqlboiler/v4/drivers"
@@ -186,6 +187,7 @@ func TestConvertTypeReplace(t *testing.T) {
 		"udt_name":       "d",
 		"full_db_type":   "e",
 		"arr_type":       "f",
+		"tables":         []string{"g", "h"},
 		"auto_generated": true,
 		"nullable":       true,
 	}
@@ -248,4 +250,7 @@ func TestConvertTypeReplace(t *testing.T) {
 	if got := r.Imports.ThirdParty[0]; got != "github.com/abc" {
 		t.Error("standard import wrong:", got)
 	}
+	if got := r.Tables; !reflect.DeepEqual(r.Tables, []string{"g", "h"}) {
+		t.Error("tables in types.match wrong:", got)
+	}
 }