v6.0.2

associations/association.go

@@ -160,5 +160,9 @@ func fieldIsNil(f reflect.Value) bool {
 
 // IsZeroOfUnderlyingType will check if the value of anything is the equal to the Zero value of that type.
 func IsZeroOfUnderlyingType(x interface{}) bool {
+	if x == nil {
+		return true
+	}
+
 	return reflect.DeepEqual(x, reflect.Zero(reflect.TypeOf(x)).Interface())
 }

associations/association_test.go

@@ -0,0 +1,37 @@
+package associations
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/gobuffalo/nulls"
+	"github.com/gofrs/uuid"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func Test_IsZeroOfUnderlyingType(t *testing.T) {
+	for k, tc := range []struct {
+		in   interface{}
+		zero bool
+	}{
+		{in: nil, zero: true},
+		{in: 0, zero: true},
+		{in: 1, zero: false},
+		{in: false, zero: true},
+		{in: "", zero: true},
+		{in: interface{}(nil), zero: true},
+		{in: uuid.NullUUID{}, zero: true},
+		{in: uuid.UUID{}, zero: true},
+		{in: uuid.NullUUID{Valid: true}, zero: false},
+		{in: nulls.Int{}, zero: true},
+		{in: nulls.String{}, zero: true},
+		{in: nulls.Bool{}, zero: true},
+		{in: nulls.Float64{}, zero: true},
+		{in: sql.NullString{}, zero: true},
+		{in: sql.NullString{Valid: true}, zero: false},
+	} {
+		t.Run(fmt.Sprintf("case=%d", k), func(t *testing.T) {
+			assert.EqualValues(t, tc.zero, IsZeroOfUnderlyingType(tc.in))
+		})
+	}
+}

associations/associations_for_struct.go

@@ -1,7 +1,6 @@
 package associations
 
 import (
-	"errors"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -30,7 +29,7 @@ var associationBuilders = map[string]associationBuilder{}
 func ForStruct(s interface{}, fields ...string) (Associations, error) {
 	t, v := getModelDefinition(s)
 	if t.Kind() != reflect.Struct {
-		return nil, errors.New("could not get struct associations: not a struct")
+		return nil, fmt.Errorf("could not get struct associations: not a struct but %T", s)
 	}
 	fields = trimFields(fields)
 	associations := Associations{}
@@ -73,6 +72,16 @@ func ForStruct(s interface{}, fields ...string) (Associations, error) {
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
 
+		// inline embedded field
+		if f.Anonymous {
+			innerAssociations, err := ForStruct(v.Field(i).Interface(), fields...)
+			if err != nil {
+				return nil, err
+			}
+			associations = append(associations, innerAssociations...)
+			continue
+		}
+
 		// ignores those fields not included in fields list.
 		if len(fields) > 0 && fieldIgnoredIn(fields, f.Name) {
 			continue

associations/belongs_to_association.go

@@ -128,15 +128,22 @@ func (b *belongsToAssociation) BeforeInterface() interface{} {
 
 func (b *belongsToAssociation) BeforeSetup() error {
 	ownerID := reflect.Indirect(reflect.ValueOf(b.ownerModel.Interface())).FieldByName("ID")
-	if b.ownerID.CanSet() {
-		if n := nulls.New(b.ownerID.Interface()); n != nil {
-			b.ownerID.Set(reflect.ValueOf(n.Parse(ownerID.Interface())))
-		} else if b.ownerID.Kind() == reflect.Ptr {
-			b.ownerID.Set(ownerID.Addr())
+	toSet := b.ownerID
+	switch b.ownerID.Type().Name() {
+	case "NullUUID":
+		b.ownerID.FieldByName("Valid").Set(reflect.ValueOf(true))
+		toSet = b.ownerID.FieldByName("UUID")
+	}
+
+	if toSet.CanSet() {
+		if n := nulls.New(toSet.Interface()); n != nil {
+			toSet.Set(reflect.ValueOf(n.Parse(ownerID.Interface())))
+		} else if toSet.Kind() == reflect.Ptr {
+			toSet.Set(ownerID.Addr())
 		} else {
-			b.ownerID.Set(ownerID)
+			toSet.Set(ownerID)
 		}
 		return nil
 	}
-	return fmt.Errorf("could not set '%s' to '%s'", ownerID, b.ownerID)
+	return fmt.Errorf("could not set '%s' to '%s'", ownerID, toSet)
 }

associations/belongs_to_association_test.go

@@ -22,6 +22,11 @@ type barBelongsTo struct {
 	Foo   fooBelongsTo `belongs_to:"foo"`
 }
 
+type barBelongsToNullable struct {
+	FooID uuid.NullUUID `db:"foo_id"`
+	Foo   *fooBelongsTo `belongs_to:"foo"`
+}
+
 func Test_Belongs_To_Association(t *testing.T) {
 	a := require.New(t)
 
@@ -50,3 +55,17 @@ func Test_Belongs_To_Association(t *testing.T) {
 		a.Equal(nil, before[index].BeforeInterface())
 	}
 }
+
+func Test_Belongs_To_Nullable_Association(t *testing.T) {
+	a := require.New(t)
+	id, _ := uuid.NewV1()
+
+	bar := barBelongsToNullable{Foo: &fooBelongsTo{id}}
+	as, err := associations.ForStruct(&bar, "Foo")
+	a.NoError(err)
+
+	before := as.AssociationsBeforeCreatable()
+	for index := range before {
+		a.Equal(nil, before[index].BeforeSetup())
+	}
+}

columns/columns_for_struct.go

@@ -31,33 +31,47 @@ func ForStructWithAlias(s interface{}, tableName, tableAlias, idField string) (c
 		}
 	}
 
-	fieldCount := st.NumField()
+	// recursive functions to also find and add embedded struct fields
+	var findColumns func(st reflect.Type)
+	findColumns = func(t reflect.Type) {
+		if t.Kind() == reflect.Ptr {
+			t = t.Elem()
+		}
 
-	for i := 0; i < fieldCount; i++ {
-		field := st.Field(i)
+		fc := t.NumField()
+		for i := 0; i < fc; i++ {
+			field := t.Field(i)
 
-		popTags := TagsFor(field)
-		tag := popTags.Find("db")
+			if field.Anonymous {
+				findColumns(field.Type)
+				continue
+			}
 
-		if !tag.Ignored() && !tag.Empty() {
-			col := tag.Value
+			popTags := TagsFor(field)
+			tag := popTags.Find("db")
 
-			// add writable or readable.
-			tag := popTags.Find("rw")
-			if !tag.Empty() {
-				col = col + "," + tag.Value
-			}
+			if !tag.Ignored() && !tag.Empty() {
+				col := tag.Value
 
-			cs := columns.Add(col)
+				// add writable or readable.
+				tag := popTags.Find("rw")
+				if !tag.Empty() {
+					col = col + "," + tag.Value
+				}
 
-			// add select clause.
-			tag = popTags.Find("select")
-			if !tag.Empty() {
-				c := cs[0]
-				c.SetSelectSQL(tag.Value)
+				cs := columns.Add(col)
+
+				// add select clause.
+				tag = popTags.Find("select")
+				if !tag.Empty() {
+					c := cs[0]
+					c.SetSelectSQL(tag.Value)
+				}
 			}
 		}
 	}
 
+	findColumns(st)
+
 	return columns
 }

dialect_cockroach.go

@@ -1,11 +1,13 @@
 package pop
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 
@@ -200,13 +202,42 @@ func (p *cockroach) FizzTranslator() fizz.Translator {
 }
 
 func (p *cockroach) DumpSchema(w io.Writer) error {
-	cmd := exec.Command("cockroach", "dump", p.Details().Database, "--dump-mode=schema")
+	cmd := exec.Command("cockroach", "sql", "-e", "SHOW CREATE ALL TABLES", "-d", p.Details().Database, "--format", "raw")
 
 	c := p.ConnectionDetails
 	if defaults.String(c.Options["sslmode"], "disable") == "disable" || strings.Contains(c.RawOptions, "sslmode=disable") {
 		cmd.Args = append(cmd.Args, "--insecure")
 	}
-	return genericDumpSchema(p.Details(), cmd, w)
+	return cockroachDumpSchema(p.Details(), cmd, w)
+}
+
+func cockroachDumpSchema(deets *ConnectionDetails, cmd *exec.Cmd, w io.Writer) error {
+	log(logging.SQL, strings.Join(cmd.Args, " "))
+
+	var bb bytes.Buffer
+
+	cmd.Stdout = &bb
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	// --format raw returns comments prefixed with # which is invalid, so we make it a valid SQL comment.
+	result := regexp.MustCompile("(?m)^#").ReplaceAll(bb.Bytes(), []byte("-- #"))
+
+	if _, err := w.Write(result); err != nil {
+		return err
+	}
+
+	x := bytes.TrimSpace(result)
+	if len(x) == 0 {
+		return fmt.Errorf("unable to dump schema for %s", deets.Database)
+	}
+
+	log(logging.Info, "dumped schema for %s", deets.Database)
+	return nil
 }
 
 func (p *cockroach) LoadSchema(r io.Reader) error {

dialect_common.go

@@ -85,7 +85,7 @@ func genericCreate(s store, model *Model, cols columns.Columns, quoter quotable)
 		if err != nil {
 			return err
 		}
-		_, err = stmt.Exec(model.Value)
+		_, err = stmt.ExecContext(model.ctx, model.Value)
 		if err != nil {
 			if closeErr := stmt.Close(); closeErr != nil {
 				return fmt.Errorf("failed to close prepared statement: %s: %w", closeErr, err)

dialect_sqlite.go

@@ -169,10 +169,11 @@ func (m *sqlite) CreateDB() error {
 	if err != nil {
 		return fmt.Errorf("could not create SQLite database '%s': %w", m.ConnectionDetails.Database, err)
 	}
-	_, err = os.Create(m.ConnectionDetails.Database)
+	f, err := os.Create(m.ConnectionDetails.Database)
 	if err != nil {
 		return fmt.Errorf("could not create SQLite database '%s': %w", m.ConnectionDetails.Database, err)
 	}
+	_ = f.Close()
 
 	log(logging.Info, "created database '%s'", m.ConnectionDetails.Database)
 	return nil

dialect_sqlite_test.go

@@ -4,8 +4,6 @@ package pop
 
 import (
 	"fmt"
-	"io/ioutil"
-	"os"
 	"path/filepath"
 	"testing"
 
@@ -133,10 +131,8 @@ func Test_ConnectionDetails_Finalize_SQLite_OverrideOptions_Synonym_Path(t *test
 
 func Test_ConnectionDetails_FinalizeOSPath(t *testing.T) {
 	r := require.New(t)
-	d, err := ioutil.TempDir("", "")
-	r.NoError(err)
+	d := t.TempDir()
 	p := filepath.Join(d, "testdb.sqlite")
-	defer os.RemoveAll(p)
 	cd := &ConnectionDetails{
 		Dialect:  "sqlite",
 		Database: p,
@@ -148,10 +144,8 @@ func Test_ConnectionDetails_FinalizeOSPath(t *testing.T) {
 
 func TestSqlite_CreateDB(t *testing.T) {
 	r := require.New(t)
-	dir, err := ioutil.TempDir("", "")
-	r.NoError(err)
+	dir := t.TempDir()
 	p := filepath.Join(dir, "testdb.sqlite")
-	defer os.RemoveAll(p)
 	cd := &ConnectionDetails{
 		Dialect:  "sqlite",
 		Database: p,

executors_test.go

@@ -533,6 +533,33 @@ func Test_Create_Non_PK_ID(t *testing.T) {
 	})
 }
 
+func Test_Embedded_Struct(t *testing.T) {
+	if PDB == nil {
+		t.Skip("skipping integration tests")
+	}
+	transaction(func(tx *Connection) {
+		r := require.New(t)
+
+		entry := &EmbeddingStruct{
+			InnerStruct:     InnerStruct{},
+			AdditionalField: "I am also important!",
+		}
+		r.NoError(tx.Create(entry))
+
+		var actual EmbeddingStruct
+		r.NoError(tx.Find(&actual, entry.ID))
+		r.Equal(entry.AdditionalField, actual.AdditionalField)
+
+		entry.AdditionalField = entry.AdditionalField + " updated"
+		r.NoError(tx.Update(entry))
+
+		r.NoError(tx.Find(&actual, entry.ID))
+		r.Equal(entry.AdditionalField, actual.AdditionalField)
+
+		r.NoError(tx.Destroy(entry))
+	})
+}
+
 func Test_Eager_Create_Has_Many(t *testing.T) {
 	if PDB == nil {
 		t.Skip("skipping integration tests")

finders.go

@@ -282,7 +282,14 @@ func (q *Query) eagerDefaultAssociations(model interface{}) error {
 			v = reflect.Indirect(reflect.ValueOf(model)).FieldByName(inner.Name)
 			innerQuery := Q(query.Connection)
 			innerQuery.eagerFields = inner.Fields
-			err = innerQuery.eagerAssociations(v.Addr().Interface())
+
+			switch v.Kind() {
+			case reflect.Ptr:
+				err = innerQuery.eagerAssociations(v.Interface())
+			default:
+				err = innerQuery.eagerAssociations(v.Addr().Interface())
+			}
+
 			if err != nil {
 				return err
 			}