github.com/gogf/gf@v1.16.9/database/gdb/gdb_z_mysql_association_scanlist_test.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gdb_test
     8  
     9  import (
    10  	"context"
    11  	"fmt"
    12  	"testing"
    13  
    14  	"github.com/gogf/gf/database/gdb"
    15  	"github.com/gogf/gf/frame/g"
    16  	"github.com/gogf/gf/util/gconv"
    17  
    18  	"github.com/gogf/gf/os/gtime"
    19  	"github.com/gogf/gf/test/gtest"
    20  )
    21  
    22  func Test_Table_Relation_One(t *testing.T) {
    23  	var (
    24  		tableUser       = "user_" + gtime.TimestampMicroStr()
    25  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
    26  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
    27  	)
    28  	if _, err := db.Exec(fmt.Sprintf(`
    29  CREATE TABLE %s (
    30    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
    31    name varchar(45) NOT NULL,
    32    PRIMARY KEY (uid)
    33  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    34      `, tableUser)); err != nil {
    35  		gtest.Error(err)
    36  	}
    37  	defer dropTable(tableUser)
    38  
    39  	if _, err := db.Exec(fmt.Sprintf(`
    40  CREATE TABLE %s (
    41    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
    42    address varchar(45) NOT NULL,
    43    PRIMARY KEY (uid)
    44  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    45      `, tableUserDetail)); err != nil {
    46  		gtest.Error(err)
    47  	}
    48  	defer dropTable(tableUserDetail)
    49  
    50  	if _, err := db.Exec(fmt.Sprintf(`
    51  CREATE TABLE %s (
    52    id int(10) unsigned NOT NULL AUTO_INCREMENT,
    53    uid int(10) unsigned NOT NULL,
    54    score int(10) unsigned NOT NULL,
    55    course varchar(45) NOT NULL,
    56    PRIMARY KEY (id)
    57  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    58      `, tableUserScores)); err != nil {
    59  		gtest.Error(err)
    60  	}
    61  	defer dropTable(tableUserScores)
    62  
    63  	type EntityUser struct {
    64  		Uid  int    `orm:"uid"`
    65  		Name string `orm:"name"`
    66  	}
    67  
    68  	type EntityUserDetail struct {
    69  		Uid     int    `orm:"uid"`
    70  		Address string `orm:"address"`
    71  	}
    72  
    73  	type EntityUserScores struct {
    74  		Id     int    `orm:"id"`
    75  		Uid    int    `orm:"uid"`
    76  		Score  int    `orm:"score"`
    77  		Course string `orm:"course"`
    78  	}
    79  
    80  	type Entity struct {
    81  		User       *EntityUser
    82  		UserDetail *EntityUserDetail
    83  		UserScores []*EntityUserScores
    84  	}
    85  
    86  	// Initialize the data.
    87  	var err error
    88  	gtest.C(t, func(t *gtest.T) {
    89  		err = db.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
    90  			r, err := tx.Model(tableUser).Save(EntityUser{
    91  				Name: "john",
    92  			})
    93  			if err != nil {
    94  				return err
    95  			}
    96  			uid, err := r.LastInsertId()
    97  			if err != nil {
    98  				return err
    99  			}
   100  			_, err = tx.Model(tableUserDetail).Save(EntityUserDetail{
   101  				Uid:     int(uid),
   102  				Address: "Beijing DongZhiMen #66",
   103  			})
   104  			if err != nil {
   105  				return err
   106  			}
   107  			_, err = tx.Model(tableUserScores).Save(g.Slice{
   108  				EntityUserScores{Uid: int(uid), Score: 100, Course: "math"},
   109  				EntityUserScores{Uid: int(uid), Score: 99, Course: "physics"},
   110  			})
   111  			return err
   112  		})
   113  		t.AssertNil(err)
   114  	})
   115  	// Data check.
   116  	gtest.C(t, func(t *gtest.T) {
   117  		r, err := db.Model(tableUser).All()
   118  		t.AssertNil(err)
   119  		t.Assert(r.Len(), 1)
   120  		t.Assert(r[0]["uid"].Int(), 1)
   121  		t.Assert(r[0]["name"].String(), "john")
   122  
   123  		r, err = db.Model(tableUserDetail).Where("uid", r[0]["uid"].Int()).All()
   124  		t.AssertNil(err)
   125  		t.Assert(r.Len(), 1)
   126  		t.Assert(r[0]["uid"].Int(), 1)
   127  		t.Assert(r[0]["address"].String(), `Beijing DongZhiMen #66`)
   128  
   129  		r, err = db.Model(tableUserScores).Where("uid", r[0]["uid"].Int()).All()
   130  		t.AssertNil(err)
   131  		t.Assert(r.Len(), 2)
   132  		t.Assert(r[0]["uid"].Int(), 1)
   133  		t.Assert(r[1]["uid"].Int(), 1)
   134  		t.Assert(r[0]["course"].String(), `math`)
   135  		t.Assert(r[1]["course"].String(), `physics`)
   136  	})
   137  	// Entity query.
   138  	gtest.C(t, func(t *gtest.T) {
   139  		var user Entity
   140  		// SELECT * FROM `user` WHERE `name`='john'
   141  		err := db.Model(tableUser).Scan(&user.User, "name", "john")
   142  		t.AssertNil(err)
   143  
   144  		// SELECT * FROM `user_detail` WHERE `uid`=1
   145  		err = db.Model(tableUserDetail).Scan(&user.UserDetail, "uid", user.User.Uid)
   146  		t.AssertNil(err)
   147  
   148  		// SELECT * FROM `user_scores` WHERE `uid`=1
   149  		err = db.Model(tableUserScores).Scan(&user.UserScores, "uid", user.User.Uid)
   150  		t.AssertNil(err)
   151  
   152  		t.Assert(user.User, EntityUser{
   153  			Uid:  1,
   154  			Name: "john",
   155  		})
   156  		t.Assert(user.UserDetail, EntityUserDetail{
   157  			Uid:     1,
   158  			Address: "Beijing DongZhiMen #66",
   159  		})
   160  		t.Assert(user.UserScores, []EntityUserScores{
   161  			{Id: 1, Uid: 1, Course: "math", Score: 100},
   162  			{Id: 2, Uid: 1, Course: "physics", Score: 99},
   163  		})
   164  	})
   165  }
   166  
   167  func Test_Table_Relation_Many(t *testing.T) {
   168  	var (
   169  		tableUser       = "user_" + gtime.TimestampMicroStr()
   170  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
   171  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
   172  	)
   173  	if _, err := db.Exec(fmt.Sprintf(`
   174  CREATE TABLE %s (
   175    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   176    name varchar(45) NOT NULL,
   177    PRIMARY KEY (uid)
   178  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   179      `, tableUser)); err != nil {
   180  		gtest.Error(err)
   181  	}
   182  	defer dropTable(tableUser)
   183  
   184  	if _, err := db.Exec(fmt.Sprintf(`
   185  CREATE TABLE %s (
   186    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   187    address varchar(45) NOT NULL,
   188    PRIMARY KEY (uid)
   189  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   190      `, tableUserDetail)); err != nil {
   191  		gtest.Error(err)
   192  	}
   193  	defer dropTable(tableUserDetail)
   194  
   195  	if _, err := db.Exec(fmt.Sprintf(`
   196  CREATE TABLE %s (
   197    id int(10) unsigned NOT NULL AUTO_INCREMENT,
   198    uid int(10) unsigned NOT NULL,
   199    score int(10) unsigned NOT NULL,
   200    PRIMARY KEY (id)
   201  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   202      `, tableUserScores)); err != nil {
   203  		gtest.Error(err)
   204  	}
   205  	defer dropTable(tableUserScores)
   206  
   207  	type EntityUser struct {
   208  		Uid  int    `json:"uid"`
   209  		Name string `json:"name"`
   210  	}
   211  	type EntityUserDetail struct {
   212  		Uid     int    `json:"uid"`
   213  		Address string `json:"address"`
   214  	}
   215  	type EntityUserScores struct {
   216  		Id    int `json:"id"`
   217  		Uid   int `json:"uid"`
   218  		Score int `json:"score"`
   219  	}
   220  	type Entity struct {
   221  		User       *EntityUser
   222  		UserDetail *EntityUserDetail
   223  		UserScores []*EntityUserScores
   224  	}
   225  
   226  	// Initialize the data.
   227  	gtest.C(t, func(t *gtest.T) {
   228  		var err error
   229  		for i := 1; i <= 5; i++ {
   230  			// User.
   231  			_, err = db.Insert(tableUser, g.Map{
   232  				"uid":  i,
   233  				"name": fmt.Sprintf(`name_%d`, i),
   234  			})
   235  			t.AssertNil(err)
   236  			// Detail.
   237  			_, err = db.Insert(tableUserDetail, g.Map{
   238  				"uid":     i,
   239  				"address": fmt.Sprintf(`address_%d`, i),
   240  			})
   241  			t.AssertNil(err)
   242  			// Scores.
   243  			for j := 1; j <= 5; j++ {
   244  				_, err = db.Insert(tableUserScores, g.Map{
   245  					"uid":   i,
   246  					"score": j,
   247  				})
   248  				t.AssertNil(err)
   249  			}
   250  		}
   251  	})
   252  
   253  	// MapKeyValue.
   254  	gtest.C(t, func(t *gtest.T) {
   255  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   256  		t.AssertNil(err)
   257  		t.Assert(all.Len(), 2)
   258  		t.Assert(len(all.MapKeyValue("uid")), 2)
   259  		t.Assert(all.MapKeyValue("uid")["3"].Map()["uid"], 3)
   260  		t.Assert(all.MapKeyValue("uid")["4"].Map()["uid"], 4)
   261  		all, err = db.Model(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All()
   262  		t.AssertNil(err)
   263  		t.Assert(all.Len(), 10)
   264  		t.Assert(len(all.MapKeyValue("uid")), 2)
   265  		t.Assert(len(all.MapKeyValue("uid")["3"].Slice()), 5)
   266  		t.Assert(len(all.MapKeyValue("uid")["4"].Slice()), 5)
   267  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[0])["uid"], 3)
   268  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[0])["score"], 1)
   269  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[4])["uid"], 3)
   270  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[4])["score"], 5)
   271  	})
   272  	// Result ScanList with struct elements and pointer attributes.
   273  	gtest.C(t, func(t *gtest.T) {
   274  		var users []Entity
   275  		// User
   276  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   277  		t.AssertNil(err)
   278  		err = all.ScanList(&users, "User")
   279  		t.AssertNil(err)
   280  		t.Assert(len(users), 2)
   281  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   282  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   283  		// Detail
   284  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   285  		t.AssertNil(err)
   286  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
   287  		t.AssertNil(err)
   288  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   289  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   290  		// Scores
   291  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   292  		t.AssertNil(err)
   293  		err = all.ScanList(&users, "UserScores", "User", "uid:Uid")
   294  		t.AssertNil(err)
   295  		t.Assert(len(users[0].UserScores), 5)
   296  		t.Assert(len(users[1].UserScores), 5)
   297  		t.Assert(users[0].UserScores[0].Uid, 3)
   298  		t.Assert(users[0].UserScores[0].Score, 1)
   299  		t.Assert(users[0].UserScores[4].Score, 5)
   300  		t.Assert(users[1].UserScores[0].Uid, 4)
   301  		t.Assert(users[1].UserScores[0].Score, 1)
   302  		t.Assert(users[1].UserScores[4].Score, 5)
   303  	})
   304  
   305  	// Result ScanList with pointer elements and pointer attributes.
   306  	gtest.C(t, func(t *gtest.T) {
   307  		var users []*Entity
   308  		// User
   309  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   310  		t.AssertNil(err)
   311  		err = all.ScanList(&users, "User")
   312  		t.AssertNil(err)
   313  		t.Assert(len(users), 2)
   314  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   315  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   316  		// Detail
   317  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   318  		t.AssertNil(err)
   319  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
   320  		t.AssertNil(err)
   321  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   322  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   323  		// Scores
   324  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   325  		t.AssertNil(err)
   326  		err = all.ScanList(&users, "UserScores", "User", "uid:Uid")
   327  		t.AssertNil(err)
   328  		t.Assert(len(users[0].UserScores), 5)
   329  		t.Assert(len(users[1].UserScores), 5)
   330  		t.Assert(users[0].UserScores[0].Uid, 3)
   331  		t.Assert(users[0].UserScores[0].Score, 1)
   332  		t.Assert(users[0].UserScores[4].Score, 5)
   333  		t.Assert(users[1].UserScores[0].Uid, 4)
   334  		t.Assert(users[1].UserScores[0].Score, 1)
   335  		t.Assert(users[1].UserScores[4].Score, 5)
   336  	})
   337  
   338  	// Result ScanList with struct elements and struct attributes.
   339  	gtest.C(t, func(t *gtest.T) {
   340  		type EntityUser struct {
   341  			Uid  int    `json:"uid"`
   342  			Name string `json:"name"`
   343  		}
   344  		type EntityUserDetail struct {
   345  			Uid     int    `json:"uid"`
   346  			Address string `json:"address"`
   347  		}
   348  		type EntityUserScores struct {
   349  			Id    int `json:"id"`
   350  			Uid   int `json:"uid"`
   351  			Score int `json:"score"`
   352  		}
   353  		type Entity struct {
   354  			User       EntityUser
   355  			UserDetail EntityUserDetail
   356  			UserScores []EntityUserScores
   357  		}
   358  		var users []Entity
   359  		// User
   360  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   361  		t.AssertNil(err)
   362  		err = all.ScanList(&users, "User")
   363  		t.AssertNil(err)
   364  		t.Assert(len(users), 2)
   365  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   366  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   367  		// Detail
   368  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   369  		t.AssertNil(err)
   370  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
   371  		t.AssertNil(err)
   372  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   373  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   374  		// Scores
   375  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   376  		t.AssertNil(err)
   377  		err = all.ScanList(&users, "UserScores", "User", "uid:Uid")
   378  		t.AssertNil(err)
   379  		t.Assert(len(users[0].UserScores), 5)
   380  		t.Assert(len(users[1].UserScores), 5)
   381  		t.Assert(users[0].UserScores[0].Uid, 3)
   382  		t.Assert(users[0].UserScores[0].Score, 1)
   383  		t.Assert(users[0].UserScores[4].Score, 5)
   384  		t.Assert(users[1].UserScores[0].Uid, 4)
   385  		t.Assert(users[1].UserScores[0].Score, 1)
   386  		t.Assert(users[1].UserScores[4].Score, 5)
   387  	})
   388  
   389  	// Result ScanList with pointer elements and struct attributes.
   390  	gtest.C(t, func(t *gtest.T) {
   391  		type EntityUser struct {
   392  			Uid  int    `json:"uid"`
   393  			Name string `json:"name"`
   394  		}
   395  		type EntityUserDetail struct {
   396  			Uid     int    `json:"uid"`
   397  			Address string `json:"address"`
   398  		}
   399  		type EntityUserScores struct {
   400  			Id    int `json:"id"`
   401  			Uid   int `json:"uid"`
   402  			Score int `json:"score"`
   403  		}
   404  		type Entity struct {
   405  			User       EntityUser
   406  			UserDetail EntityUserDetail
   407  			UserScores []EntityUserScores
   408  		}
   409  		var users []*Entity
   410  
   411  		// User
   412  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   413  		t.AssertNil(err)
   414  		err = all.ScanList(&users, "User")
   415  		t.AssertNil(err)
   416  		t.Assert(len(users), 2)
   417  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   418  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   419  		// Detail
   420  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   421  		t.AssertNil(err)
   422  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
   423  		t.AssertNil(err)
   424  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   425  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   426  		// Scores
   427  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   428  		t.AssertNil(err)
   429  		err = all.ScanList(&users, "UserScores", "User", "uid:Uid")
   430  		t.AssertNil(err)
   431  		t.Assert(len(users[0].UserScores), 5)
   432  		t.Assert(len(users[1].UserScores), 5)
   433  		t.Assert(users[0].UserScores[0].Uid, 3)
   434  		t.Assert(users[0].UserScores[0].Score, 1)
   435  		t.Assert(users[0].UserScores[4].Score, 5)
   436  		t.Assert(users[1].UserScores[0].Uid, 4)
   437  		t.Assert(users[1].UserScores[0].Score, 1)
   438  		t.Assert(users[1].UserScores[4].Score, 5)
   439  	})
   440  
   441  	// Model ScanList with pointer elements and pointer attributes.
   442  	gtest.C(t, func(t *gtest.T) {
   443  		var users []*Entity
   444  		// User
   445  		err := db.Model(tableUser).
   446  			Where("uid", g.Slice{3, 4}).
   447  			Order("uid asc").
   448  			ScanList(&users, "User")
   449  		t.AssertNil(err)
   450  		// Detail
   451  		err = db.Model(tableUserDetail).
   452  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
   453  			Order("uid asc").
   454  			ScanList(&users, "UserDetail", "User", "uid:Uid")
   455  		t.AssertNil(err)
   456  		// Scores
   457  		err = db.Model(tableUserScores).
   458  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
   459  			Order("id asc").
   460  			ScanList(&users, "UserScores", "User", "uid:Uid")
   461  		t.AssertNil(err)
   462  
   463  		t.Assert(len(users), 2)
   464  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   465  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   466  
   467  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   468  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   469  
   470  		t.Assert(len(users[0].UserScores), 5)
   471  		t.Assert(len(users[1].UserScores), 5)
   472  		t.Assert(users[0].UserScores[0].Uid, 3)
   473  		t.Assert(users[0].UserScores[0].Score, 1)
   474  		t.Assert(users[0].UserScores[4].Score, 5)
   475  		t.Assert(users[1].UserScores[0].Uid, 4)
   476  		t.Assert(users[1].UserScores[0].Score, 1)
   477  		t.Assert(users[1].UserScores[4].Score, 5)
   478  	})
   479  }
   480  
   481  func Test_Table_Relation_Many_RelationKeyCaseInsensitive(t *testing.T) {
   482  	var (
   483  		tableUser       = "user_" + gtime.TimestampMicroStr()
   484  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
   485  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
   486  	)
   487  	if _, err := db.Exec(fmt.Sprintf(`
   488  CREATE TABLE %s (
   489    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   490    name varchar(45) NOT NULL,
   491    PRIMARY KEY (uid)
   492  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   493      `, tableUser)); err != nil {
   494  		gtest.Error(err)
   495  	}
   496  	defer dropTable(tableUser)
   497  
   498  	if _, err := db.Exec(fmt.Sprintf(`
   499  CREATE TABLE %s (
   500    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   501    address varchar(45) NOT NULL,
   502    PRIMARY KEY (uid)
   503  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   504      `, tableUserDetail)); err != nil {
   505  		gtest.Error(err)
   506  	}
   507  	defer dropTable(tableUserDetail)
   508  
   509  	if _, err := db.Exec(fmt.Sprintf(`
   510  CREATE TABLE %s (
   511    id int(10) unsigned NOT NULL AUTO_INCREMENT,
   512    uid int(10) unsigned NOT NULL,
   513    score int(10) unsigned NOT NULL,
   514    PRIMARY KEY (id)
   515  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   516      `, tableUserScores)); err != nil {
   517  		gtest.Error(err)
   518  	}
   519  	defer dropTable(tableUserScores)
   520  
   521  	type EntityUser struct {
   522  		Uid  int    `json:"uid"`
   523  		Name string `json:"name"`
   524  	}
   525  	type EntityUserDetail struct {
   526  		Uid     int    `json:"uid"`
   527  		Address string `json:"address"`
   528  	}
   529  	type EntityUserScores struct {
   530  		Id    int `json:"id"`
   531  		Uid   int `json:"uid"`
   532  		Score int `json:"score"`
   533  	}
   534  	type Entity struct {
   535  		User       *EntityUser
   536  		UserDetail *EntityUserDetail
   537  		UserScores []*EntityUserScores
   538  	}
   539  
   540  	// Initialize the data.
   541  	gtest.C(t, func(t *gtest.T) {
   542  		var err error
   543  		for i := 1; i <= 5; i++ {
   544  			// User.
   545  			_, err = db.Insert(tableUser, g.Map{
   546  				"uid":  i,
   547  				"name": fmt.Sprintf(`name_%d`, i),
   548  			})
   549  			t.AssertNil(err)
   550  			// Detail.
   551  			_, err = db.Insert(tableUserDetail, g.Map{
   552  				"uid":     i,
   553  				"address": fmt.Sprintf(`address_%d`, i),
   554  			})
   555  			t.AssertNil(err)
   556  			// Scores.
   557  			for j := 1; j <= 5; j++ {
   558  				_, err = db.Insert(tableUserScores, g.Map{
   559  					"uid":   i,
   560  					"score": j,
   561  				})
   562  				t.AssertNil(err)
   563  			}
   564  		}
   565  	})
   566  
   567  	// MapKeyValue.
   568  	gtest.C(t, func(t *gtest.T) {
   569  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   570  		t.AssertNil(err)
   571  		t.Assert(all.Len(), 2)
   572  		t.Assert(len(all.MapKeyValue("uid")), 2)
   573  		t.Assert(all.MapKeyValue("uid")["3"].Map()["uid"], 3)
   574  		t.Assert(all.MapKeyValue("uid")["4"].Map()["uid"], 4)
   575  		all, err = db.Model(tableUserScores).Where("uid", g.Slice{3, 4}).Order("id asc").All()
   576  		t.AssertNil(err)
   577  		t.Assert(all.Len(), 10)
   578  		t.Assert(len(all.MapKeyValue("uid")), 2)
   579  		t.Assert(len(all.MapKeyValue("uid")["3"].Slice()), 5)
   580  		t.Assert(len(all.MapKeyValue("uid")["4"].Slice()), 5)
   581  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[0])["uid"], 3)
   582  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[0])["score"], 1)
   583  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[4])["uid"], 3)
   584  		t.Assert(gconv.Map(all.MapKeyValue("uid")["3"].Slice()[4])["score"], 5)
   585  	})
   586  	// Result ScanList with struct elements and pointer attributes.
   587  	gtest.C(t, func(t *gtest.T) {
   588  		var users []Entity
   589  		// User
   590  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   591  		t.AssertNil(err)
   592  		err = all.ScanList(&users, "User")
   593  		t.AssertNil(err)
   594  		t.Assert(len(users), 2)
   595  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   596  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   597  		// Detail
   598  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   599  		t.AssertNil(err)
   600  		err = all.ScanList(&users, "UserDetail", "User", "uid:uid")
   601  		t.AssertNil(err)
   602  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   603  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   604  		// Scores
   605  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   606  		t.AssertNil(err)
   607  		err = all.ScanList(&users, "UserScores", "User", "uid:uid")
   608  		t.AssertNil(err)
   609  		t.Assert(len(users[0].UserScores), 5)
   610  		t.Assert(len(users[1].UserScores), 5)
   611  		t.Assert(users[0].UserScores[0].Uid, 3)
   612  		t.Assert(users[0].UserScores[0].Score, 1)
   613  		t.Assert(users[0].UserScores[4].Score, 5)
   614  		t.Assert(users[1].UserScores[0].Uid, 4)
   615  		t.Assert(users[1].UserScores[0].Score, 1)
   616  		t.Assert(users[1].UserScores[4].Score, 5)
   617  	})
   618  
   619  	// Result ScanList with pointer elements and pointer attributes.
   620  	gtest.C(t, func(t *gtest.T) {
   621  		var users []*Entity
   622  		// User
   623  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   624  		t.AssertNil(err)
   625  		err = all.ScanList(&users, "User")
   626  		t.AssertNil(err)
   627  		t.Assert(len(users), 2)
   628  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   629  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   630  		// Detail
   631  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   632  		t.AssertNil(err)
   633  		err = all.ScanList(&users, "UserDetail", "User", "Uid:UID")
   634  		t.AssertNil(err)
   635  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   636  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   637  		// Scores
   638  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   639  		t.AssertNil(err)
   640  		err = all.ScanList(&users, "UserScores", "User", "Uid:UID")
   641  		t.AssertNil(err)
   642  		t.Assert(len(users[0].UserScores), 5)
   643  		t.Assert(len(users[1].UserScores), 5)
   644  		t.Assert(users[0].UserScores[0].Uid, 3)
   645  		t.Assert(users[0].UserScores[0].Score, 1)
   646  		t.Assert(users[0].UserScores[4].Score, 5)
   647  		t.Assert(users[1].UserScores[0].Uid, 4)
   648  		t.Assert(users[1].UserScores[0].Score, 1)
   649  		t.Assert(users[1].UserScores[4].Score, 5)
   650  	})
   651  
   652  	// Result ScanList with struct elements and struct attributes.
   653  	gtest.C(t, func(t *gtest.T) {
   654  		type EntityUser struct {
   655  			Uid  int    `json:"uid"`
   656  			Name string `json:"name"`
   657  		}
   658  		type EntityUserDetail struct {
   659  			Uid     int    `json:"uid"`
   660  			Address string `json:"address"`
   661  		}
   662  		type EntityUserScores struct {
   663  			Id    int `json:"id"`
   664  			Uid   int `json:"uid"`
   665  			Score int `json:"score"`
   666  		}
   667  		type Entity struct {
   668  			User       EntityUser
   669  			UserDetail EntityUserDetail
   670  			UserScores []EntityUserScores
   671  		}
   672  		var users []Entity
   673  		// User
   674  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   675  		t.AssertNil(err)
   676  		err = all.ScanList(&users, "User")
   677  		t.AssertNil(err)
   678  		t.Assert(len(users), 2)
   679  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   680  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   681  		// Detail
   682  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   683  		t.AssertNil(err)
   684  		err = all.ScanList(&users, "UserDetail", "User", "uid:UId")
   685  		t.AssertNil(err)
   686  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   687  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   688  		// Scores
   689  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   690  		t.AssertNil(err)
   691  		err = all.ScanList(&users, "UserScores", "User", "UId:Uid")
   692  		t.AssertNil(err)
   693  		t.Assert(len(users[0].UserScores), 5)
   694  		t.Assert(len(users[1].UserScores), 5)
   695  		t.Assert(users[0].UserScores[0].Uid, 3)
   696  		t.Assert(users[0].UserScores[0].Score, 1)
   697  		t.Assert(users[0].UserScores[4].Score, 5)
   698  		t.Assert(users[1].UserScores[0].Uid, 4)
   699  		t.Assert(users[1].UserScores[0].Score, 1)
   700  		t.Assert(users[1].UserScores[4].Score, 5)
   701  	})
   702  
   703  	// Result ScanList with pointer elements and struct attributes.
   704  	gtest.C(t, func(t *gtest.T) {
   705  		type EntityUser struct {
   706  			Uid  int    `json:"uid"`
   707  			Name string `json:"name"`
   708  		}
   709  		type EntityUserDetail struct {
   710  			Uid     int    `json:"uid"`
   711  			Address string `json:"address"`
   712  		}
   713  		type EntityUserScores struct {
   714  			Id    int `json:"id"`
   715  			Uid   int `json:"uid"`
   716  			Score int `json:"score"`
   717  		}
   718  		type Entity struct {
   719  			User       EntityUser
   720  			UserDetail EntityUserDetail
   721  			UserScores []EntityUserScores
   722  		}
   723  		var users []*Entity
   724  
   725  		// User
   726  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   727  		t.AssertNil(err)
   728  		err = all.ScanList(&users, "User")
   729  		t.AssertNil(err)
   730  		t.Assert(len(users), 2)
   731  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   732  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   733  		// Detail
   734  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   735  		t.AssertNil(err)
   736  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
   737  		t.AssertNil(err)
   738  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   739  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   740  		// Scores
   741  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   742  		t.AssertNil(err)
   743  		err = all.ScanList(&users, "UserScores", "User", "UID:Uid")
   744  		t.AssertNil(err)
   745  		t.Assert(len(users[0].UserScores), 5)
   746  		t.Assert(len(users[1].UserScores), 5)
   747  		t.Assert(users[0].UserScores[0].Uid, 3)
   748  		t.Assert(users[0].UserScores[0].Score, 1)
   749  		t.Assert(users[0].UserScores[4].Score, 5)
   750  		t.Assert(users[1].UserScores[0].Uid, 4)
   751  		t.Assert(users[1].UserScores[0].Score, 1)
   752  		t.Assert(users[1].UserScores[4].Score, 5)
   753  	})
   754  
   755  	// Model ScanList with pointer elements and pointer attributes.
   756  	gtest.C(t, func(t *gtest.T) {
   757  		var users []*Entity
   758  		// User
   759  		err := db.Model(tableUser).
   760  			Where("uid", g.Slice{3, 4}).
   761  			Order("uid asc").
   762  			ScanList(&users, "User")
   763  		t.AssertNil(err)
   764  		// Detail
   765  		err = db.Model(tableUserDetail).
   766  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
   767  			Order("uid asc").
   768  			ScanList(&users, "UserDetail", "User", "uid:Uid")
   769  		t.AssertNil(err)
   770  		// Scores
   771  		err = db.Model(tableUserScores).
   772  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
   773  			Order("id asc").
   774  			ScanList(&users, "UserScores", "User", "uid:Uid")
   775  		t.AssertNil(err)
   776  
   777  		t.Assert(len(users), 2)
   778  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   779  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   780  
   781  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   782  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   783  
   784  		t.Assert(len(users[0].UserScores), 5)
   785  		t.Assert(len(users[1].UserScores), 5)
   786  		t.Assert(users[0].UserScores[0].Uid, 3)
   787  		t.Assert(users[0].UserScores[0].Score, 1)
   788  		t.Assert(users[0].UserScores[4].Score, 5)
   789  		t.Assert(users[1].UserScores[0].Uid, 4)
   790  		t.Assert(users[1].UserScores[0].Score, 1)
   791  		t.Assert(users[1].UserScores[4].Score, 5)
   792  	})
   793  }
   794  
   795  func Test_Table_Relation_Many_TheSameRelationNames(t *testing.T) {
   796  	var (
   797  		tableUser       = "user_" + gtime.TimestampMicroStr()
   798  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
   799  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
   800  	)
   801  	if _, err := db.Exec(fmt.Sprintf(`
   802  CREATE TABLE %s (
   803    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   804    name varchar(45) NOT NULL,
   805    PRIMARY KEY (uid)
   806  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   807      `, tableUser)); err != nil {
   808  		gtest.Error(err)
   809  	}
   810  	defer dropTable(tableUser)
   811  
   812  	if _, err := db.Exec(fmt.Sprintf(`
   813  CREATE TABLE %s (
   814    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
   815    address varchar(45) NOT NULL,
   816    PRIMARY KEY (uid)
   817  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   818      `, tableUserDetail)); err != nil {
   819  		gtest.Error(err)
   820  	}
   821  	defer dropTable(tableUserDetail)
   822  
   823  	if _, err := db.Exec(fmt.Sprintf(`
   824  CREATE TABLE %s (
   825    id int(10) unsigned NOT NULL AUTO_INCREMENT,
   826    uid int(10) unsigned NOT NULL,
   827    score int(10) unsigned NOT NULL,
   828    PRIMARY KEY (id)
   829  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   830      `, tableUserScores)); err != nil {
   831  		gtest.Error(err)
   832  	}
   833  	defer dropTable(tableUserScores)
   834  
   835  	type EntityUser struct {
   836  		Uid  int    `json:"uid"`
   837  		Name string `json:"name"`
   838  	}
   839  	type EntityUserDetail struct {
   840  		Uid     int    `json:"uid"`
   841  		Address string `json:"address"`
   842  	}
   843  	type EntityUserScores struct {
   844  		Id    int `json:"id"`
   845  		Uid   int `json:"uid"`
   846  		Score int `json:"score"`
   847  	}
   848  	type Entity struct {
   849  		User       *EntityUser
   850  		UserDetail *EntityUserDetail
   851  		UserScores []*EntityUserScores
   852  	}
   853  
   854  	// Initialize the data.
   855  	gtest.C(t, func(t *gtest.T) {
   856  		var err error
   857  		for i := 1; i <= 5; i++ {
   858  			// User.
   859  			_, err = db.Insert(tableUser, g.Map{
   860  				"uid":  i,
   861  				"name": fmt.Sprintf(`name_%d`, i),
   862  			})
   863  			t.AssertNil(err)
   864  			// Detail.
   865  			_, err = db.Insert(tableUserDetail, g.Map{
   866  				"uid":     i,
   867  				"address": fmt.Sprintf(`address_%d`, i),
   868  			})
   869  			t.AssertNil(err)
   870  			// Scores.
   871  			for j := 1; j <= 5; j++ {
   872  				_, err = db.Insert(tableUserScores, g.Map{
   873  					"uid":   i,
   874  					"score": j,
   875  				})
   876  				t.AssertNil(err)
   877  			}
   878  		}
   879  	})
   880  
   881  	// Result ScanList with struct elements and pointer attributes.
   882  	gtest.C(t, func(t *gtest.T) {
   883  		var users []Entity
   884  		// User
   885  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   886  		t.AssertNil(err)
   887  		err = all.ScanList(&users, "User")
   888  		t.AssertNil(err)
   889  		t.Assert(len(users), 2)
   890  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   891  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   892  		// Detail
   893  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   894  		t.AssertNil(err)
   895  		err = all.ScanList(&users, "UserDetail", "User", "uid")
   896  		t.AssertNil(err)
   897  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   898  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   899  		// Scores
   900  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   901  		t.AssertNil(err)
   902  		err = all.ScanList(&users, "UserScores", "User", "uid")
   903  		t.AssertNil(err)
   904  		t.Assert(len(users[0].UserScores), 5)
   905  		t.Assert(len(users[1].UserScores), 5)
   906  		t.Assert(users[0].UserScores[0].Uid, 3)
   907  		t.Assert(users[0].UserScores[0].Score, 1)
   908  		t.Assert(users[0].UserScores[4].Score, 5)
   909  		t.Assert(users[1].UserScores[0].Uid, 4)
   910  		t.Assert(users[1].UserScores[0].Score, 1)
   911  		t.Assert(users[1].UserScores[4].Score, 5)
   912  	})
   913  
   914  	// Result ScanList with pointer elements and pointer attributes.
   915  	gtest.C(t, func(t *gtest.T) {
   916  		var users []*Entity
   917  		// User
   918  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   919  		t.AssertNil(err)
   920  		err = all.ScanList(&users, "User")
   921  		t.AssertNil(err)
   922  		t.Assert(len(users), 2)
   923  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   924  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   925  		// Detail
   926  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   927  		t.AssertNil(err)
   928  		err = all.ScanList(&users, "UserDetail", "User", "Uid")
   929  		t.AssertNil(err)
   930  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   931  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   932  		// Scores
   933  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   934  		t.AssertNil(err)
   935  		err = all.ScanList(&users, "UserScores", "User", "UID")
   936  		t.AssertNil(err)
   937  		t.Assert(len(users[0].UserScores), 5)
   938  		t.Assert(len(users[1].UserScores), 5)
   939  		t.Assert(users[0].UserScores[0].Uid, 3)
   940  		t.Assert(users[0].UserScores[0].Score, 1)
   941  		t.Assert(users[0].UserScores[4].Score, 5)
   942  		t.Assert(users[1].UserScores[0].Uid, 4)
   943  		t.Assert(users[1].UserScores[0].Score, 1)
   944  		t.Assert(users[1].UserScores[4].Score, 5)
   945  	})
   946  
   947  	// Result ScanList with struct elements and struct attributes.
   948  	gtest.C(t, func(t *gtest.T) {
   949  		type EntityUser struct {
   950  			Uid  int    `json:"uid"`
   951  			Name string `json:"name"`
   952  		}
   953  		type EntityUserDetail struct {
   954  			Uid     int    `json:"uid"`
   955  			Address string `json:"address"`
   956  		}
   957  		type EntityUserScores struct {
   958  			Id    int `json:"id"`
   959  			Uid   int `json:"uid"`
   960  			Score int `json:"score"`
   961  		}
   962  		type Entity struct {
   963  			User       EntityUser
   964  			UserDetail EntityUserDetail
   965  			UserScores []EntityUserScores
   966  		}
   967  		var users []Entity
   968  		// User
   969  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
   970  		t.AssertNil(err)
   971  		err = all.ScanList(&users, "User")
   972  		t.AssertNil(err)
   973  		t.Assert(len(users), 2)
   974  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
   975  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
   976  		// Detail
   977  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
   978  		t.AssertNil(err)
   979  		err = all.ScanList(&users, "UserDetail", "User", "UId")
   980  		t.AssertNil(err)
   981  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
   982  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
   983  		// Scores
   984  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
   985  		t.AssertNil(err)
   986  		err = all.ScanList(&users, "UserScores", "User", "Uid")
   987  		t.AssertNil(err)
   988  		t.Assert(len(users[0].UserScores), 5)
   989  		t.Assert(len(users[1].UserScores), 5)
   990  		t.Assert(users[0].UserScores[0].Uid, 3)
   991  		t.Assert(users[0].UserScores[0].Score, 1)
   992  		t.Assert(users[0].UserScores[4].Score, 5)
   993  		t.Assert(users[1].UserScores[0].Uid, 4)
   994  		t.Assert(users[1].UserScores[0].Score, 1)
   995  		t.Assert(users[1].UserScores[4].Score, 5)
   996  	})
   997  
   998  	// Result ScanList with pointer elements and struct attributes.
   999  	gtest.C(t, func(t *gtest.T) {
  1000  		type EntityUser struct {
  1001  			Uid  int    `json:"uid"`
  1002  			Name string `json:"name"`
  1003  		}
  1004  		type EntityUserDetail struct {
  1005  			Uid     int    `json:"uid"`
  1006  			Address string `json:"address"`
  1007  		}
  1008  		type EntityUserScores struct {
  1009  			Id    int `json:"id"`
  1010  			Uid   int `json:"uid"`
  1011  			Score int `json:"score"`
  1012  		}
  1013  		type Entity struct {
  1014  			User       EntityUser
  1015  			UserDetail EntityUserDetail
  1016  			UserScores []EntityUserScores
  1017  		}
  1018  		var users []*Entity
  1019  
  1020  		// User
  1021  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1022  		t.AssertNil(err)
  1023  		err = all.ScanList(&users, "User")
  1024  		t.AssertNil(err)
  1025  		t.Assert(len(users), 2)
  1026  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1027  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1028  		// Detail
  1029  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1030  		t.AssertNil(err)
  1031  		err = all.ScanList(&users, "UserDetail", "User", "uid")
  1032  		t.AssertNil(err)
  1033  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
  1034  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
  1035  		// Scores
  1036  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1037  		t.AssertNil(err)
  1038  		err = all.ScanList(&users, "UserScores", "User", "UID")
  1039  		t.AssertNil(err)
  1040  		t.Assert(len(users[0].UserScores), 5)
  1041  		t.Assert(len(users[1].UserScores), 5)
  1042  		t.Assert(users[0].UserScores[0].Uid, 3)
  1043  		t.Assert(users[0].UserScores[0].Score, 1)
  1044  		t.Assert(users[0].UserScores[4].Score, 5)
  1045  		t.Assert(users[1].UserScores[0].Uid, 4)
  1046  		t.Assert(users[1].UserScores[0].Score, 1)
  1047  		t.Assert(users[1].UserScores[4].Score, 5)
  1048  	})
  1049  
  1050  	// Model ScanList with pointer elements and pointer attributes.
  1051  	gtest.C(t, func(t *gtest.T) {
  1052  		var users []*Entity
  1053  		// User
  1054  		err := db.Model(tableUser).
  1055  			Where("uid", g.Slice{3, 4}).
  1056  			Order("uid asc").
  1057  			ScanList(&users, "User")
  1058  		t.AssertNil(err)
  1059  		// Detail
  1060  		err = db.Model(tableUserDetail).
  1061  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1062  			Order("uid asc").
  1063  			ScanList(&users, "UserDetail", "User", "uid")
  1064  		t.AssertNil(err)
  1065  		// Scores
  1066  		err = db.Model(tableUserScores).
  1067  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1068  			Order("id asc").
  1069  			ScanList(&users, "UserScores", "User", "uid")
  1070  		t.AssertNil(err)
  1071  
  1072  		t.Assert(len(users), 2)
  1073  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1074  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1075  
  1076  		t.Assert(users[0].UserDetail, &EntityUserDetail{3, "address_3"})
  1077  		t.Assert(users[1].UserDetail, &EntityUserDetail{4, "address_4"})
  1078  
  1079  		t.Assert(len(users[0].UserScores), 5)
  1080  		t.Assert(len(users[1].UserScores), 5)
  1081  		t.Assert(users[0].UserScores[0].Uid, 3)
  1082  		t.Assert(users[0].UserScores[0].Score, 1)
  1083  		t.Assert(users[0].UserScores[4].Score, 5)
  1084  		t.Assert(users[1].UserScores[0].Uid, 4)
  1085  		t.Assert(users[1].UserScores[0].Score, 1)
  1086  		t.Assert(users[1].UserScores[4].Score, 5)
  1087  	})
  1088  }
  1089  
  1090  func Test_Table_Relation_EmptyData(t *testing.T) {
  1091  	var (
  1092  		tableUser       = "user_" + gtime.TimestampMicroStr()
  1093  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
  1094  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
  1095  	)
  1096  	if _, err := db.Exec(fmt.Sprintf(`
  1097  CREATE TABLE %s (
  1098    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1099    name varchar(45) NOT NULL,
  1100    PRIMARY KEY (uid)
  1101  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1102      `, tableUser)); err != nil {
  1103  		gtest.Error(err)
  1104  	}
  1105  	defer dropTable(tableUser)
  1106  
  1107  	if _, err := db.Exec(fmt.Sprintf(`
  1108  CREATE TABLE %s (
  1109    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1110    address varchar(45) NOT NULL,
  1111    PRIMARY KEY (uid)
  1112  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1113      `, tableUserDetail)); err != nil {
  1114  		gtest.Error(err)
  1115  	}
  1116  	defer dropTable(tableUserDetail)
  1117  
  1118  	if _, err := db.Exec(fmt.Sprintf(`
  1119  CREATE TABLE %s (
  1120    id int(10) unsigned NOT NULL AUTO_INCREMENT,
  1121    uid int(10) unsigned NOT NULL,
  1122    score int(10) unsigned NOT NULL,
  1123    PRIMARY KEY (id)
  1124  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1125      `, tableUserScores)); err != nil {
  1126  		gtest.Error(err)
  1127  	}
  1128  	defer dropTable(tableUserScores)
  1129  
  1130  	type EntityUser struct {
  1131  		Uid  int    `json:"uid"`
  1132  		Name string `json:"name"`
  1133  	}
  1134  	type EntityUserDetail struct {
  1135  		Uid     int    `json:"uid"`
  1136  		Address string `json:"address"`
  1137  	}
  1138  	type EntityUserScores struct {
  1139  		Id    int `json:"id"`
  1140  		Uid   int `json:"uid"`
  1141  		Score int `json:"score"`
  1142  	}
  1143  	type Entity struct {
  1144  		User       *EntityUser
  1145  		UserDetail *EntityUserDetail
  1146  		UserScores []*EntityUserScores
  1147  	}
  1148  
  1149  	// Result ScanList with struct elements and pointer attributes.
  1150  	gtest.C(t, func(t *gtest.T) {
  1151  		var users []Entity
  1152  		// User
  1153  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1154  		t.AssertNil(err)
  1155  		err = all.ScanList(&users, "User")
  1156  		t.AssertNil(err)
  1157  		t.Assert(len(users), 0)
  1158  		// Detail
  1159  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1160  		t.AssertNil(err)
  1161  		err = all.ScanList(&users, "UserDetail", "User", "uid:uid")
  1162  		t.AssertNil(err)
  1163  
  1164  		// Scores
  1165  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1166  		t.AssertNil(err)
  1167  		err = all.ScanList(&users, "UserScores", "User", "uid:uid")
  1168  		t.AssertNil(err)
  1169  	})
  1170  	return
  1171  	// Result ScanList with pointer elements and pointer attributes.
  1172  	gtest.C(t, func(t *gtest.T) {
  1173  		var users []*Entity
  1174  		// User
  1175  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1176  		t.AssertNil(err)
  1177  		err = all.ScanList(&users, "User")
  1178  		t.AssertNil(err)
  1179  		t.Assert(len(users), 0)
  1180  
  1181  		// Detail
  1182  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1183  		t.AssertNil(err)
  1184  		err = all.ScanList(&users, "UserDetail", "User", "Uid:UID")
  1185  		t.AssertNil(err)
  1186  
  1187  		// Scores
  1188  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1189  		t.AssertNil(err)
  1190  		err = all.ScanList(&users, "UserScores", "User", "Uid:UID")
  1191  		t.AssertNil(err)
  1192  	})
  1193  
  1194  	// Result ScanList with struct elements and struct attributes.
  1195  	gtest.C(t, func(t *gtest.T) {
  1196  		type EntityUser struct {
  1197  			Uid  int    `json:"uid"`
  1198  			Name string `json:"name"`
  1199  		}
  1200  		type EntityUserDetail struct {
  1201  			Uid     int    `json:"uid"`
  1202  			Address string `json:"address"`
  1203  		}
  1204  		type EntityUserScores struct {
  1205  			Id    int `json:"id"`
  1206  			Uid   int `json:"uid"`
  1207  			Score int `json:"score"`
  1208  		}
  1209  		type Entity struct {
  1210  			User       EntityUser
  1211  			UserDetail EntityUserDetail
  1212  			UserScores []EntityUserScores
  1213  		}
  1214  		var users []Entity
  1215  		// User
  1216  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1217  		t.AssertNil(err)
  1218  		err = all.ScanList(&users, "User")
  1219  		t.AssertNil(err)
  1220  
  1221  		// Detail
  1222  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1223  		t.AssertNil(err)
  1224  		err = all.ScanList(&users, "UserDetail", "User", "uid:UId")
  1225  		t.AssertNil(err)
  1226  
  1227  		// Scores
  1228  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1229  		t.AssertNil(err)
  1230  		err = all.ScanList(&users, "UserScores", "User", "UId:Uid")
  1231  		t.AssertNil(err)
  1232  	})
  1233  
  1234  	// Result ScanList with pointer elements and struct attributes.
  1235  	gtest.C(t, func(t *gtest.T) {
  1236  		type EntityUser struct {
  1237  			Uid  int    `json:"uid"`
  1238  			Name string `json:"name"`
  1239  		}
  1240  		type EntityUserDetail struct {
  1241  			Uid     int    `json:"uid"`
  1242  			Address string `json:"address"`
  1243  		}
  1244  		type EntityUserScores struct {
  1245  			Id    int `json:"id"`
  1246  			Uid   int `json:"uid"`
  1247  			Score int `json:"score"`
  1248  		}
  1249  		type Entity struct {
  1250  			User       EntityUser
  1251  			UserDetail EntityUserDetail
  1252  			UserScores []EntityUserScores
  1253  		}
  1254  		var users []*Entity
  1255  
  1256  		// User
  1257  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1258  		t.AssertNil(err)
  1259  		err = all.ScanList(&users, "User")
  1260  		t.AssertNil(err)
  1261  		t.Assert(len(users), 0)
  1262  		// Detail
  1263  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1264  		t.AssertNil(err)
  1265  		err = all.ScanList(&users, "UserDetail", "User", "uid:Uid")
  1266  		t.AssertNil(err)
  1267  
  1268  		// Scores
  1269  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1270  		t.AssertNil(err)
  1271  		err = all.ScanList(&users, "UserScores", "User", "UID:Uid")
  1272  		t.AssertNil(err)
  1273  	})
  1274  
  1275  	// Model ScanList with pointer elements and pointer attributes.
  1276  	gtest.C(t, func(t *gtest.T) {
  1277  		var users []*Entity
  1278  		// User
  1279  		err := db.Model(tableUser).
  1280  			Where("uid", g.Slice{3, 4}).
  1281  			Order("uid asc").
  1282  			ScanList(&users, "User")
  1283  		t.AssertNil(err)
  1284  		// Detail
  1285  		err = db.Model(tableUserDetail).
  1286  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1287  			Order("uid asc").
  1288  			ScanList(&users, "UserDetail", "User", "uid:Uid")
  1289  		t.AssertNil(err)
  1290  		// Scores
  1291  		err = db.Model(tableUserScores).
  1292  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1293  			Order("id asc").
  1294  			ScanList(&users, "UserScores", "User", "uid:Uid")
  1295  		t.AssertNil(err)
  1296  
  1297  		t.Assert(len(users), 0)
  1298  	})
  1299  }
  1300  
  1301  func Test_Table_Relation_NoneEqualDataSize(t *testing.T) {
  1302  	var (
  1303  		tableUser       = "user_" + gtime.TimestampMicroStr()
  1304  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
  1305  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
  1306  	)
  1307  	if _, err := db.Exec(fmt.Sprintf(`
  1308  CREATE TABLE %s (
  1309    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1310    name varchar(45) NOT NULL,
  1311    PRIMARY KEY (uid)
  1312  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1313      `, tableUser)); err != nil {
  1314  		gtest.Error(err)
  1315  	}
  1316  	defer dropTable(tableUser)
  1317  
  1318  	if _, err := db.Exec(fmt.Sprintf(`
  1319  CREATE TABLE %s (
  1320    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1321    address varchar(45) NOT NULL,
  1322    PRIMARY KEY (uid)
  1323  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1324      `, tableUserDetail)); err != nil {
  1325  		gtest.Error(err)
  1326  	}
  1327  	defer dropTable(tableUserDetail)
  1328  
  1329  	if _, err := db.Exec(fmt.Sprintf(`
  1330  CREATE TABLE %s (
  1331    id int(10) unsigned NOT NULL AUTO_INCREMENT,
  1332    uid int(10) unsigned NOT NULL,
  1333    score int(10) unsigned NOT NULL,
  1334    PRIMARY KEY (id)
  1335  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1336      `, tableUserScores)); err != nil {
  1337  		gtest.Error(err)
  1338  	}
  1339  	defer dropTable(tableUserScores)
  1340  
  1341  	type EntityUser struct {
  1342  		Uid  int    `json:"uid"`
  1343  		Name string `json:"name"`
  1344  	}
  1345  	type EntityUserDetail struct {
  1346  		Uid     int    `json:"uid"`
  1347  		Address string `json:"address"`
  1348  	}
  1349  	type EntityUserScores struct {
  1350  		Id    int `json:"id"`
  1351  		Uid   int `json:"uid"`
  1352  		Score int `json:"score"`
  1353  	}
  1354  	type Entity struct {
  1355  		User       *EntityUser
  1356  		UserDetail *EntityUserDetail
  1357  		UserScores []*EntityUserScores
  1358  	}
  1359  
  1360  	// Initialize the data.
  1361  	gtest.C(t, func(t *gtest.T) {
  1362  		var err error
  1363  		for i := 1; i <= 5; i++ {
  1364  			// User.
  1365  			_, err = db.Insert(tableUser, g.Map{
  1366  				"uid":  i,
  1367  				"name": fmt.Sprintf(`name_%d`, i),
  1368  			})
  1369  			t.AssertNil(err)
  1370  			// Detail.
  1371  			//_, err = db.Insert(tableUserDetail, g.Map{
  1372  			//	"uid":     i,
  1373  			//	"address": fmt.Sprintf(`address_%d`, i),
  1374  			//})
  1375  			//t.AssertNil(err)
  1376  			// Scores.
  1377  			//for j := 1; j <= 5; j++ {
  1378  			//	_, err = db.Insert(tableUserScores, g.Map{
  1379  			//		"uid":   i,
  1380  			//		"score": j,
  1381  			//	})
  1382  			//	t.AssertNil(err)
  1383  			//}
  1384  		}
  1385  	})
  1386  
  1387  	// Result ScanList with struct elements and pointer attributes.
  1388  	gtest.C(t, func(t *gtest.T) {
  1389  		var users []Entity
  1390  		// User
  1391  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1392  		t.AssertNil(err)
  1393  		err = all.ScanList(&users, "User")
  1394  		t.AssertNil(err)
  1395  		t.Assert(len(users), 2)
  1396  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1397  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1398  		// Detail
  1399  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1400  		t.AssertNil(err)
  1401  		err = all.ScanList(&users, "UserDetail", "User", "uid")
  1402  		t.AssertNil(err)
  1403  		t.Assert(users[0].UserDetail, nil)
  1404  		// Scores
  1405  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1406  		t.AssertNil(err)
  1407  		err = all.ScanList(&users, "UserScores", "User", "uid")
  1408  		t.AssertNil(err)
  1409  		t.Assert(len(users[0].UserScores), 0)
  1410  	})
  1411  
  1412  	// Result ScanList with pointer elements and pointer attributes.
  1413  	gtest.C(t, func(t *gtest.T) {
  1414  		var users []*Entity
  1415  		// User
  1416  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1417  		t.AssertNil(err)
  1418  		err = all.ScanList(&users, "User")
  1419  		t.AssertNil(err)
  1420  		t.Assert(len(users), 2)
  1421  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1422  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1423  		// Detail
  1424  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1425  		t.AssertNil(err)
  1426  		err = all.ScanList(&users, "UserDetail", "User", "Uid")
  1427  		t.AssertNil(err)
  1428  		t.Assert(users[0].UserDetail, nil)
  1429  		// Scores
  1430  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1431  		t.AssertNil(err)
  1432  		err = all.ScanList(&users, "UserScores", "User", "UID")
  1433  		t.AssertNil(err)
  1434  		t.Assert(len(users[0].UserScores), 0)
  1435  	})
  1436  
  1437  	// Result ScanList with struct elements and struct attributes.
  1438  	gtest.C(t, func(t *gtest.T) {
  1439  		type EntityUser struct {
  1440  			Uid  int    `json:"uid"`
  1441  			Name string `json:"name"`
  1442  		}
  1443  		type EntityUserDetail struct {
  1444  			Uid     int    `json:"uid"`
  1445  			Address string `json:"address"`
  1446  		}
  1447  		type EntityUserScores struct {
  1448  			Id    int `json:"id"`
  1449  			Uid   int `json:"uid"`
  1450  			Score int `json:"score"`
  1451  		}
  1452  		type Entity struct {
  1453  			User       EntityUser
  1454  			UserDetail EntityUserDetail
  1455  			UserScores []EntityUserScores
  1456  		}
  1457  		var users []Entity
  1458  		// User
  1459  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1460  		t.AssertNil(err)
  1461  		err = all.ScanList(&users, "User")
  1462  		t.AssertNil(err)
  1463  		t.Assert(len(users), 2)
  1464  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1465  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1466  		// Detail
  1467  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1468  		t.AssertNil(err)
  1469  		err = all.ScanList(&users, "UserDetail", "User", "UId")
  1470  		t.AssertNil(err)
  1471  		t.Assert(users[0].UserDetail, EntityUserDetail{})
  1472  		// Scores
  1473  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1474  		t.AssertNil(err)
  1475  		err = all.ScanList(&users, "UserScores", "User", "Uid")
  1476  		t.AssertNil(err)
  1477  		t.Assert(len(users[0].UserScores), 0)
  1478  	})
  1479  
  1480  	// Result ScanList with pointer elements and struct attributes.
  1481  	gtest.C(t, func(t *gtest.T) {
  1482  		type EntityUser struct {
  1483  			Uid  int    `json:"uid"`
  1484  			Name string `json:"name"`
  1485  		}
  1486  		type EntityUserDetail struct {
  1487  			Uid     int    `json:"uid"`
  1488  			Address string `json:"address"`
  1489  		}
  1490  		type EntityUserScores struct {
  1491  			Id    int `json:"id"`
  1492  			Uid   int `json:"uid"`
  1493  			Score int `json:"score"`
  1494  		}
  1495  		type Entity struct {
  1496  			User       EntityUser
  1497  			UserDetail EntityUserDetail
  1498  			UserScores []EntityUserScores
  1499  		}
  1500  		var users []*Entity
  1501  
  1502  		// User
  1503  		all, err := db.Model(tableUser).Where("uid", g.Slice{3, 4}).Order("uid asc").All()
  1504  		t.AssertNil(err)
  1505  		err = all.ScanList(&users, "User")
  1506  		t.AssertNil(err)
  1507  		t.Assert(len(users), 2)
  1508  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1509  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1510  		// Detail
  1511  		all, err = db.Model(tableUserDetail).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("uid asc").All()
  1512  		t.AssertNil(err)
  1513  		err = all.ScanList(&users, "UserDetail", "User", "uid")
  1514  		t.AssertNil(err)
  1515  		t.Assert(users[0].UserDetail, EntityUserDetail{})
  1516  		// Scores
  1517  		all, err = db.Model(tableUserScores).Where("uid", gdb.ListItemValues(users, "User", "Uid")).Order("id asc").All()
  1518  		t.AssertNil(err)
  1519  		err = all.ScanList(&users, "UserScores", "User", "UID")
  1520  		t.AssertNil(err)
  1521  		t.Assert(len(users[0].UserScores), 0)
  1522  	})
  1523  
  1524  	// Model ScanList with pointer elements and pointer attributes.
  1525  	gtest.C(t, func(t *gtest.T) {
  1526  		var users []*Entity
  1527  		// User
  1528  		err := db.Model(tableUser).
  1529  			Where("uid", g.Slice{3, 4}).
  1530  			Order("uid asc").
  1531  			ScanList(&users, "User")
  1532  		t.AssertNil(err)
  1533  		// Detail
  1534  		err = db.Model(tableUserDetail).
  1535  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1536  			Order("uid asc").
  1537  			ScanList(&users, "UserDetail", "User", "uid")
  1538  		t.AssertNil(err)
  1539  		// Scores
  1540  		err = db.Model(tableUserScores).
  1541  			Where("uid", gdb.ListItemValues(users, "User", "Uid")).
  1542  			Order("id asc").
  1543  			ScanList(&users, "UserScores", "User", "uid")
  1544  		t.AssertNil(err)
  1545  
  1546  		t.Assert(len(users), 2)
  1547  		t.Assert(users[0].User, &EntityUser{3, "name_3"})
  1548  		t.Assert(users[1].User, &EntityUser{4, "name_4"})
  1549  
  1550  		t.Assert(users[0].UserDetail, nil)
  1551  
  1552  		t.Assert(len(users[0].UserScores), 0)
  1553  	})
  1554  }
  1555  
  1556  func Test_Table_Relation_EmbeddedStruct(t *testing.T) {
  1557  	var (
  1558  		tableUser       = "user_" + gtime.TimestampMicroStr()
  1559  		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
  1560  		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
  1561  	)
  1562  	if _, err := db.Exec(fmt.Sprintf(`
  1563  CREATE TABLE %s (
  1564    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1565    name varchar(45) NOT NULL,
  1566    PRIMARY KEY (uid)
  1567  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1568      `, tableUser)); err != nil {
  1569  		gtest.Error(err)
  1570  	}
  1571  	defer dropTable(tableUser)
  1572  
  1573  	if _, err := db.Exec(fmt.Sprintf(`
  1574  CREATE TABLE %s (
  1575    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
  1576    address varchar(45) NOT NULL,
  1577    PRIMARY KEY (uid)
  1578  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1579      `, tableUserDetail)); err != nil {
  1580  		gtest.Error(err)
  1581  	}
  1582  	defer dropTable(tableUserDetail)
  1583  
  1584  	if _, err := db.Exec(fmt.Sprintf(`
  1585  CREATE TABLE %s (
  1586    id int(10) unsigned NOT NULL AUTO_INCREMENT,
  1587    uid int(10) unsigned NOT NULL,
  1588    score int(10) unsigned NOT NULL,
  1589    PRIMARY KEY (id)
  1590  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  1591      `, tableUserScores)); err != nil {
  1592  		gtest.Error(err)
  1593  	}
  1594  	defer dropTable(tableUserScores)
  1595  
  1596  	type EntityUser struct {
  1597  		Uid  int    `json:"uid"`
  1598  		Name string `json:"name"`
  1599  	}
  1600  	type EntityUserDetail struct {
  1601  		*EntityUser
  1602  		Uid     int    `json:"uid"`
  1603  		Address string `json:"address"`
  1604  	}
  1605  	type EntityUserScores struct {
  1606  		*EntityUser
  1607  		*EntityUserDetail
  1608  		Id    int `json:"id"`
  1609  		Uid   int `json:"uid"`
  1610  		Score int `json:"score"`
  1611  	}
  1612  
  1613  	// Initialize the data.
  1614  	gtest.C(t, func(t *gtest.T) {
  1615  		var err error
  1616  		for i := 1; i <= 5; i++ {
  1617  			// User.
  1618  			_, err = db.Insert(tableUser, g.Map{
  1619  				"uid":  i,
  1620  				"name": fmt.Sprintf(`name_%d`, i),
  1621  			})
  1622  			t.AssertNil(err)
  1623  			// Detail.
  1624  			_, err = db.Insert(tableUserDetail, g.Map{
  1625  				"uid":     i,
  1626  				"address": fmt.Sprintf(`address_%d`, i),
  1627  			})
  1628  			t.AssertNil(err)
  1629  			// Scores.
  1630  			for j := 1; j <= 5; j++ {
  1631  				_, err = db.Insert(tableUserScores, g.Map{
  1632  					"uid":   i,
  1633  					"score": j,
  1634  				})
  1635  				t.AssertNil(err)
  1636  			}
  1637  		}
  1638  	})
  1639  
  1640  	gtest.C(t, func(t *gtest.T) {
  1641  		var (
  1642  			err    error
  1643  			scores []*EntityUserScores
  1644  		)
  1645  		// SELECT * FROM `user_scores`
  1646  		err = db.Model(tableUserScores).Scan(&scores)
  1647  		t.AssertNil(err)
  1648  
  1649  		// SELECT * FROM `user_scores` WHERE `uid` IN(1,2,3,4,5)
  1650  		err = db.Model(tableUser).
  1651  			Where("uid", gdb.ListItemValuesUnique(&scores, "Uid")).
  1652  			ScanList(&scores, "EntityUser", "uid:Uid")
  1653  		t.AssertNil(err)
  1654  
  1655  		// SELECT * FROM `user_detail` WHERE `uid` IN(1,2,3,4,5)
  1656  		err = db.Model(tableUserDetail).
  1657  			Where("uid", gdb.ListItemValuesUnique(&scores, "Uid")).
  1658  			ScanList(&scores, "EntityUserDetail", "uid:Uid")
  1659  		t.AssertNil(err)
  1660  
  1661  		// Assertions.
  1662  		t.Assert(len(scores), 25)
  1663  		t.Assert(scores[0].Id, 1)
  1664  		t.Assert(scores[0].Uid, 1)
  1665  		t.Assert(scores[0].Name, "name_1")
  1666  		t.Assert(scores[0].Address, "address_1")
  1667  		t.Assert(scores[24].Id, 25)
  1668  		t.Assert(scores[24].Uid, 5)
  1669  		t.Assert(scores[24].Name, "name_5")
  1670  		t.Assert(scores[24].Address, "address_5")
  1671  	})
  1672  }