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)
}