func ExampleContext_All() {
type Person struct {
// ...
}
ctx := rebecca.Context{Limit: 20, Skip: 40}
people := []Person{}
if err := ctx.All(&people); err != nil {
panic(err)
}
// At this point people contains 20 Person records starting from 41th from
// the database.
fmt.Print(people)
}
func ExampleContext_Where() {
type Person struct {
// ...
}
ctx := rebecca.Context{Order: "age DESC"}
teenagers := []Person{}
if err := ctx.Where(&teenagers, "age < $1", 21); err != nil {
panic(err)
}
// At this point teenagers will contain a list of Person records sorted by
// age in descending order and where age < 21.
fmt.Print(teenagers)
}
func ExampleContext_First() {
type Person struct {
// ...
}
ctx := rebecca.Context{Order: "age DESC"}
oldestTeenager := &Person{}
if err := ctx.First(oldestTeenager, "age < $1", 21); err != nil {
panic(err)
}
// At this point oldestTeenager will contain a Person record that is of
// maximum age and that is of age < 21.
fmt.Print(oldestTeenager)
}
func TestGroup(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "Bruce", Age: 27}
p4 := &Person{Name: "James", Age: 11}
p5 := &Person{Name: "Monika", Age: 11}
p6 := &Person{Name: "Peter", Age: 21}
p7 := &Person{Name: "Brad", Age: 11}
people := []*Person{p1, p2, p3, p4, p5, p6, p7}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
type PersonByAge struct {
rebecca.ModelMetadata `tablename:"people"`
Age int `rebecca:"age" rebecca_primary:"true"`
Count int `rebecca:"count(distinct(id))"`
}
ctx := rebecca.Context{Group: "age"}
expected := []PersonByAge{
{Age: 9, Count: 1},
{Age: 11, Count: 3},
{Age: 21, Count: 1},
{Age: 27, Count: 2},
}
actual := []PersonByAge{}
if err := ctx.All(&actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func ExampleModelMetadata() {
type Person struct {
// ModelMetadata allows to provide table name for the model
rebecca.ModelMetadata `tablename:"people"`
ID int `rebecca:"id" rebecca_primary:"true"`
Name string `rebecca:"name"`
Age int `rebecca:"age"`
}
type PostsOfPerson struct {
// Additionally you can have any expression as a table name, that your
// driver will allow, for example, simple join:
rebecca.ModelMetadata `tablename:"people JOIN posts ON posts.author_id = people.id"`
// .. fields are defined here ..
}
type PersonCountByAge struct {
rebecca.ModelMetadata `tablename:"people"`
// Additionally you can use any expressions as a database mapping for
// fields, that your driver will allow, for example,
// count(distinct(field_name)):
Count int `rebecca:"count(distinct(id))"`
Age int `rebecca:"age"`
}
// PersonCountByAge is useful, because it can be nicely used with
// aggregation:
byAge := []PersonCountByAge{}
ctx := rebecca.Context{Group: "age"}
if err := ctx.All(&byAge); err != nil {
panic(err)
}
// At this point byAge contains counts of people per each distinct age.
// Ordering depends on your chosen driver and database.
fmt.Print(byAge)
}