Support nested struct db aliases in Struct (ref #233)

Author: huandu

README.md

@@ -283,6 +283,34 @@ type ATable struct {
 }
 ```
 
+If a field is itself a struct and has a `db` tag, `Struct` treats that tag as a database alias and expands the nested fields. This is useful for `JOIN` projections built from reusable structs.
+
+```go
+type Post struct {
+    ID   string `db:"id"`
+    Text string `db:"text"`
+}
+
+type Comment struct {
+    Body string `db:"body"`
+}
+
+type PostCommentJoined struct {
+    Post    Post    `db:"post"`
+    Comment Comment `db:"comment"`
+}
+
+joined := sqlbuilder.NewStruct(new(PostCommentJoined))
+sql, _ := joined.SelectFrom("posts post").
+    Join("comments comment", "post.id = comment.post_id").
+    Build()
+
+fmt.Println(sql)
+
+// Output:
+// SELECT post.id, post.text, comment.body FROM posts post JOIN comments comment ON post.id = comment.post_id
+```
+
 For detailed instructions on utilizing `Struct`, refer to the [examples](https://pkg.go.dev/github.com/huandu/go-sqlbuilder#Struct).
 
 Furthermore, `Struct` can be employed as a zero-configuration ORM. Unlike most ORM implementations that necessitate preliminary configurations for database connectivity, `Struct` operates without any configuration, functioning seamlessly with any SQL driver compatible with `database/sql`. `Struct` does not invoke any `database/sql` APIs; it solely generates the appropriate SQL statements with arguments for `DB#Query`/`DB#Exec` or an array of struct field addresses for `Rows#Scan`/`Row#Scan`.

struct.go

@@ -376,8 +376,16 @@ func (s *Struct) updateWithTags(table string, with, without []string, value inte
 	assignments := make([]string, 0, len(tagged.ForWrite))
 
 	for _, sf := range tagged.ForWrite {
-		name := sf.Name
-		val := v.FieldByName(name)
+		val, ok := fieldByIndex(v, sf.Index, false)
+
+		if !ok || !val.IsValid() {
+			if sf.ShouldOmitEmpty(with...) {
+				continue
+			}
+
+			assignments = append(assignments, ub.Assign(sf.Quote(s.Flavor), nil))
+			continue
+		}
 
 		if isEmptyValue(val) {
 			if sf.ShouldOmitEmpty(with...) {
@@ -387,7 +395,10 @@ func (s *Struct) updateWithTags(table string, with, without []string, value inte
 			val = dereferencedFieldValue(val)
 		}
 
-		data := val.Interface()
+		var data interface{}
+		if val.IsValid() {
+			data = val.Interface()
+		}
 		assignments = append(assignments, ub.Assign(sf.Quote(s.Flavor), data))
 	}
 
@@ -471,12 +482,16 @@ func (s *Struct) buildColsAndValuesForTag(ib *InsertBuilder, with, without []str
 
 	for _, sf := range tagged.ForWrite {
 		cols = append(cols, sf.Quote(s.Flavor))
-		name := sf.Name
 		shouldOmitEmpty := sf.ShouldOmitEmpty(with...)
 		nilCnt := 0
 
 		for i, v := range vs {
-			val := v.FieldByName(name)
+			val, ok := fieldByIndex(v, sf.Index, false)
+			if !ok || !val.IsValid() {
+				nilCnt++
+				values[i] = append(values[i], nil)
+				continue
+			}
 
 			if isEmptyValue(val) && shouldOmitEmpty {
 				nilCnt++
@@ -639,8 +654,12 @@ func (s *Struct) addrWithFields(fields []*structField, st interface{}) []interfa
 	addrs := make([]interface{}, 0, len(fields))
 
 	for _, sf := range fields {
-		name := sf.Name
-		data := v.FieldByName(name).Addr().Interface()
+		field, ok := fieldByIndex(v, sf.Index, true)
+		if !ok || !field.IsValid() {
+			return nil
+		}
+
+		data := field.Addr().Interface()
 		addrs = append(addrs, data)
 	}
 
@@ -708,8 +727,13 @@ func (s *Struct) valuesWithTags(with, without []string, value interface{}) (valu
 	values = make([]interface{}, 0, len(tagged.ForWrite))
 
 	for _, sf := range tagged.ForWrite {
-		name := sf.Name
-		data := v.FieldByName(name).Interface()
+		field, ok := fieldByIndex(v, sf.Index, false)
+		if !ok || !field.IsValid() {
+			values = append(values, nil)
+			continue
+		}
+
+		data := field.Interface()
 		values = append(values, data)
 	}
 
@@ -770,15 +794,53 @@ func dereferencedFieldValue(v reflect.Value) reflect.Value {
 			break
 		}
 
+		if v.IsNil() {
+			return reflect.Value{}
+		}
+
 		v = v.Elem()
 	}
 
 	return v
 }
 
+func fieldByIndex(v reflect.Value, index []int, allocate bool) (reflect.Value, bool) {
+	field := v
+
+	for i, idx := range index {
+		for field.Kind() == reflect.Ptr || field.Kind() == reflect.Interface {
+			if field.IsNil() {
+				if !allocate || field.Kind() != reflect.Ptr {
+					return reflect.Value{}, false
+				}
+
+				field.Set(reflect.New(field.Type().Elem()))
+			}
+
+			field = field.Elem()
+		}
+
+		if field.Kind() != reflect.Struct || idx < 0 || idx >= field.NumField() {
+			return reflect.Value{}, false
+		}
+
+		field = field.Field(idx)
+
+		if i == len(index)-1 {
+			return field, true
+		}
+	}
+
+	return field, true
+}
+
 // isEmptyValue checks if v is zero.
 // Following code is borrowed from `IsZero` method in `reflect.Value` since Go 1.13.
 func isEmptyValue(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true
+	}
+
 	switch v.Kind() {
 	case reflect.Bool:
 		return !v.Bool()

struct_test.go

@@ -21,7 +21,28 @@ type structUserForTest struct {
 	unexported struct{}
 }
 
+type structNestedPostForTest struct {
+	ID   string `db:"id" fieldtag:"post"`
+	Text string `db:"text"`
+}
+
+type structNestedCommentForTest struct {
+	ID   string `db:"id" fieldtag:"comment"`
+	Body string `db:"body"`
+}
+
+type structNestedJoinRowForTest struct {
+	Post    structNestedPostForTest     `db:"post"`
+	Comment *structNestedCommentForTest `db:"comment"`
+	Rank    int                         `db:"rank" fieldtag:"meta"`
+}
+
+type structTimeValueForTest struct {
+	CreatedAt time.Time `db:"created_at"`
+}
+
 var userForTest = NewStruct(new(structUserForTest))
+var nestedJoinRowForTest = NewStruct(new(structNestedJoinRowForTest))
 var _ = new(structUserForTest).unexported // disable lint warning
 
 func TestStructSelectFrom(t *testing.T) {
@@ -260,6 +281,75 @@ func TestStructColumns(t *testing.T) {
 	a.Equal(userForTest.ColumnsForTag("invalid"), nil)
 }
 
+func TestStructNestedAliasSelectAndColumns(t *testing.T) {
+	a := assert.New(t)
+	sql, args := nestedJoinRowForTest.SelectFrom("posts post").
+		Join("comments comment", "post.id = comment.post_id").
+		Build()
+
+	a.Equal(sql, "SELECT post.id, post.text, comment.id, comment.body, post.rank FROM posts post JOIN comments comment ON post.id = comment.post_id")
+	a.Equal(args, nil)
+	a.Equal(nestedJoinRowForTest.Columns(), []string{"post.id", "post.text", "comment.id", "comment.body", "rank"})
+	a.Equal(nestedJoinRowForTest.WithTag("post", "meta").Columns(), []string{"rank", "post.id"})
+}
+
+func TestStructNestedAliasAddrValuesAndWrites(t *testing.T) {
+	a := assert.New(t)
+	row := &structNestedJoinRowForTest{
+		Post: structNestedPostForTest{
+			ID:   "post-1",
+			Text: "hello",
+		},
+		Comment: &structNestedCommentForTest{
+			ID:   "comment-1",
+			Body: "world",
+		},
+		Rank: 7,
+	}
+
+	a.Equal(nestedJoinRowForTest.Values(row), []interface{}{"post-1", "hello", "comment-1", "world", 7})
+
+	updateSQL, updateArgs := nestedJoinRowForTest.Update("joined", row).Build()
+	a.Equal(updateSQL, "UPDATE joined SET post.id = ?, post.text = ?, comment.id = ?, comment.body = ?, rank = ?")
+	a.Equal(updateArgs, []interface{}{"post-1", "hello", "comment-1", "world", 7})
+
+	insertSQL, insertArgs := nestedJoinRowForTest.InsertInto("joined", row).Build()
+	a.Equal(insertSQL, "INSERT INTO joined (post.id, post.text, comment.id, comment.body, rank) VALUES (?, ?, ?, ?, ?)")
+	a.Equal(insertArgs, []interface{}{"post-1", "hello", "comment-1", "world", 7})
+
+	var scanned structNestedJoinRowForTest
+	_, _ = fmt.Sscan("post-2 newer comment-2 scanned 9", nestedJoinRowForTest.Addr(&scanned)...)
+	a.Equal(scanned.Post.ID, "post-2")
+	a.Equal(scanned.Post.Text, "newer")
+	a.Assert(scanned.Comment != nil)
+	a.Equal(scanned.Comment.ID, "comment-2")
+	a.Equal(scanned.Comment.Body, "scanned")
+	a.Equal(scanned.Rank, 9)
+
+	var reordered structNestedJoinRowForTest
+	_, _ = fmt.Sscan("comment-3 11 post-3 reverse", nestedJoinRowForTest.AddrWithCols([]string{"comment.id", "rank", "post.id", "comment.body"}, &reordered)...)
+	a.Assert(reordered.Comment != nil)
+	a.Equal(reordered.Comment.ID, "comment-3")
+	a.Equal(reordered.Rank, 11)
+	a.Equal(reordered.Post.ID, "post-3")
+	a.Equal(reordered.Comment.Body, "reverse")
+
+	withNilComment := &structNestedJoinRowForTest{
+		Post: structNestedPostForTest{ID: "post-4", Text: "nil"},
+		Rank: 13,
+	}
+	a.Equal(nestedJoinRowForTest.Values(withNilComment), []interface{}{"post-4", "nil", nil, nil, 13})
+}
+
+func TestStructTaggedTimeFieldRemainsScalar(t *testing.T) {
+	a := assert.New(t)
+	st := NewStruct(new(structTimeValueForTest))
+	a.Equal(st.Columns(), []string{"created_at"})
+
+	sql, _ := st.SelectFrom("events e").Build()
+	a.Equal(sql, "SELECT e.created_at FROM events e")
+}
+
 func TestWithAndWithoutTags(t *testing.T) {
 	type Tags struct {
 		A int `db:"a" fieldtag:"tag1"`
@@ -418,6 +508,33 @@ func ExampleStruct_buildJOIN() {
 	// [Huan%]
 }
 
+func ExampleStruct_buildJOINWithNestedStructAlias() {
+	type Post struct {
+		ID   string `db:"id"`
+		Text string `db:"text"`
+	}
+
+	type Comment struct {
+		Body string `db:"body"`
+	}
+
+	type PostCommentJoined struct {
+		Post    Post    `db:"post"`
+		Comment Comment `db:"comment"`
+	}
+
+	joined := NewStruct(new(PostCommentJoined))
+	sb := joined.SelectFrom("posts post").Join("comments comment", "post.id = comment.post_id")
+	sql, args := sb.Build()
+
+	fmt.Println(sql)
+	fmt.Println(args)
+
+	// Output:
+	// SELECT post.id, post.text, comment.body FROM posts post JOIN comments comment ON post.id = comment.post_id
+	// []
+}
+
 var orderDB testDB = 1
 
 func ExampleStruct_WithTag() {