Revert "Revert "Merge pull request #4 from nelsam/foreign_keys""

This reverts commit fc3ce5a.  Decided foreign key support shouldn't be in master just yet.  Should still be in foreign_keys branch.

db_map.go

@@ -1,7 +1,7 @@
 package gorp_queries
 
 import (
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 	"github.com/nelsam/gorp_queries/interfaces"
 	"github.com/nelsam/gorp_queries/query_plans"
 )
@@ -11,7 +11,7 @@ type SqlExecutor interface {
 	Query(interface{}) interfaces.Query
 }
 
-// DbMap embeds "github.com/coopernurse/gorp".DbMap and adds query
+// DbMap embeds "github.com/nelsam/gorp".DbMap and adds query
 // methods to it.
 type DbMap struct {
 	gorp.DbMap
@@ -55,7 +55,7 @@ func (m *DbMap) Query(target interface{}) interfaces.Query {
 	return query_plans.Query(gorpMap, gorpMap, target)
 }
 
-// Begin acts just like "github.com/coopernurse/gorp".DbMap.Begin,
+// Begin acts just like "github.com/nelsam/gorp".DbMap.Begin,
 // except that its return type is gorp_queries.Transaction.
 func (m *DbMap) Begin() (*Transaction, error) {
 	t, err := m.DbMap.Begin()
@@ -65,7 +65,7 @@ func (m *DbMap) Begin() (*Transaction, error) {
 	return &Transaction{Transaction: *t, dbmap: m}, nil
 }
 
-// Transaction embeds "github.com/coopernurse/gorp".Transaction and
+// Transaction embeds "github.com/nelsam/gorp".Transaction and
 // adds query methods to it.
 type Transaction struct {
 	gorp.Transaction
@@ -75,5 +75,6 @@ type Transaction struct {
 // Query runs a query within a transaction.  See DbMap.Query for full
 // documentation.
 func (t *Transaction) Query(target interface{}) interfaces.Query {
-	return query_plans.Query(&t.dbmap.DbMap, &t.Transaction, target)
+	gorpMap := &t.dbmap.DbMap
+	return query_plans.Query(gorpMap, &t.Transaction, target)
 }

db_map_test.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/nelsam/gorp_queries/interfaces"
 	"github.com/nelsam/gorp_queries/query_plans"

dialects/mysql.go

@@ -2,7 +2,7 @@ package dialects
 
 import (
 	"fmt"
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 )
 
 type MySQLDialect struct {

dialects/sqlite.go

@@ -2,7 +2,7 @@ package dialects
 
 import (
 	"fmt"
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 )
 
 type SqliteDialect struct {

extensions/postgres_query_plans.go

@@ -1,12 +1,46 @@
 package extensions
 
 import (
-	"github.com/coopernurse/gorp"
-	"github.com/nelsam/gorp_queries/query_plans"
-	"github.com/nelsam/gorp_queries/interfaces"
+	"bytes"
+
+	"github.com/nelsam/gorp"
 	"github.com/nelsam/gorp_queries/filters"
+	"github.com/nelsam/gorp_queries/interfaces"
+	"github.com/nelsam/gorp_queries/query_plans"
 )
 
+type pgJsonSelectWrapper struct {
+	actualValue interface{}
+	subElements []string
+}
+
+func (wrapper pgJsonSelectWrapper) ActualValue() interface{} {
+	return wrapper.actualValue
+}
+
+func (wrapper pgJsonSelectWrapper) WrapSql(sqlValue string) string {
+	buf := bytes.Buffer{}
+	buf.WriteString(sqlValue)
+	for idx, elem := range wrapper.subElements {
+		isLast := idx == len(wrapper.subElements)-1
+		buf.WriteString("::json->")
+		if isLast {
+			buf.WriteString(">")
+		}
+		buf.WriteString("'")
+		buf.WriteString(elem)
+		buf.WriteString("'")
+	}
+	return buf.String()
+}
+
+func PgJsonField(actualValue interface{}, subElements ...string) filters.SqlWrapper {
+	return pgJsonSelectWrapper{
+		actualValue: actualValue,
+		subElements: subElements,
+	}
+}
+
 type PostgresAssigner interface {
 	Assign(fieldPtr interface{}, value interface{}) PostgresAssignQuery
 }

filters/filters.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 	"reflect"
 
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 )
 
 type SqlWrapper interface {

foreign_keys/foreign_key_converter.go

@@ -0,0 +1,70 @@
+package foreign_keys
+
+import (
+	"reflect"
+
+	"github.com/nelsam/gorp"
+)
+
+// ForeignKeyConverter is a gorp.TypeConverter that converts
+// foreign keys.
+type ForeignKeyConverter struct {
+	SubConverter gorp.TypeConverter
+}
+
+// ToDb will attempt to typecast the passed in value to Keyer and
+// return the value's key.
+func (converter ForeignKeyConverter) ToDb(parent, value interface{}) (dbValue interface{}, err error) {
+	if converter.SubConverter != nil {
+		defer func() {
+			if err == nil {
+				dbValue, err = converter.SubConverter.ToDb(dbValue)
+			}
+		}()
+	}
+	// Use reflect to check if value is nil.  This works around
+	// situations where value's type is not nil, but its value is.
+	refValue := reflect.ValueOf(value)
+	if (refValue.Kind() == reflect.Ptr || refValue.Kind() == reflect.Interface) && refValue.IsNil() {
+		return nil, nil
+	}
+	if keyer, ok := value.(Keyer); ok {
+		return keyer.Key(), nil
+	}
+	return value, nil
+}
+
+// FromDb takes a pointer to a field within a struct.  If the field's
+// Kind is reflect.Interface and its value is nil, FromDb will attempt
+// to initialize it using the registered foreign key relationships.
+func (converter ForeignKeyConverter) FromDb(parent, target interface{}) (scanner gorp.CustomScanner, convert bool) {
+	if converter.SubConverter != nil {
+		defer func() {
+			if convert == false {
+				scanner, convert = converter.SubConverter.FromDb(target)
+			}
+		}()
+	}
+
+	targetVal := reflect.ValueOf(target).Elem()
+	if targetVal.Kind() == reflect.Interface && targetVal.IsNil() {
+		if init, err := Lookup(parent, target); err == nil {
+			targetVal.Set(reflect.ValueOf(init))
+			convert = true
+
+			scanner.Target = init
+			holderPtrVal := reflect.New(reflect.TypeOf(init.Key()))
+			scanner.Holder = holderPtrVal.Interface()
+			scanner.Binder = func(interface{}, interface{}) error {
+				if holderPtrVal.IsNil() {
+					targetVal.Set(reflect.ValueOf(nil))
+					return nil
+				}
+				holderVal := holderPtrVal.Elem()
+				return init.SetKey(holderVal.Interface())
+			}
+		}
+	}
+
+	return
+}

foreign_keys/foreign_keys.go

@@ -58,7 +58,7 @@ func Register(parent, fieldPtrOrName interface{}, fkey Keyer) (registerErr error
 func namesFor(parent, fieldPtrOrName interface{}) (parentPath, fieldName string, err error) {
 	parentVal := reflect.ValueOf(parent)
 	parentType := parentVal.Type()
-	for parentType.Kind() == reflect.Ptr {
+	if parentType.Kind() == reflect.Ptr {
 		parentType = parentType.Elem()
 		if parentVal.IsNil() {
 			parentVal.Set(reflect.New(parentType))
@@ -77,12 +77,14 @@ func namesFor(parent, fieldPtrOrName interface{}) (parentPath, fieldName string,
 		field := parentVal.Field(i)
 		fieldType := parentType.Field(i)
 		if fieldType.Anonymous {
-			if _, fieldName, err = namesFor(field.Interface(), fieldPtrOrName); err == nil {
+			if _, fieldName, err = namesFor(field.Addr().Interface(), fieldPtrOrName); err == nil {
+				return
+			}
+		} else {
+			if fieldType.PkgPath == "" && field.Addr().Interface() == fieldPtrOrName {
+				fieldName = fieldType.Name
 				return
 			}
-		} else if field.Addr().Interface() == fieldPtrOrName {
-			fieldName = fieldType.Name
-			return
 		}
 	}
 	return "", "", errors.New("The requested field pointer was not found on the parent value")

query_plans/extensions.go

@@ -1,7 +1,7 @@
 package query_plans
 
 import (
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 	"errors"
 )
 

query_plans/query_plans.go

@@ -6,7 +6,7 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 	"github.com/nelsam/gorp_queries/dialects"
 	"github.com/nelsam/gorp_queries/filters"
 	"github.com/nelsam/gorp_queries/interfaces"
@@ -175,12 +175,22 @@ func (plan *QueryPlan) mapTable(targetVal reflect.Value) (*gorp.TableMap, error)
 // passing the address of a field that has been overridden is
 // difficult to do accidentally.
 func (plan *QueryPlan) mapColumns(table *gorp.TableMap, value reflect.Value) (err error) {
+	queryableFields, err := plan.mapColumnsCount(table, value)
+	if err != nil {
+		return err
+	}
+	if queryableFields == 0 {
+		return errors.New("No fields in the target struct are mappable.")
+	}
+	return nil
+}
+
+func (plan *QueryPlan) mapColumnsCount(table *gorp.TableMap, value reflect.Value) (queryableFields int, err error) {
 	value = value.Elem()
 	valueType := value.Type()
 	if plan.colMap == nil {
 		plan.colMap = make(structColumnMap, 0, value.NumField())
 	}
-	queryableFields := 0
 	quotedTableName := plan.dbMap.Dialect.QuotedTableForQuery(table.SchemaName, table.TableName)
 	for i := 0; i < value.NumField(); i++ {
 		fieldType := valueType.Field(i)
@@ -189,7 +199,7 @@ func (plan *QueryPlan) mapColumns(table *gorp.TableMap, value reflect.Value) (er
 			if fieldVal.Kind() != reflect.Ptr {
 				fieldVal = fieldVal.Addr()
 			}
-			plan.mapColumns(table, fieldVal)
+			queryableFields, err = plan.mapColumnsCount(table, fieldVal)
 		} else if fieldType.PkgPath == "" {
 			col := table.ColMap(fieldType.Name)
 			quotedCol := plan.dbMap.Dialect.QuoteField(col.ColumnName)
@@ -205,9 +215,6 @@ func (plan *QueryPlan) mapColumns(table *gorp.TableMap, value reflect.Value) (er
 			}
 		}
 	}
-	if queryableFields == 0 {
-		return errors.New("No fields in the target struct are mappable.")
-	}
 	return
 }
 

query_plans/query_plans_test.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/coopernurse/gorp"
+	"github.com/nelsam/gorp"
 	_ "github.com/go-sql-driver/mysql"
 	_ "github.com/lib/pq"
 	_ "github.com/mattn/go-sqlite3"
@@ -35,6 +35,11 @@ type ValidStruct struct {
 	ExportedValue          string
 }
 
+type ValidStructWithNoUniqueDbFields struct {
+	ValidStruct
+	AnotherTransientValue string `db:"-"`
+}
+
 type Invoice struct {
 	Id       int64
 	Created  int64
@@ -112,6 +117,7 @@ type DbTestSuite struct {
 func (suite *DbTestSuite) SetupSuite() {
 	suite.Map.AddTable(InvalidStruct{})
 	suite.Map.AddTable(ValidStruct{})
+	suite.Map.AddTable(ValidStructWithNoUniqueDbFields{})
 	suite.Map.AddTable(OverriddenInvoice{}).SetKeys(false, "Id")
 	if err := suite.Map.CreateTablesIfNotExists(); !suite.NoError(err) {
 		suite.T().FailNow()
@@ -245,6 +251,12 @@ func (suite *QueryPlanTestSuite) TestQueryPlan_NonFieldPtr() {
 		"Assign(fieldPtr, value) should generate errors if fieldPtr is not a pointer to a field in ref")
 }
 
+func (suite *QueryPlanTestSuite) TestQueryPlan_AllDbFieldsEmbedded() {
+	q := suite.getQueryPlanFor(ValidStructWithNoUniqueDbFields{})
+	suite.Equal(0, len(q.Errors),
+		"Query(ref) should not generate errors if ref only has db fields in an embedded struct")
+}
+
 type QueryLanguageTestSuite struct {
 	DbTestSuite
 	Ref *OverriddenInvoice

targeted_wrappers.go

@@ -0,0 +1 @@
+package gorp_queries