Gleipnir/jet
4
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Add support for slice model scan.

Browse source
This commit is contained in:
sub0Zero 2019-03-14 09:18:23 +01:00 • committed by zer0sub
parent 3f4b5c69d3
commit bb18e4d0f7
2 changed files with 385 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

172
tests/generator_test.go
View file

@ -10,6 +10,7 @@ import (
"gotest.tools/assert"
"os"
"testing"
"time"
)
const (
@ -55,18 +56,23 @@ func TestGenerateModel(t *testing.T) {
//assert.NilError(t, err)
}
func TestSelectQuery(t *testing.T) {
//query := Actor.InnerJoinOn(Store, Eq(Actor.ActorID, Store.StoreID)).
// Select(Store.StoreID, Store.AddressID, Actor.ActorID)
//
//queryStr, err := query.String(schemaName)
//
//assert.NilError(t, err)
//
//assert.Equal(t, queryStr, "SELECT store.store_id,store.address_id,actor.actor_id FROM dvds.actor JOIN dvds.store ON actor.actor_id=store.store_id")
//
//err = query.Execute(db, nil)
func TestSelect_ScanToStruct(t *testing.T) {
actor := model.Actor{}
err := Actor.Select(Actor.All...).Execute(db, &actor)
assert.NilError(t, err)
expectedActor := model.Actor{
ActorID: 1,
FirstName: "Penelope",
LastName: "Guiness",
LastUpdate: *timeWithoutTimeZone("2013-05-26 14:47:57.62 +0000"),
}
assert.DeepEqual(t, actor, expectedActor)
}
func TestSelect_ScanToSlice(t *testing.T) {
customers := []model.Customer{}
query := Customer.Select(Customer.All...)
@ -75,51 +81,157 @@ func TestSelectQuery(t *testing.T) {
assert.NilError(t, err)
assert.Equal(t, queryStr, `SELECT customer.customer_id AS "customer.customer_id",customer.store_id AS "customer.store_id",customer.first_name AS "customer.first_name",customer.last_name AS "customer.last_name",customer.email AS "customer.email",customer.address_id AS "customer.address_id",customer.activebool AS "customer.activebool",customer.create_date AS "customer.create_date",customer.last_update AS "customer.last_update",customer.active AS "customer.active" FROM dvds.customer`)
//fmt.Println(queryStr)
err = query.Execute(db, &customers)
//fmt.Println(customers)
//
//spew.Sdump(customers)
assert.NilError(t, err)
customer0 := model.Customer{
CustomerID: 524,
StoreID: 1,
FirstName: "Jared",
LastName: "Ely",
Email: stringPtr("austin.cintron@sakilacustomer.org"),
Address: nil,
Activebool: true,
CreateDate: *timeWithoutTimeZone("2006-02-14 00:00:00 +0000"),
LastUpdate: timeWithoutTimeZone("2013-05-26 14:49:45.738 +0000"),
Active: int32Ptr(1),
}
customer1 := model.Customer{
CustomerID: 1,
StoreID: 1,
FirstName: "Mary",
LastName: "Smith",
Email: stringPtr("austin.cintron@sakilacustomer.org"),
Address: nil,
Activebool: true,
CreateDate: *timeWithoutTimeZone("2006-02-14 00:00:00 +0000"),
LastUpdate: timeWithoutTimeZone("2013-05-26 14:49:45.738 +0000"),
Active: int32Ptr(1),
}
lastCustomer := model.Customer{
CustomerID: 599,
StoreID: 2,
FirstName: "Austin",
LastName: "Cintron",
Email: stringPtr("austin.cintron@sakilacustomer.org"),
Address: nil,
Activebool: true,
CreateDate: *timeWithoutTimeZone("2006-02-14 00:00:00 +0000"),
LastUpdate: timeWithoutTimeZone("2013-05-26 14:49:45.738 +0000"),
Active: int32Ptr(1),
}
assert.Equal(t, len(customers), 599)
actor := model.Actor{}
err = Actor.Select(Actor.All...).Execute(db, &actor)
assert.NilError(t, err)
//spew.Dump(actor)
//time, _ := time.Parse("2006-01-02 15:04:05.00MST", "2013-05-26 14:47:57.62MST")
assert.Equal(t, actor.ActorID, int32(1))
assert.Equal(t, actor.FirstName, "Penelope")
assert.Equal(t, actor.LastName, "Guiness")
assert.DeepEqual(t, customer0, customers[0])
assert.DeepEqual(t, customer1, customers[1])
assert.DeepEqual(t, lastCustomer, customers[598])
}
func TestJoinQuery(t *testing.T) {
func TestJoinQueryStruct(t *testing.T) {
//filmActor := model.FilmActor{}
allFilmActorColumns := append(append(Actor.All, Film.All...), Language.All...)
allFilmActorColumns := append(append(append(FilmActor.All, Film.All...), Language.All...), Actor.All...)
query := FilmActor.
InnerJoinOn(Actor, sqlbuilder.Eq(FilmActor.ActorID, Actor.ActorID)).
InnerJoinOn(Film, sqlbuilder.Eq(FilmActor.FilmID, Film.FilmID)).
InnerJoinOn(Language, sqlbuilder.Eq(Film.LanguageID, Language.LanguageID)).
Select(allFilmActorColumns...).
Where(sqlbuilder.Eq(FilmActor.ActorID, sqlbuilder.Literal(1)))
Where(sqlbuilder.And(sqlbuilder.Gte(FilmActor.ActorID, sqlbuilder.Literal(1)), sqlbuilder.Lte(FilmActor.ActorID, sqlbuilder.Literal(2))))
queryStr, err := query.String()
assert.NilError(t, err)
fmt.Println(queryStr)
filmActor := model.FilmActor{}
filmActor := []model.FilmActor{}
err = query.Execute(db, &filmActor)
assert.NilError(t, err)
//fmt.Println("ACTORS: --------------------")
//spew.Dump(filmActor)
}
func TestJoinQuerySlice(t *testing.T) {
type FilmsPerLanguage struct {
Language *model.Language
Films *[]model.Film
}
filmsPerLanguage := []FilmsPerLanguage{}
limit := 15
query := Film.InnerJoinOn(Language, sqlbuilder.Eq(Film.LanguageID, Language.LanguageID)).
Select(append(Language.All, Film.All...)...).
Limit(15)
queryStr, _ := query.String()
fmt.Println(queryStr)
err := query.Execute(db, &filmsPerLanguage)
assert.NilError(t, err)
//fmt.Println("--------------- result --------------- ")
//spew.Dump(filmsPerLanguage)
assert.Equal(t, len(filmsPerLanguage), 1)
assert.Equal(t, len(*filmsPerLanguage[0].Films), limit)
//spew.Dump(filmsPerLanguage)
filmsPerLanguageWithPtrs := []*FilmsPerLanguage{}
err = query.Execute(db, &filmsPerLanguageWithPtrs)
assert.NilError(t, err)
assert.Equal(t, len(filmsPerLanguage), 1)
assert.Equal(t, len(*filmsPerLanguage[0].Films), limit)
}
func TestJoinQuerySliceWithPtrs(t *testing.T) {
type FilmsPerLanguage struct {
Language model.Language
Films *[]*model.Film
}
limit := int64(3)
query := Film.InnerJoinOn(Language, sqlbuilder.Eq(Film.LanguageID, Language.LanguageID)).
Select(append(Language.All, Film.All...)...).
Limit(limit)
filmsPerLanguageWithPtrs := []*FilmsPerLanguage{}
err := query.Execute(db, &filmsPerLanguageWithPtrs)
//spew.Dump(filmsPerLanguageWithPtrs)
assert.NilError(t, err)
assert.Equal(t, len(filmsPerLanguageWithPtrs), 1)
assert.Equal(t, len(*filmsPerLanguageWithPtrs[0].Films), int(limit))
}
func int32Ptr(i int32) *int32 {
return &i
}
func stringPtr(s string) *string {
return &s
}
func timeWithoutTimeZone(t string) *time.Time {
time, err := time.Parse("2006-01-02 15:04:05 -0700", t)
if err != nil {
panic(err)
}
return &time
}