tests

package

Go to main page

Versions in this module

v1

v1.3.5

Jun 7, 2018

v1.3.4

Apr 20, 2018

Changes in this version

type AStore

+ func (s *AStore) DisableCacher() *AStore

type BStore

+ func (s *BStore) DisableCacher() *BStore

type BrandStore

+ func (s *BrandStore) DisableCacher() *BrandStore

type CStore

+ func (s *CStore) DisableCacher() *CStore

type CarStore

+ func (s *CarStore) DisableCacher() *CarStore

type ChildStore

+ func (s *ChildStore) DisableCacher() *ChildStore

type EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) DisableCacher() *EventsAllFixtureStore

type EventsFixtureStore

+ func (s *EventsFixtureStore) DisableCacher() *EventsFixtureStore

type EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) DisableCacher() *EventsSaveFixtureStore

type JSONModelStore

+ func (s *JSONModelStore) DisableCacher() *JSONModelStore

type MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) DisableCacher() *MultiKeySortFixtureStore

type NullableStore

+ func (s *NullableStore) DisableCacher() *NullableStore

type ParentNoPtrStore

+ func (s *ParentNoPtrStore) DisableCacher() *ParentNoPtrStore

type ParentStore

+ func (s *ParentStore) DisableCacher() *ParentStore

type PersonStore

+ func (s *PersonStore) DisableCacher() *PersonStore

type PetStore

+ func (s *PetStore) DisableCacher() *PetStore

type QueryFixtureStore

+ func (s *QueryFixtureStore) DisableCacher() *QueryFixtureStore

type QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) DisableCacher() *QueryRelationFixtureStore

type ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) DisableCacher() *ResultSetFixtureStore

type SchemaFixtureStore

+ func (s *SchemaFixtureStore) DisableCacher() *SchemaFixtureStore

type SchemaRelationshipFixtureStore

+ func (s *SchemaRelationshipFixtureStore) DisableCacher() *SchemaRelationshipFixtureStore

type StoreFixtureStore

+ func (s *StoreFixtureStore) DisableCacher() *StoreFixtureStore

type StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) DisableCacher() *StoreWithConstructFixtureStore

type StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) DisableCacher() *StoreWithNewFixtureStore

v1.3.3

Nov 23, 2017

v1.3.2

Nov 15, 2017

v1.3.1

Aug 9, 2017

v1.3.0

Aug 3, 2017

Changes in this version

+ type A struct

+ B *B

+ ID int64

+ Name string

+ func NewA(name string) (record *A)

+ func (r *A) ColumnAddress(col string) (interface{}, error)

+ func (r *A) GetID() kallax.Identifier

+ func (r *A) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *A) SetRelationship(field string, rel interface{}) error

+ func (r *A) Value(col string) (interface{}, error)

+ type AQuery struct

+ func NewAQuery() *AQuery

+ func (q *AQuery) BatchSize(size uint64) *AQuery

+ func (q *AQuery) Copy() *AQuery

+ func (q *AQuery) FindByID(v ...int64) *AQuery

+ func (q *AQuery) FindByName(v string) *AQuery

+ func (q *AQuery) Limit(n uint64) *AQuery

+ func (q *AQuery) Offset(n uint64) *AQuery

+ func (q *AQuery) Order(cols ...kallax.ColumnOrder) *AQuery

+ func (q *AQuery) Select(columns ...kallax.SchemaField) *AQuery

+ func (q *AQuery) SelectNot(columns ...kallax.SchemaField) *AQuery

+ func (q *AQuery) Where(cond kallax.Condition) *AQuery

+ func (q *AQuery) WithB() *AQuery

+ type AResultSet struct

+ ResultSet kallax.ResultSet

+ func NewAResultSet(rs kallax.ResultSet) *AResultSet

+ func (rs *AResultSet) All() ([]*A, error)

+ func (rs *AResultSet) Close() error

+ func (rs *AResultSet) Err() error

+ func (rs *AResultSet) ForEach(fn func(*A) error) error

+ func (rs *AResultSet) Get() (*A, error)

+ func (rs *AResultSet) Next() bool

+ func (rs *AResultSet) One() (*A, error)

+ type AStore struct

+ func NewAStore(db *sql.DB) *AStore

+ func (s *AStore) Count(q *AQuery) (int64, error)

+ func (s *AStore) Debug() *AStore

+ func (s *AStore) DebugWith(logger kallax.LoggerFunc) *AStore

+ func (s *AStore) Delete(record *A) error

+ func (s *AStore) Find(q *AQuery) (*AResultSet, error)

+ func (s *AStore) FindAll(q *AQuery) ([]*A, error)

+ func (s *AStore) FindOne(q *AQuery) (*A, error)

+ func (s *AStore) GenericStore() *kallax.Store

+ func (s *AStore) Insert(record *A) error

+ func (s *AStore) MustCount(q *AQuery) int64

+ func (s *AStore) MustFind(q *AQuery) *AResultSet

+ func (s *AStore) MustFindOne(q *AQuery) *A

+ func (s *AStore) Reload(record *A) error

+ func (s *AStore) RemoveB(record *A) error

+ func (s *AStore) Save(record *A) (updated bool, err error)

+ func (s *AStore) SetGenericStore(store *kallax.Store)

+ func (s *AStore) Transaction(callback func(*AStore) error) error

+ func (s *AStore) Update(record *A, cols ...kallax.SchemaField) (updated int64, err error)

+ type B struct

+ A *A

+ C *C

+ ID int64

+ Name string

+ func NewB(name string, a *A) (record *B)

+ func (r *B) ColumnAddress(col string) (interface{}, error)

+ func (r *B) GetID() kallax.Identifier

+ func (r *B) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *B) SetRelationship(field string, rel interface{}) error

+ func (r *B) Value(col string) (interface{}, error)

+ type BQuery struct

+ func NewBQuery() *BQuery

+ func (q *BQuery) BatchSize(size uint64) *BQuery

+ func (q *BQuery) Copy() *BQuery

+ func (q *BQuery) FindByA(v int64) *BQuery

+ func (q *BQuery) FindByID(v ...int64) *BQuery

+ func (q *BQuery) FindByName(v string) *BQuery

+ func (q *BQuery) Limit(n uint64) *BQuery

+ func (q *BQuery) Offset(n uint64) *BQuery

+ func (q *BQuery) Order(cols ...kallax.ColumnOrder) *BQuery

+ func (q *BQuery) Select(columns ...kallax.SchemaField) *BQuery

+ func (q *BQuery) SelectNot(columns ...kallax.SchemaField) *BQuery

+ func (q *BQuery) Where(cond kallax.Condition) *BQuery

+ func (q *BQuery) WithA() *BQuery

+ func (q *BQuery) WithC() *BQuery

+ type BResultSet struct

+ ResultSet kallax.ResultSet

+ func NewBResultSet(rs kallax.ResultSet) *BResultSet

+ func (rs *BResultSet) All() ([]*B, error)

+ func (rs *BResultSet) Close() error

+ func (rs *BResultSet) Err() error

+ func (rs *BResultSet) ForEach(fn func(*B) error) error

+ func (rs *BResultSet) Get() (*B, error)

+ func (rs *BResultSet) Next() bool

+ func (rs *BResultSet) One() (*B, error)

+ type BStore struct

+ func NewBStore(db *sql.DB) *BStore

+ func (s *BStore) Count(q *BQuery) (int64, error)

+ func (s *BStore) Debug() *BStore

+ func (s *BStore) DebugWith(logger kallax.LoggerFunc) *BStore

+ func (s *BStore) Delete(record *B) error

+ func (s *BStore) Find(q *BQuery) (*BResultSet, error)

+ func (s *BStore) FindAll(q *BQuery) ([]*B, error)

+ func (s *BStore) FindOne(q *BQuery) (*B, error)

+ func (s *BStore) GenericStore() *kallax.Store

+ func (s *BStore) Insert(record *B) error

+ func (s *BStore) MustCount(q *BQuery) int64

+ func (s *BStore) MustFind(q *BQuery) *BResultSet

+ func (s *BStore) MustFindOne(q *BQuery) *B

+ func (s *BStore) Reload(record *B) error

+ func (s *BStore) RemoveC(record *B) error

+ func (s *BStore) Save(record *B) (updated bool, err error)

+ func (s *BStore) SetGenericStore(store *kallax.Store)

+ func (s *BStore) Transaction(callback func(*BStore) error) error

+ func (s *BStore) Update(record *B, cols ...kallax.SchemaField) (updated int64, err error)

+ type Brand struct

+ ID kallax.ULID

+ Name string

+ func NewBrand(name string) (record *Brand)

+ func (r *Brand) ColumnAddress(col string) (interface{}, error)

+ func (r *Brand) GetID() kallax.Identifier

+ func (r *Brand) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Brand) SetRelationship(field string, rel interface{}) error

+ func (r *Brand) Value(col string) (interface{}, error)

+ type BrandQuery struct

+ func NewBrandQuery() *BrandQuery

+ func (q *BrandQuery) BatchSize(size uint64) *BrandQuery

+ func (q *BrandQuery) Copy() *BrandQuery

+ func (q *BrandQuery) FindByID(v ...kallax.ULID) *BrandQuery

+ func (q *BrandQuery) FindByName(v string) *BrandQuery

+ func (q *BrandQuery) Limit(n uint64) *BrandQuery

+ func (q *BrandQuery) Offset(n uint64) *BrandQuery

+ func (q *BrandQuery) Order(cols ...kallax.ColumnOrder) *BrandQuery

+ func (q *BrandQuery) Select(columns ...kallax.SchemaField) *BrandQuery

+ func (q *BrandQuery) SelectNot(columns ...kallax.SchemaField) *BrandQuery

+ func (q *BrandQuery) Where(cond kallax.Condition) *BrandQuery

+ type BrandResultSet struct

+ ResultSet kallax.ResultSet

+ func NewBrandResultSet(rs kallax.ResultSet) *BrandResultSet

+ func (rs *BrandResultSet) All() ([]*Brand, error)

+ func (rs *BrandResultSet) Close() error

+ func (rs *BrandResultSet) Err() error

+ func (rs *BrandResultSet) ForEach(fn func(*Brand) error) error

+ func (rs *BrandResultSet) Get() (*Brand, error)

+ func (rs *BrandResultSet) Next() bool

+ func (rs *BrandResultSet) One() (*Brand, error)

+ type BrandStore struct

+ func NewBrandStore(db *sql.DB) *BrandStore

+ func (s *BrandStore) Count(q *BrandQuery) (int64, error)

+ func (s *BrandStore) Debug() *BrandStore

+ func (s *BrandStore) DebugWith(logger kallax.LoggerFunc) *BrandStore

+ func (s *BrandStore) Delete(record *Brand) error

+ func (s *BrandStore) Find(q *BrandQuery) (*BrandResultSet, error)

+ func (s *BrandStore) FindAll(q *BrandQuery) ([]*Brand, error)

+ func (s *BrandStore) FindOne(q *BrandQuery) (*Brand, error)

+ func (s *BrandStore) GenericStore() *kallax.Store

+ func (s *BrandStore) Insert(record *Brand) error

+ func (s *BrandStore) MustCount(q *BrandQuery) int64

+ func (s *BrandStore) MustFind(q *BrandQuery) *BrandResultSet

+ func (s *BrandStore) MustFindOne(q *BrandQuery) *Brand

+ func (s *BrandStore) Reload(record *Brand) error

+ func (s *BrandStore) Save(record *Brand) (updated bool, err error)

+ func (s *BrandStore) SetGenericStore(store *kallax.Store)

+ func (s *BrandStore) Transaction(callback func(*BrandStore) error) error

+ func (s *BrandStore) Update(record *Brand, cols ...kallax.SchemaField) (updated int64, err error)

+ type C struct

+ B *B

+ ID int64

+ Name string

+ func NewC(name string, b *B) (record *C)

+ func (r *C) ColumnAddress(col string) (interface{}, error)

+ func (r *C) GetID() kallax.Identifier

+ func (r *C) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *C) SetRelationship(field string, rel interface{}) error

+ func (r *C) Value(col string) (interface{}, error)

+ type CQuery struct

+ func NewCQuery() *CQuery

+ func (q *CQuery) BatchSize(size uint64) *CQuery

+ func (q *CQuery) Copy() *CQuery

+ func (q *CQuery) FindByB(v int64) *CQuery

+ func (q *CQuery) FindByID(v ...int64) *CQuery

+ func (q *CQuery) FindByName(v string) *CQuery

+ func (q *CQuery) Limit(n uint64) *CQuery

+ func (q *CQuery) Offset(n uint64) *CQuery

+ func (q *CQuery) Order(cols ...kallax.ColumnOrder) *CQuery

+ func (q *CQuery) Select(columns ...kallax.SchemaField) *CQuery

+ func (q *CQuery) SelectNot(columns ...kallax.SchemaField) *CQuery

+ func (q *CQuery) Where(cond kallax.Condition) *CQuery

+ func (q *CQuery) WithB() *CQuery

+ type CResultSet struct

+ ResultSet kallax.ResultSet

+ func NewCResultSet(rs kallax.ResultSet) *CResultSet

+ func (rs *CResultSet) All() ([]*C, error)

+ func (rs *CResultSet) Close() error

+ func (rs *CResultSet) Err() error

+ func (rs *CResultSet) ForEach(fn func(*C) error) error

+ func (rs *CResultSet) Get() (*C, error)

+ func (rs *CResultSet) Next() bool

+ func (rs *CResultSet) One() (*C, error)

+ type CStore struct

+ func NewCStore(db *sql.DB) *CStore

+ func (s *CStore) Count(q *CQuery) (int64, error)

+ func (s *CStore) Debug() *CStore

+ func (s *CStore) DebugWith(logger kallax.LoggerFunc) *CStore

+ func (s *CStore) Delete(record *C) error

+ func (s *CStore) Find(q *CQuery) (*CResultSet, error)

+ func (s *CStore) FindAll(q *CQuery) ([]*C, error)

+ func (s *CStore) FindOne(q *CQuery) (*C, error)

+ func (s *CStore) GenericStore() *kallax.Store

+ func (s *CStore) Insert(record *C) error

+ func (s *CStore) MustCount(q *CQuery) int64

+ func (s *CStore) MustFind(q *CQuery) *CResultSet

+ func (s *CStore) MustFindOne(q *CQuery) *C

+ func (s *CStore) Reload(record *C) error

+ func (s *CStore) Save(record *C) (updated bool, err error)

+ func (s *CStore) SetGenericStore(store *kallax.Store)

+ func (s *CStore) Transaction(callback func(*CStore) error) error

+ func (s *CStore) Update(record *C, cols ...kallax.SchemaField) (updated int64, err error)

type Car

+ Brand *Brand

type CarQuery

+ func (q *CarQuery) FindByBrand(v kallax.ULID) *CarQuery

+ func (q *CarQuery) WithBrand() *CarQuery

v1.2.21

Aug 1, 2017

v1.2.20

Aug 1, 2017

v1.2.19

Jul 26, 2017

v1.2.18

Jul 18, 2017

v1.2.17

Jul 18, 2017

v1.2.16

Jul 18, 2017

v1.2.15

Jul 18, 2017

v1.2.14

Jul 12, 2017

v1.2.13

Jun 28, 2017

v1.2.12

Jun 19, 2017

v1.2.11

Jun 19, 2017

v1.2.10

Jun 13, 2017

v1.2.9

Jun 13, 2017

Changes in this version

+ type ParentNoPtr struct

+ Children []Child

+ ID int64

+ Name string

+ func NewParentNoPtr() (record *ParentNoPtr)

+ func (r *ParentNoPtr) ColumnAddress(col string) (interface{}, error)

+ func (r *ParentNoPtr) GetID() kallax.Identifier

+ func (r *ParentNoPtr) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *ParentNoPtr) SetRelationship(field string, rel interface{}) error

+ func (r *ParentNoPtr) Value(col string) (interface{}, error)

+ type ParentNoPtrQuery struct

+ func NewParentNoPtrQuery() *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) BatchSize(size uint64) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Copy() *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) FindByID(v ...int64) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) FindByName(v string) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Limit(n uint64) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Offset(n uint64) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Order(cols ...kallax.ColumnOrder) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Select(columns ...kallax.SchemaField) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) SelectNot(columns ...kallax.SchemaField) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) Where(cond kallax.Condition) *ParentNoPtrQuery

+ func (q *ParentNoPtrQuery) WithChildren(cond kallax.Condition) *ParentNoPtrQuery

+ type ParentNoPtrResultSet struct

+ ResultSet kallax.ResultSet

+ func NewParentNoPtrResultSet(rs kallax.ResultSet) *ParentNoPtrResultSet

+ func (rs *ParentNoPtrResultSet) All() ([]*ParentNoPtr, error)

+ func (rs *ParentNoPtrResultSet) Close() error

+ func (rs *ParentNoPtrResultSet) Err() error

+ func (rs *ParentNoPtrResultSet) ForEach(fn func(*ParentNoPtr) error) error

+ func (rs *ParentNoPtrResultSet) Get() (*ParentNoPtr, error)

+ func (rs *ParentNoPtrResultSet) Next() bool

+ func (rs *ParentNoPtrResultSet) One() (*ParentNoPtr, error)

+ type ParentNoPtrStore struct

+ func NewParentNoPtrStore(db *sql.DB) *ParentNoPtrStore

+ func (s *ParentNoPtrStore) Count(q *ParentNoPtrQuery) (int64, error)

+ func (s *ParentNoPtrStore) Debug() *ParentNoPtrStore

+ func (s *ParentNoPtrStore) DebugWith(logger kallax.LoggerFunc) *ParentNoPtrStore

+ func (s *ParentNoPtrStore) Delete(record *ParentNoPtr) error

+ func (s *ParentNoPtrStore) Find(q *ParentNoPtrQuery) (*ParentNoPtrResultSet, error)

+ func (s *ParentNoPtrStore) FindAll(q *ParentNoPtrQuery) ([]*ParentNoPtr, error)

+ func (s *ParentNoPtrStore) FindOne(q *ParentNoPtrQuery) (*ParentNoPtr, error)

+ func (s *ParentNoPtrStore) GenericStore() *kallax.Store

+ func (s *ParentNoPtrStore) Insert(record *ParentNoPtr) error

+ func (s *ParentNoPtrStore) MustCount(q *ParentNoPtrQuery) int64

+ func (s *ParentNoPtrStore) MustFind(q *ParentNoPtrQuery) *ParentNoPtrResultSet

+ func (s *ParentNoPtrStore) MustFindOne(q *ParentNoPtrQuery) *ParentNoPtr

+ func (s *ParentNoPtrStore) Reload(record *ParentNoPtr) error

+ func (s *ParentNoPtrStore) RemoveChildren(record *ParentNoPtr, deleted ...Child) error

+ func (s *ParentNoPtrStore) Save(record *ParentNoPtr) (updated bool, err error)

+ func (s *ParentNoPtrStore) SetGenericStore(store *kallax.Store)

+ func (s *ParentNoPtrStore) Transaction(callback func(*ParentNoPtrStore) error) error

+ func (s *ParentNoPtrStore) Update(record *ParentNoPtr, cols ...kallax.SchemaField) (updated int64, err error)

v1.2.8

Jun 13, 2017

Changes in this version

+ type Child struct

+ ID int64

+ Name string

+ func NewChild() (record *Child)

+ func (r *Child) ColumnAddress(col string) (interface{}, error)

+ func (r *Child) GetID() kallax.Identifier

+ func (r *Child) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Child) SetRelationship(field string, rel interface{}) error

+ func (r *Child) Value(col string) (interface{}, error)

+ type ChildQuery struct

+ func NewChildQuery() *ChildQuery

+ func (q *ChildQuery) BatchSize(size uint64) *ChildQuery

+ func (q *ChildQuery) Copy() *ChildQuery

+ func (q *ChildQuery) FindByID(v ...int64) *ChildQuery

+ func (q *ChildQuery) FindByName(v string) *ChildQuery

+ func (q *ChildQuery) Limit(n uint64) *ChildQuery

+ func (q *ChildQuery) Offset(n uint64) *ChildQuery

+ func (q *ChildQuery) Order(cols ...kallax.ColumnOrder) *ChildQuery

+ func (q *ChildQuery) Select(columns ...kallax.SchemaField) *ChildQuery

+ func (q *ChildQuery) SelectNot(columns ...kallax.SchemaField) *ChildQuery

+ func (q *ChildQuery) Where(cond kallax.Condition) *ChildQuery

+ type ChildResultSet struct

+ ResultSet kallax.ResultSet

+ func NewChildResultSet(rs kallax.ResultSet) *ChildResultSet

+ func (rs *ChildResultSet) All() ([]*Child, error)

+ func (rs *ChildResultSet) Close() error

+ func (rs *ChildResultSet) Err() error

+ func (rs *ChildResultSet) ForEach(fn func(*Child) error) error

+ func (rs *ChildResultSet) Get() (*Child, error)

+ func (rs *ChildResultSet) Next() bool

+ func (rs *ChildResultSet) One() (*Child, error)

+ type ChildStore struct

+ func NewChildStore(db *sql.DB) *ChildStore

+ func (s *ChildStore) Count(q *ChildQuery) (int64, error)

+ func (s *ChildStore) Debug() *ChildStore

+ func (s *ChildStore) DebugWith(logger kallax.LoggerFunc) *ChildStore

+ func (s *ChildStore) Delete(record *Child) error

+ func (s *ChildStore) Find(q *ChildQuery) (*ChildResultSet, error)

+ func (s *ChildStore) FindAll(q *ChildQuery) ([]*Child, error)

+ func (s *ChildStore) FindOne(q *ChildQuery) (*Child, error)

+ func (s *ChildStore) GenericStore() *kallax.Store

+ func (s *ChildStore) Insert(record *Child) error

+ func (s *ChildStore) MustCount(q *ChildQuery) int64

+ func (s *ChildStore) MustFind(q *ChildQuery) *ChildResultSet

+ func (s *ChildStore) MustFindOne(q *ChildQuery) *Child

+ func (s *ChildStore) Reload(record *Child) error

+ func (s *ChildStore) Save(record *Child) (updated bool, err error)

+ func (s *ChildStore) SetGenericStore(store *kallax.Store)

+ func (s *ChildStore) Transaction(callback func(*ChildStore) error) error

+ func (s *ChildStore) Update(record *Child, cols ...kallax.SchemaField) (updated int64, err error)

+ type Parent struct

+ Children []*Child

+ ID int64

+ Name string

+ func NewParent() (record *Parent)

+ func (r *Parent) ColumnAddress(col string) (interface{}, error)

+ func (r *Parent) GetID() kallax.Identifier

+ func (r *Parent) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Parent) SetRelationship(field string, rel interface{}) error

+ func (r *Parent) Value(col string) (interface{}, error)

+ type ParentQuery struct

+ func NewParentQuery() *ParentQuery

+ func (q *ParentQuery) BatchSize(size uint64) *ParentQuery

+ func (q *ParentQuery) Copy() *ParentQuery

+ func (q *ParentQuery) FindByID(v ...int64) *ParentQuery

+ func (q *ParentQuery) FindByName(v string) *ParentQuery

+ func (q *ParentQuery) Limit(n uint64) *ParentQuery

+ func (q *ParentQuery) Offset(n uint64) *ParentQuery

+ func (q *ParentQuery) Order(cols ...kallax.ColumnOrder) *ParentQuery

+ func (q *ParentQuery) Select(columns ...kallax.SchemaField) *ParentQuery

+ func (q *ParentQuery) SelectNot(columns ...kallax.SchemaField) *ParentQuery

+ func (q *ParentQuery) Where(cond kallax.Condition) *ParentQuery

+ func (q *ParentQuery) WithChildren(cond kallax.Condition) *ParentQuery

+ type ParentResultSet struct

+ ResultSet kallax.ResultSet

+ func NewParentResultSet(rs kallax.ResultSet) *ParentResultSet

+ func (rs *ParentResultSet) All() ([]*Parent, error)

+ func (rs *ParentResultSet) Close() error

+ func (rs *ParentResultSet) Err() error

+ func (rs *ParentResultSet) ForEach(fn func(*Parent) error) error

+ func (rs *ParentResultSet) Get() (*Parent, error)

+ func (rs *ParentResultSet) Next() bool

+ func (rs *ParentResultSet) One() (*Parent, error)

+ type ParentStore struct

+ func NewParentStore(db *sql.DB) *ParentStore

+ func (s *ParentStore) Count(q *ParentQuery) (int64, error)

+ func (s *ParentStore) Debug() *ParentStore

+ func (s *ParentStore) DebugWith(logger kallax.LoggerFunc) *ParentStore

+ func (s *ParentStore) Delete(record *Parent) error

+ func (s *ParentStore) Find(q *ParentQuery) (*ParentResultSet, error)

+ func (s *ParentStore) FindAll(q *ParentQuery) ([]*Parent, error)

+ func (s *ParentStore) FindOne(q *ParentQuery) (*Parent, error)

+ func (s *ParentStore) GenericStore() *kallax.Store

+ func (s *ParentStore) Insert(record *Parent) error

+ func (s *ParentStore) MustCount(q *ParentQuery) int64

+ func (s *ParentStore) MustFind(q *ParentQuery) *ParentResultSet

+ func (s *ParentStore) MustFindOne(q *ParentQuery) *Parent

+ func (s *ParentStore) Reload(record *Parent) error

+ func (s *ParentStore) RemoveChildren(record *Parent, deleted ...*Child) error

+ func (s *ParentStore) Save(record *Parent) (updated bool, err error)

+ func (s *ParentStore) SetGenericStore(store *kallax.Store)

+ func (s *ParentStore) Transaction(callback func(*ParentStore) error) error

+ func (s *ParentStore) Update(record *Parent, cols ...kallax.SchemaField) (updated int64, err error)

v1.2.7

Jun 7, 2017

v1.2.6

Jun 7, 2017

v1.2.5

May 24, 2017

v1.2.4

May 16, 2017

v1.2.3

May 16, 2017

v1.2.2

May 15, 2017

v1.2.1

May 9, 2017

Changes in this version

type CarStore

+ func (s *CarStore) FindAll(q *CarQuery) ([]*Car, error)

type EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) FindAll(q *EventsAllFixtureQuery) ([]*EventsAllFixture, error)

type EventsFixtureStore

+ func (s *EventsFixtureStore) FindAll(q *EventsFixtureQuery) ([]*EventsFixture, error)

type EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) FindAll(q *EventsSaveFixtureQuery) ([]*EventsSaveFixture, error)

type JSONModelStore

+ func (s *JSONModelStore) FindAll(q *JSONModelQuery) ([]*JSONModel, error)

type MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) FindAll(q *MultiKeySortFixtureQuery) ([]*MultiKeySortFixture, error)

type NullableStore

+ func (s *NullableStore) FindAll(q *NullableQuery) ([]*Nullable, error)

type PersonStore

+ func (s *PersonStore) FindAll(q *PersonQuery) ([]*Person, error)

type PetStore

+ func (s *PetStore) FindAll(q *PetQuery) ([]*Pet, error)

type QueryFixtureStore

+ func (s *QueryFixtureStore) FindAll(q *QueryFixtureQuery) ([]*QueryFixture, error)

type QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) FindAll(q *QueryRelationFixtureQuery) ([]*QueryRelationFixture, error)

type ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) FindAll(q *ResultSetFixtureQuery) ([]*ResultSetFixture, error)

type SchemaFixtureStore

+ func (s *SchemaFixtureStore) FindAll(q *SchemaFixtureQuery) ([]*SchemaFixture, error)

type SchemaRelationshipFixtureStore

+ func (s *SchemaRelationshipFixtureStore) FindAll(q *SchemaRelationshipFixtureQuery) ([]*SchemaRelationshipFixture, error)

type StoreFixtureStore

+ func (s *StoreFixtureStore) FindAll(q *StoreFixtureQuery) ([]*StoreFixture, error)

type StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) FindAll(q *StoreWithConstructFixtureQuery) ([]*StoreWithConstructFixture, error)

type StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) FindAll(q *StoreWithNewFixtureQuery) ([]*StoreWithNewFixture, error)

v1.2.0

May 8, 2017

v1.1.4

May 3, 2017

Changes in this version

type CarStore

+ func (s *CarStore) Debug() *CarStore

+ func (s *CarStore) DebugWith(logger kallax.LoggerFunc) *CarStore

type EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) Debug() *EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) DebugWith(logger kallax.LoggerFunc) *EventsAllFixtureStore

type EventsFixtureStore

+ func (s *EventsFixtureStore) Debug() *EventsFixtureStore

+ func (s *EventsFixtureStore) DebugWith(logger kallax.LoggerFunc) *EventsFixtureStore

type EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) Debug() *EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) DebugWith(logger kallax.LoggerFunc) *EventsSaveFixtureStore

type JSONModelStore

+ func (s *JSONModelStore) Debug() *JSONModelStore

+ func (s *JSONModelStore) DebugWith(logger kallax.LoggerFunc) *JSONModelStore

type MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) Debug() *MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) DebugWith(logger kallax.LoggerFunc) *MultiKeySortFixtureStore

type NullableStore

+ func (s *NullableStore) Debug() *NullableStore

+ func (s *NullableStore) DebugWith(logger kallax.LoggerFunc) *NullableStore

type PersonStore

+ func (s *PersonStore) Debug() *PersonStore

+ func (s *PersonStore) DebugWith(logger kallax.LoggerFunc) *PersonStore

type PetStore

+ func (s *PetStore) Debug() *PetStore

+ func (s *PetStore) DebugWith(logger kallax.LoggerFunc) *PetStore

type QueryFixtureStore

+ func (s *QueryFixtureStore) Debug() *QueryFixtureStore

+ func (s *QueryFixtureStore) DebugWith(logger kallax.LoggerFunc) *QueryFixtureStore

type QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) Debug() *QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) DebugWith(logger kallax.LoggerFunc) *QueryRelationFixtureStore

type ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) Debug() *ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) DebugWith(logger kallax.LoggerFunc) *ResultSetFixtureStore

type SchemaFixtureStore

+ func (s *SchemaFixtureStore) Debug() *SchemaFixtureStore

+ func (s *SchemaFixtureStore) DebugWith(logger kallax.LoggerFunc) *SchemaFixtureStore

type SchemaRelationshipFixtureStore

+ func (s *SchemaRelationshipFixtureStore) Debug() *SchemaRelationshipFixtureStore

+ func (s *SchemaRelationshipFixtureStore) DebugWith(logger kallax.LoggerFunc) *SchemaRelationshipFixtureStore

type StoreFixtureStore

+ func (s *StoreFixtureStore) Debug() *StoreFixtureStore

+ func (s *StoreFixtureStore) DebugWith(logger kallax.LoggerFunc) *StoreFixtureStore

type StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) Debug() *StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) DebugWith(logger kallax.LoggerFunc) *StoreWithConstructFixtureStore

type StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) Debug() *StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) DebugWith(logger kallax.LoggerFunc) *StoreWithNewFixtureStore

v1.1.3

May 3, 2017

v1.1.2

Apr 26, 2017

v1.1.1

Apr 23, 2017

v1.1.0

Apr 20, 2017

Changes in this version

type CarQuery

+ func (q *CarQuery) FindByOwner(v int64) *CarQuery

type CarStore

+ func (s *CarStore) GenericStore() *kallax.Store

+ func (s *CarStore) SetGenericStore(store *kallax.Store)

type EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) GenericStore() *kallax.Store

+ func (s *EventsAllFixtureStore) SetGenericStore(store *kallax.Store)

type EventsFixtureStore

+ func (s *EventsFixtureStore) GenericStore() *kallax.Store

+ func (s *EventsFixtureStore) SetGenericStore(store *kallax.Store)

type EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) GenericStore() *kallax.Store

+ func (s *EventsSaveFixtureStore) SetGenericStore(store *kallax.Store)

type JSONModelStore

+ func (s *JSONModelStore) GenericStore() *kallax.Store

+ func (s *JSONModelStore) SetGenericStore(store *kallax.Store)

type MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) GenericStore() *kallax.Store

+ func (s *MultiKeySortFixtureStore) SetGenericStore(store *kallax.Store)

type NullableStore

+ func (s *NullableStore) GenericStore() *kallax.Store

+ func (s *NullableStore) SetGenericStore(store *kallax.Store)

type PersonStore

+ func (s *PersonStore) GenericStore() *kallax.Store

+ func (s *PersonStore) SetGenericStore(store *kallax.Store)

type PetQuery

+ func (q *PetQuery) FindByOwner(v int64) *PetQuery

type PetStore

+ func (s *PetStore) GenericStore() *kallax.Store

+ func (s *PetStore) SetGenericStore(store *kallax.Store)

type QueryFixture

+ Inverse *QueryRelationFixture

type QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByInverse(v kallax.ULID) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) WithInverse() *QueryFixtureQuery

type QueryFixtureStore

+ func (s *QueryFixtureStore) GenericStore() *kallax.Store

+ func (s *QueryFixtureStore) SetGenericStore(store *kallax.Store)

type QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) FindByOwner(v kallax.ULID) *QueryRelationFixtureQuery

type QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) GenericStore() *kallax.Store

+ func (s *QueryRelationFixtureStore) SetGenericStore(store *kallax.Store)

type ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) GenericStore() *kallax.Store

+ func (s *ResultSetFixtureStore) SetGenericStore(store *kallax.Store)

type SchemaFixture

+ Inverse *SchemaRelationshipFixture

type SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) FindByInverse(v kallax.ULID) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) WithInverse() *SchemaFixtureQuery

type SchemaFixtureStore

+ func (s *SchemaFixtureStore) GenericStore() *kallax.Store

+ func (s *SchemaFixtureStore) SetGenericStore(store *kallax.Store)

+ type SchemaRelationshipFixture struct

+ ID kallax.ULID

+ func NewSchemaRelationshipFixture() (record *SchemaRelationshipFixture)

+ func (r *SchemaRelationshipFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *SchemaRelationshipFixture) GetID() kallax.Identifier

+ func (r *SchemaRelationshipFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *SchemaRelationshipFixture) SetRelationship(field string, rel interface{}) error

+ func (r *SchemaRelationshipFixture) Value(col string) (interface{}, error)

+ type SchemaRelationshipFixtureQuery struct

+ func NewSchemaRelationshipFixtureQuery() *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) BatchSize(size uint64) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Copy() *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) FindByID(v ...kallax.ULID) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Limit(n uint64) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Offset(n uint64) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Order(cols ...kallax.ColumnOrder) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Select(columns ...kallax.SchemaField) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) SelectNot(columns ...kallax.SchemaField) *SchemaRelationshipFixtureQuery

+ func (q *SchemaRelationshipFixtureQuery) Where(cond kallax.Condition) *SchemaRelationshipFixtureQuery

+ type SchemaRelationshipFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewSchemaRelationshipFixtureResultSet(rs kallax.ResultSet) *SchemaRelationshipFixtureResultSet

+ func (rs *SchemaRelationshipFixtureResultSet) All() ([]*SchemaRelationshipFixture, error)

+ func (rs *SchemaRelationshipFixtureResultSet) Close() error

+ func (rs *SchemaRelationshipFixtureResultSet) Err() error

+ func (rs *SchemaRelationshipFixtureResultSet) ForEach(fn func(*SchemaRelationshipFixture) error) error

+ func (rs *SchemaRelationshipFixtureResultSet) Get() (*SchemaRelationshipFixture, error)

+ func (rs *SchemaRelationshipFixtureResultSet) Next() bool

+ func (rs *SchemaRelationshipFixtureResultSet) One() (*SchemaRelationshipFixture, error)

+ type SchemaRelationshipFixtureStore struct

+ func NewSchemaRelationshipFixtureStore(db *sql.DB) *SchemaRelationshipFixtureStore

+ func (s *SchemaRelationshipFixtureStore) Count(q *SchemaRelationshipFixtureQuery) (int64, error)

+ func (s *SchemaRelationshipFixtureStore) Delete(record *SchemaRelationshipFixture) error

+ func (s *SchemaRelationshipFixtureStore) Find(q *SchemaRelationshipFixtureQuery) (*SchemaRelationshipFixtureResultSet, error)

+ func (s *SchemaRelationshipFixtureStore) FindOne(q *SchemaRelationshipFixtureQuery) (*SchemaRelationshipFixture, error)

+ func (s *SchemaRelationshipFixtureStore) GenericStore() *kallax.Store

+ func (s *SchemaRelationshipFixtureStore) Insert(record *SchemaRelationshipFixture) error

+ func (s *SchemaRelationshipFixtureStore) MustCount(q *SchemaRelationshipFixtureQuery) int64

+ func (s *SchemaRelationshipFixtureStore) MustFind(q *SchemaRelationshipFixtureQuery) *SchemaRelationshipFixtureResultSet

+ func (s *SchemaRelationshipFixtureStore) MustFindOne(q *SchemaRelationshipFixtureQuery) *SchemaRelationshipFixture

+ func (s *SchemaRelationshipFixtureStore) Reload(record *SchemaRelationshipFixture) error

+ func (s *SchemaRelationshipFixtureStore) Save(record *SchemaRelationshipFixture) (updated bool, err error)

+ func (s *SchemaRelationshipFixtureStore) SetGenericStore(store *kallax.Store)

+ func (s *SchemaRelationshipFixtureStore) Transaction(callback func(*SchemaRelationshipFixtureStore) error) error

+ func (s *SchemaRelationshipFixtureStore) Update(record *SchemaRelationshipFixture, cols ...kallax.SchemaField) (updated int64, err error)

type StoreFixtureStore

+ func (s *StoreFixtureStore) GenericStore() *kallax.Store

+ func (s *StoreFixtureStore) SetGenericStore(store *kallax.Store)

type StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) GenericStore() *kallax.Store

+ func (s *StoreWithConstructFixtureStore) SetGenericStore(store *kallax.Store)

type StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) GenericStore() *kallax.Store

+ func (s *StoreWithNewFixtureStore) SetGenericStore(store *kallax.Store)

v1.0.5

Apr 11, 2017

v1.0.4

Apr 3, 2017

v1.0.3

Apr 3, 2017

v1.0.2

Mar 21, 2017

v1.0.1

Feb 27, 2017

v1.0.0

Feb 22, 2017

Changes in this version

+ var Schema = &schema

+ type AliasHereArray [3]string

+ type AliasHereString string

+ type AliasID kallax.ULID

+ type AliasSliceString []string

+ type Bar struct

+ Mux string

+ Qux []Qux

+ type Baz struct

+ Mux string

+ type Car struct

+ ID kallax.ULID

+ ModelName string

+ Owner *Person

+ func NewCar(model string, owner *Person) (record *Car)

+ func (c *Car) AfterDelete() error

+ func (c *Car) AfterSave() error

+ func (c *Car) BeforeDelete() error

+ func (c *Car) BeforeSave() error

+ func (r *Car) ColumnAddress(col string) (interface{}, error)

+ func (r *Car) GetID() kallax.Identifier

+ func (r *Car) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Car) SetRelationship(field string, rel interface{}) error

+ func (r *Car) Value(col string) (interface{}, error)

+ type CarQuery struct

+ func NewCarQuery() *CarQuery

+ func (q *CarQuery) BatchSize(size uint64) *CarQuery

+ func (q *CarQuery) Copy() *CarQuery

+ func (q *CarQuery) FindByID(v ...kallax.ULID) *CarQuery

+ func (q *CarQuery) FindByModelName(v string) *CarQuery

+ func (q *CarQuery) Limit(n uint64) *CarQuery

+ func (q *CarQuery) Offset(n uint64) *CarQuery

+ func (q *CarQuery) Order(cols ...kallax.ColumnOrder) *CarQuery

+ func (q *CarQuery) Select(columns ...kallax.SchemaField) *CarQuery

+ func (q *CarQuery) SelectNot(columns ...kallax.SchemaField) *CarQuery

+ func (q *CarQuery) Where(cond kallax.Condition) *CarQuery

+ func (q *CarQuery) WithOwner() *CarQuery

+ type CarResultSet struct

+ ResultSet kallax.ResultSet

+ func NewCarResultSet(rs kallax.ResultSet) *CarResultSet

+ func (rs *CarResultSet) All() ([]*Car, error)

+ func (rs *CarResultSet) Close() error

+ func (rs *CarResultSet) Err() error

+ func (rs *CarResultSet) ForEach(fn func(*Car) error) error

+ func (rs *CarResultSet) Get() (*Car, error)

+ func (rs *CarResultSet) Next() bool

+ func (rs *CarResultSet) One() (*Car, error)

+ type CarStore struct

+ func NewCarStore(db *sql.DB) *CarStore

+ func (s *CarStore) Count(q *CarQuery) (int64, error)

+ func (s *CarStore) Delete(record *Car) error

+ func (s *CarStore) Find(q *CarQuery) (*CarResultSet, error)

+ func (s *CarStore) FindOne(q *CarQuery) (*Car, error)

+ func (s *CarStore) Insert(record *Car) error

+ func (s *CarStore) MustCount(q *CarQuery) int64

+ func (s *CarStore) MustFind(q *CarQuery) *CarResultSet

+ func (s *CarStore) MustFindOne(q *CarQuery) *Car

+ func (s *CarStore) Reload(record *Car) error

+ func (s *CarStore) Save(record *Car) (updated bool, err error)

+ func (s *CarStore) Transaction(callback func(*CarStore) error) error

+ func (s *CarStore) Update(record *Car, cols ...kallax.SchemaField) (updated int64, err error)

+ type EventsAllFixture struct

+ Checks map[string]bool

+ ID kallax.ULID

+ MustFailAfter error

+ MustFailBefore error

+ func NewEventsAllFixture() (record *EventsAllFixture)

+ func (r *EventsAllFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *EventsAllFixture) GetID() kallax.Identifier

+ func (r *EventsAllFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *EventsAllFixture) SetRelationship(field string, rel interface{}) error

+ func (r *EventsAllFixture) Value(col string) (interface{}, error)

+ func (s *EventsAllFixture) AfterInsert() error

+ func (s *EventsAllFixture) AfterSave() error

+ func (s *EventsAllFixture) AfterUpdate() error

+ func (s *EventsAllFixture) BeforeInsert() error

+ func (s *EventsAllFixture) BeforeSave() error

+ func (s *EventsAllFixture) BeforeUpdate() error

+ type EventsAllFixtureQuery struct

+ func NewEventsAllFixtureQuery() *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) BatchSize(size uint64) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Copy() *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) FindByID(v ...kallax.ULID) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Limit(n uint64) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Offset(n uint64) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Order(cols ...kallax.ColumnOrder) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Select(columns ...kallax.SchemaField) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) SelectNot(columns ...kallax.SchemaField) *EventsAllFixtureQuery

+ func (q *EventsAllFixtureQuery) Where(cond kallax.Condition) *EventsAllFixtureQuery

+ type EventsAllFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewEventsAllFixtureResultSet(rs kallax.ResultSet) *EventsAllFixtureResultSet

+ func (rs *EventsAllFixtureResultSet) All() ([]*EventsAllFixture, error)

+ func (rs *EventsAllFixtureResultSet) Close() error

+ func (rs *EventsAllFixtureResultSet) Err() error

+ func (rs *EventsAllFixtureResultSet) ForEach(fn func(*EventsAllFixture) error) error

+ func (rs *EventsAllFixtureResultSet) Get() (*EventsAllFixture, error)

+ func (rs *EventsAllFixtureResultSet) Next() bool

+ func (rs *EventsAllFixtureResultSet) One() (*EventsAllFixture, error)

+ type EventsAllFixtureStore struct

+ func NewEventsAllFixtureStore(db *sql.DB) *EventsAllFixtureStore

+ func (s *EventsAllFixtureStore) Count(q *EventsAllFixtureQuery) (int64, error)

+ func (s *EventsAllFixtureStore) Delete(record *EventsAllFixture) error

+ func (s *EventsAllFixtureStore) Find(q *EventsAllFixtureQuery) (*EventsAllFixtureResultSet, error)

+ func (s *EventsAllFixtureStore) FindOne(q *EventsAllFixtureQuery) (*EventsAllFixture, error)

+ func (s *EventsAllFixtureStore) Insert(record *EventsAllFixture) error

+ func (s *EventsAllFixtureStore) MustCount(q *EventsAllFixtureQuery) int64

+ func (s *EventsAllFixtureStore) MustFind(q *EventsAllFixtureQuery) *EventsAllFixtureResultSet

+ func (s *EventsAllFixtureStore) MustFindOne(q *EventsAllFixtureQuery) *EventsAllFixture

+ func (s *EventsAllFixtureStore) Reload(record *EventsAllFixture) error

+ func (s *EventsAllFixtureStore) Save(record *EventsAllFixture) (updated bool, err error)

+ func (s *EventsAllFixtureStore) Transaction(callback func(*EventsAllFixtureStore) error) error

+ func (s *EventsAllFixtureStore) Update(record *EventsAllFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type EventsFixture struct

+ Checks map[string]bool

+ ID kallax.ULID

+ MustFailAfter error

+ MustFailBefore error

+ func NewEventsFixture() (record *EventsFixture)

+ func (r *EventsFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *EventsFixture) GetID() kallax.Identifier

+ func (r *EventsFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *EventsFixture) SetRelationship(field string, rel interface{}) error

+ func (r *EventsFixture) Value(col string) (interface{}, error)

+ func (s *EventsFixture) AfterInsert() error

+ func (s *EventsFixture) AfterUpdate() error

+ func (s *EventsFixture) BeforeInsert() error

+ func (s *EventsFixture) BeforeUpdate() error

+ type EventsFixtureQuery struct

+ func NewEventsFixtureQuery() *EventsFixtureQuery

+ func (q *EventsFixtureQuery) BatchSize(size uint64) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Copy() *EventsFixtureQuery

+ func (q *EventsFixtureQuery) FindByID(v ...kallax.ULID) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Limit(n uint64) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Offset(n uint64) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Order(cols ...kallax.ColumnOrder) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Select(columns ...kallax.SchemaField) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) SelectNot(columns ...kallax.SchemaField) *EventsFixtureQuery

+ func (q *EventsFixtureQuery) Where(cond kallax.Condition) *EventsFixtureQuery

+ type EventsFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewEventsFixtureResultSet(rs kallax.ResultSet) *EventsFixtureResultSet

+ func (rs *EventsFixtureResultSet) All() ([]*EventsFixture, error)

+ func (rs *EventsFixtureResultSet) Close() error

+ func (rs *EventsFixtureResultSet) Err() error

+ func (rs *EventsFixtureResultSet) ForEach(fn func(*EventsFixture) error) error

+ func (rs *EventsFixtureResultSet) Get() (*EventsFixture, error)

+ func (rs *EventsFixtureResultSet) Next() bool

+ func (rs *EventsFixtureResultSet) One() (*EventsFixture, error)

+ type EventsFixtureStore struct

+ func NewEventsFixtureStore(db *sql.DB) *EventsFixtureStore

+ func (s *EventsFixtureStore) Count(q *EventsFixtureQuery) (int64, error)

+ func (s *EventsFixtureStore) Delete(record *EventsFixture) error

+ func (s *EventsFixtureStore) Find(q *EventsFixtureQuery) (*EventsFixtureResultSet, error)

+ func (s *EventsFixtureStore) FindOne(q *EventsFixtureQuery) (*EventsFixture, error)

+ func (s *EventsFixtureStore) Insert(record *EventsFixture) error

+ func (s *EventsFixtureStore) MustCount(q *EventsFixtureQuery) int64

+ func (s *EventsFixtureStore) MustFind(q *EventsFixtureQuery) *EventsFixtureResultSet

+ func (s *EventsFixtureStore) MustFindOne(q *EventsFixtureQuery) *EventsFixture

+ func (s *EventsFixtureStore) Reload(record *EventsFixture) error

+ func (s *EventsFixtureStore) Save(record *EventsFixture) (updated bool, err error)

+ func (s *EventsFixtureStore) Transaction(callback func(*EventsFixtureStore) error) error

+ func (s *EventsFixtureStore) Update(record *EventsFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type EventsSaveFixture struct

+ Checks map[string]bool

+ ID kallax.ULID

+ MustFailAfter error

+ MustFailBefore error

+ func NewEventsSaveFixture() (record *EventsSaveFixture)

+ func (r *EventsSaveFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *EventsSaveFixture) GetID() kallax.Identifier

+ func (r *EventsSaveFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *EventsSaveFixture) SetRelationship(field string, rel interface{}) error

+ func (r *EventsSaveFixture) Value(col string) (interface{}, error)

+ func (s *EventsSaveFixture) AfterSave() error

+ func (s *EventsSaveFixture) BeforeSave() error

+ type EventsSaveFixtureQuery struct

+ func NewEventsSaveFixtureQuery() *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) BatchSize(size uint64) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Copy() *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) FindByID(v ...kallax.ULID) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Limit(n uint64) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Offset(n uint64) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Order(cols ...kallax.ColumnOrder) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Select(columns ...kallax.SchemaField) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) SelectNot(columns ...kallax.SchemaField) *EventsSaveFixtureQuery

+ func (q *EventsSaveFixtureQuery) Where(cond kallax.Condition) *EventsSaveFixtureQuery

+ type EventsSaveFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewEventsSaveFixtureResultSet(rs kallax.ResultSet) *EventsSaveFixtureResultSet

+ func (rs *EventsSaveFixtureResultSet) All() ([]*EventsSaveFixture, error)

+ func (rs *EventsSaveFixtureResultSet) Close() error

+ func (rs *EventsSaveFixtureResultSet) Err() error

+ func (rs *EventsSaveFixtureResultSet) ForEach(fn func(*EventsSaveFixture) error) error

+ func (rs *EventsSaveFixtureResultSet) Get() (*EventsSaveFixture, error)

+ func (rs *EventsSaveFixtureResultSet) Next() bool

+ func (rs *EventsSaveFixtureResultSet) One() (*EventsSaveFixture, error)

+ type EventsSaveFixtureStore struct

+ func NewEventsSaveFixtureStore(db *sql.DB) *EventsSaveFixtureStore

+ func (s *EventsSaveFixtureStore) Count(q *EventsSaveFixtureQuery) (int64, error)

+ func (s *EventsSaveFixtureStore) Delete(record *EventsSaveFixture) error

+ func (s *EventsSaveFixtureStore) Find(q *EventsSaveFixtureQuery) (*EventsSaveFixtureResultSet, error)

+ func (s *EventsSaveFixtureStore) FindOne(q *EventsSaveFixtureQuery) (*EventsSaveFixture, error)

+ func (s *EventsSaveFixtureStore) Insert(record *EventsSaveFixture) error

+ func (s *EventsSaveFixtureStore) MustCount(q *EventsSaveFixtureQuery) int64

+ func (s *EventsSaveFixtureStore) MustFind(q *EventsSaveFixtureQuery) *EventsSaveFixtureResultSet

+ func (s *EventsSaveFixtureStore) MustFindOne(q *EventsSaveFixtureQuery) *EventsSaveFixture

+ func (s *EventsSaveFixtureStore) Reload(record *EventsSaveFixture) error

+ func (s *EventsSaveFixtureStore) Save(record *EventsSaveFixture) (updated bool, err error)

+ func (s *EventsSaveFixtureStore) Transaction(callback func(*EventsSaveFixtureStore) error) error

+ func (s *EventsSaveFixtureStore) Update(record *EventsSaveFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type JSONModel struct

+ Bar *Bar

+ Baz map[string]interface{}

+ BazSlice []Baz

+ Foo string

+ ID kallax.ULID

+ func NewJSONModel() (record *JSONModel)

+ func (r *JSONModel) ColumnAddress(col string) (interface{}, error)

+ func (r *JSONModel) GetID() kallax.Identifier

+ func (r *JSONModel) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *JSONModel) SetRelationship(field string, rel interface{}) error

+ func (r *JSONModel) Value(col string) (interface{}, error)

+ type JSONModelQuery struct

+ func NewJSONModelQuery() *JSONModelQuery

+ func (q *JSONModelQuery) BatchSize(size uint64) *JSONModelQuery

+ func (q *JSONModelQuery) Copy() *JSONModelQuery

+ func (q *JSONModelQuery) FindByFoo(v string) *JSONModelQuery

+ func (q *JSONModelQuery) FindByID(v ...kallax.ULID) *JSONModelQuery

+ func (q *JSONModelQuery) Limit(n uint64) *JSONModelQuery

+ func (q *JSONModelQuery) Offset(n uint64) *JSONModelQuery

+ func (q *JSONModelQuery) Order(cols ...kallax.ColumnOrder) *JSONModelQuery

+ func (q *JSONModelQuery) Select(columns ...kallax.SchemaField) *JSONModelQuery

+ func (q *JSONModelQuery) SelectNot(columns ...kallax.SchemaField) *JSONModelQuery

+ func (q *JSONModelQuery) Where(cond kallax.Condition) *JSONModelQuery

+ type JSONModelResultSet struct

+ ResultSet kallax.ResultSet

+ func NewJSONModelResultSet(rs kallax.ResultSet) *JSONModelResultSet

+ func (rs *JSONModelResultSet) All() ([]*JSONModel, error)

+ func (rs *JSONModelResultSet) Close() error

+ func (rs *JSONModelResultSet) Err() error

+ func (rs *JSONModelResultSet) ForEach(fn func(*JSONModel) error) error

+ func (rs *JSONModelResultSet) Get() (*JSONModel, error)

+ func (rs *JSONModelResultSet) Next() bool

+ func (rs *JSONModelResultSet) One() (*JSONModel, error)

+ type JSONModelStore struct

+ func NewJSONModelStore(db *sql.DB) *JSONModelStore

+ func (s *JSONModelStore) Count(q *JSONModelQuery) (int64, error)

+ func (s *JSONModelStore) Delete(record *JSONModel) error

+ func (s *JSONModelStore) Find(q *JSONModelQuery) (*JSONModelResultSet, error)

+ func (s *JSONModelStore) FindOne(q *JSONModelQuery) (*JSONModel, error)

+ func (s *JSONModelStore) Insert(record *JSONModel) error

+ func (s *JSONModelStore) MustCount(q *JSONModelQuery) int64

+ func (s *JSONModelStore) MustFind(q *JSONModelQuery) *JSONModelResultSet

+ func (s *JSONModelStore) MustFindOne(q *JSONModelQuery) *JSONModel

+ func (s *JSONModelStore) Reload(record *JSONModel) error

+ func (s *JSONModelStore) Save(record *JSONModel) (updated bool, err error)

+ func (s *JSONModelStore) Transaction(callback func(*JSONModelStore) error) error

+ func (s *JSONModelStore) Update(record *JSONModel, cols ...kallax.SchemaField) (updated int64, err error)

+ type MultiKeySortFixture struct

+ End time.Time

+ ID kallax.ULID

+ Name string

+ Start time.Time

+ func NewMultiKeySortFixture() (record *MultiKeySortFixture)

+ func (r *MultiKeySortFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *MultiKeySortFixture) GetID() kallax.Identifier

+ func (r *MultiKeySortFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *MultiKeySortFixture) SetRelationship(field string, rel interface{}) error

+ func (r *MultiKeySortFixture) Value(col string) (interface{}, error)

+ type MultiKeySortFixtureQuery struct

+ func NewMultiKeySortFixtureQuery() *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) BatchSize(size uint64) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Copy() *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) FindByEnd(cond kallax.ScalarCond, v time.Time) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) FindByID(v ...kallax.ULID) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) FindByName(v string) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) FindByStart(cond kallax.ScalarCond, v time.Time) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Limit(n uint64) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Offset(n uint64) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Order(cols ...kallax.ColumnOrder) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Select(columns ...kallax.SchemaField) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) SelectNot(columns ...kallax.SchemaField) *MultiKeySortFixtureQuery

+ func (q *MultiKeySortFixtureQuery) Where(cond kallax.Condition) *MultiKeySortFixtureQuery

+ type MultiKeySortFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewMultiKeySortFixtureResultSet(rs kallax.ResultSet) *MultiKeySortFixtureResultSet

+ func (rs *MultiKeySortFixtureResultSet) All() ([]*MultiKeySortFixture, error)

+ func (rs *MultiKeySortFixtureResultSet) Close() error

+ func (rs *MultiKeySortFixtureResultSet) Err() error

+ func (rs *MultiKeySortFixtureResultSet) ForEach(fn func(*MultiKeySortFixture) error) error

+ func (rs *MultiKeySortFixtureResultSet) Get() (*MultiKeySortFixture, error)

+ func (rs *MultiKeySortFixtureResultSet) Next() bool

+ func (rs *MultiKeySortFixtureResultSet) One() (*MultiKeySortFixture, error)

+ type MultiKeySortFixtureStore struct

+ func NewMultiKeySortFixtureStore(db *sql.DB) *MultiKeySortFixtureStore

+ func (s *MultiKeySortFixtureStore) Count(q *MultiKeySortFixtureQuery) (int64, error)

+ func (s *MultiKeySortFixtureStore) Delete(record *MultiKeySortFixture) error

+ func (s *MultiKeySortFixtureStore) Find(q *MultiKeySortFixtureQuery) (*MultiKeySortFixtureResultSet, error)

+ func (s *MultiKeySortFixtureStore) FindOne(q *MultiKeySortFixtureQuery) (*MultiKeySortFixture, error)

+ func (s *MultiKeySortFixtureStore) Insert(record *MultiKeySortFixture) error

+ func (s *MultiKeySortFixtureStore) MustCount(q *MultiKeySortFixtureQuery) int64

+ func (s *MultiKeySortFixtureStore) MustFind(q *MultiKeySortFixtureQuery) *MultiKeySortFixtureResultSet

+ func (s *MultiKeySortFixtureStore) MustFindOne(q *MultiKeySortFixtureQuery) *MultiKeySortFixture

+ func (s *MultiKeySortFixtureStore) Reload(record *MultiKeySortFixture) error

+ func (s *MultiKeySortFixtureStore) Save(record *MultiKeySortFixture) (updated bool, err error)

+ func (s *MultiKeySortFixtureStore) Transaction(callback func(*MultiKeySortFixtureStore) error) error

+ func (s *MultiKeySortFixtureStore) Update(record *MultiKeySortFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type Nullable struct

+ ID int64

+ Scanner *kallax.ULID

+ SomeJSON *SomeJSON

+ T *time.Time

+ func NewNullable() (record *Nullable)

+ func (r *Nullable) ColumnAddress(col string) (interface{}, error)

+ func (r *Nullable) GetID() kallax.Identifier

+ func (r *Nullable) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Nullable) SetRelationship(field string, rel interface{}) error

+ func (r *Nullable) Value(col string) (interface{}, error)

+ type NullableQuery struct

+ func NewNullableQuery() *NullableQuery

+ func (q *NullableQuery) BatchSize(size uint64) *NullableQuery

+ func (q *NullableQuery) Copy() *NullableQuery

+ func (q *NullableQuery) FindByID(v ...int64) *NullableQuery

+ func (q *NullableQuery) FindByScanner(v kallax.ULID) *NullableQuery

+ func (q *NullableQuery) FindByT(cond kallax.ScalarCond, v time.Time) *NullableQuery

+ func (q *NullableQuery) Limit(n uint64) *NullableQuery

+ func (q *NullableQuery) Offset(n uint64) *NullableQuery

+ func (q *NullableQuery) Order(cols ...kallax.ColumnOrder) *NullableQuery

+ func (q *NullableQuery) Select(columns ...kallax.SchemaField) *NullableQuery

+ func (q *NullableQuery) SelectNot(columns ...kallax.SchemaField) *NullableQuery

+ func (q *NullableQuery) Where(cond kallax.Condition) *NullableQuery

+ type NullableResultSet struct

+ ResultSet kallax.ResultSet

+ func NewNullableResultSet(rs kallax.ResultSet) *NullableResultSet

+ func (rs *NullableResultSet) All() ([]*Nullable, error)

+ func (rs *NullableResultSet) Close() error

+ func (rs *NullableResultSet) Err() error

+ func (rs *NullableResultSet) ForEach(fn func(*Nullable) error) error

+ func (rs *NullableResultSet) Get() (*Nullable, error)

+ func (rs *NullableResultSet) Next() bool

+ func (rs *NullableResultSet) One() (*Nullable, error)

+ type NullableStore struct

+ func NewNullableStore(db *sql.DB) *NullableStore

+ func (s *NullableStore) Count(q *NullableQuery) (int64, error)

+ func (s *NullableStore) Delete(record *Nullable) error

+ func (s *NullableStore) Find(q *NullableQuery) (*NullableResultSet, error)

+ func (s *NullableStore) FindOne(q *NullableQuery) (*Nullable, error)

+ func (s *NullableStore) Insert(record *Nullable) error

+ func (s *NullableStore) MustCount(q *NullableQuery) int64

+ func (s *NullableStore) MustFind(q *NullableQuery) *NullableResultSet

+ func (s *NullableStore) MustFindOne(q *NullableQuery) *Nullable

+ func (s *NullableStore) Reload(record *Nullable) error

+ func (s *NullableStore) Save(record *Nullable) (updated bool, err error)

+ func (s *NullableStore) Transaction(callback func(*NullableStore) error) error

+ func (s *NullableStore) Update(record *Nullable, cols ...kallax.SchemaField) (updated int64, err error)

+ type Person struct

+ Car *Car

+ ID int64

+ Name string

+ Pets []*Pet

+ PetsArr [2]*Pet

+ func NewPerson(name string) (record *Person)

+ func (c *Person) AfterDelete() error

+ func (c *Person) AfterSave() error

+ func (c *Person) BeforeDelete() error

+ func (c *Person) BeforeSave() error

+ func (r *Person) ColumnAddress(col string) (interface{}, error)

+ func (r *Person) GetID() kallax.Identifier

+ func (r *Person) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Person) SetRelationship(field string, rel interface{}) error

+ func (r *Person) Value(col string) (interface{}, error)

+ type PersonQuery struct

+ func NewPersonQuery() *PersonQuery

+ func (q *PersonQuery) BatchSize(size uint64) *PersonQuery

+ func (q *PersonQuery) Copy() *PersonQuery

+ func (q *PersonQuery) FindByID(v ...int64) *PersonQuery

+ func (q *PersonQuery) FindByName(v string) *PersonQuery

+ func (q *PersonQuery) Limit(n uint64) *PersonQuery

+ func (q *PersonQuery) Offset(n uint64) *PersonQuery

+ func (q *PersonQuery) Order(cols ...kallax.ColumnOrder) *PersonQuery

+ func (q *PersonQuery) Select(columns ...kallax.SchemaField) *PersonQuery

+ func (q *PersonQuery) SelectNot(columns ...kallax.SchemaField) *PersonQuery

+ func (q *PersonQuery) Where(cond kallax.Condition) *PersonQuery

+ func (q *PersonQuery) WithCar() *PersonQuery

+ func (q *PersonQuery) WithPets(cond kallax.Condition) *PersonQuery

+ type PersonResultSet struct

+ ResultSet kallax.ResultSet

+ func NewPersonResultSet(rs kallax.ResultSet) *PersonResultSet

+ func (rs *PersonResultSet) All() ([]*Person, error)

+ func (rs *PersonResultSet) Close() error

+ func (rs *PersonResultSet) Err() error

+ func (rs *PersonResultSet) ForEach(fn func(*Person) error) error

+ func (rs *PersonResultSet) Get() (*Person, error)

+ func (rs *PersonResultSet) Next() bool

+ func (rs *PersonResultSet) One() (*Person, error)

+ type PersonStore struct

+ func NewPersonStore(db *sql.DB) *PersonStore

+ func (s *PersonStore) Count(q *PersonQuery) (int64, error)

+ func (s *PersonStore) Delete(record *Person) error

+ func (s *PersonStore) Find(q *PersonQuery) (*PersonResultSet, error)

+ func (s *PersonStore) FindOne(q *PersonQuery) (*Person, error)

+ func (s *PersonStore) Insert(record *Person) error

+ func (s *PersonStore) MustCount(q *PersonQuery) int64

+ func (s *PersonStore) MustFind(q *PersonQuery) *PersonResultSet

+ func (s *PersonStore) MustFindOne(q *PersonQuery) *Person

+ func (s *PersonStore) Reload(record *Person) error

+ func (s *PersonStore) RemoveCar(record *Person) error

+ func (s *PersonStore) RemovePets(record *Person, deleted ...*Pet) error

+ func (s *PersonStore) Save(record *Person) (updated bool, err error)

+ func (s *PersonStore) Transaction(callback func(*PersonStore) error) error

+ func (s *PersonStore) Update(record *Person, cols ...kallax.SchemaField) (updated int64, err error)

+ type Pet struct

+ ID kallax.ULID

+ Kind string

+ Name string

+ Owner *Person

+ func NewPet(name string, kind string, owner *Person) (record *Pet)

+ func (c *Pet) AfterDelete() error

+ func (c *Pet) AfterSave() error

+ func (c *Pet) BeforeDelete() error

+ func (c *Pet) BeforeSave() error

+ func (r *Pet) ColumnAddress(col string) (interface{}, error)

+ func (r *Pet) GetID() kallax.Identifier

+ func (r *Pet) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *Pet) SetRelationship(field string, rel interface{}) error

+ func (r *Pet) Value(col string) (interface{}, error)

+ type PetQuery struct

+ func NewPetQuery() *PetQuery

+ func (q *PetQuery) BatchSize(size uint64) *PetQuery

+ func (q *PetQuery) Copy() *PetQuery

+ func (q *PetQuery) FindByID(v ...kallax.ULID) *PetQuery

+ func (q *PetQuery) FindByKind(v string) *PetQuery

+ func (q *PetQuery) FindByName(v string) *PetQuery

+ func (q *PetQuery) Limit(n uint64) *PetQuery

+ func (q *PetQuery) Offset(n uint64) *PetQuery

+ func (q *PetQuery) Order(cols ...kallax.ColumnOrder) *PetQuery

+ func (q *PetQuery) Select(columns ...kallax.SchemaField) *PetQuery

+ func (q *PetQuery) SelectNot(columns ...kallax.SchemaField) *PetQuery

+ func (q *PetQuery) Where(cond kallax.Condition) *PetQuery

+ func (q *PetQuery) WithOwner() *PetQuery

+ type PetResultSet struct

+ ResultSet kallax.ResultSet

+ func NewPetResultSet(rs kallax.ResultSet) *PetResultSet

+ func (rs *PetResultSet) All() ([]*Pet, error)

+ func (rs *PetResultSet) Close() error

+ func (rs *PetResultSet) Err() error

+ func (rs *PetResultSet) ForEach(fn func(*Pet) error) error

+ func (rs *PetResultSet) Get() (*Pet, error)

+ func (rs *PetResultSet) Next() bool

+ func (rs *PetResultSet) One() (*Pet, error)

+ type PetStore struct

+ func NewPetStore(db *sql.DB) *PetStore

+ func (s *PetStore) Count(q *PetQuery) (int64, error)

+ func (s *PetStore) Delete(record *Pet) error

+ func (s *PetStore) Find(q *PetQuery) (*PetResultSet, error)

+ func (s *PetStore) FindOne(q *PetQuery) (*Pet, error)

+ func (s *PetStore) Insert(record *Pet) error

+ func (s *PetStore) MustCount(q *PetQuery) int64

+ func (s *PetStore) MustFind(q *PetQuery) *PetResultSet

+ func (s *PetStore) MustFindOne(q *PetQuery) *Pet

+ func (s *PetStore) Reload(record *Pet) error

+ func (s *PetStore) Save(record *Pet) (updated bool, err error)

+ func (s *PetStore) Transaction(callback func(*PetStore) error) error

+ func (s *PetStore) Update(record *Pet, cols ...kallax.SchemaField) (updated int64, err error)

+ type QueryFixture struct

+ AliasArrAliasStringParam fixtures.AliasArrAliasString

+ AliasArrayParam fixtures.AliasArray

+ AliasDummyParam fixtures.AliasDummyParam

+ AliasHereArrayParam AliasHereArray

+ AliasIntParam fixtures.AliasInt

+ AliasSliceParam fixtures.AliasSlice

+ AliasStringParam fixtures.AliasString

+ ArrayAliasHereStringParam []AliasHereString

+ ArrayParam [3]string

+ Boolean bool

+ DummyParam fixtures.QueryDummy

+ Embedded fixtures.QueryDummy

+ Float32 float32

+ Foo string

+ ID kallax.ULID

+ IDPropertyParam kallax.ULID

+ Ignored fixtures.QueryDummy

+ Inline struct{ ... }

+ Integer int

+ Integer64 int64

+ InterfacePropParam fixtures.InterfaceImplementation

+ MapOfInterface map[string]interface{}

+ MapOfSomeType map[string]fixtures.QueryDummy

+ MapOfString map[string]string

+ NRelation []*QueryRelationFixture

+ Relation *QueryRelationFixture

+ ScannerValuerParam ScannerValuer

+ SliceDummyParam []fixtures.QueryDummy

+ SliceParam []string

+ StringProperty string

+ TimeParam time.Time

+ URLParam url.URL

+ func NewQueryFixture(f string) (record *QueryFixture)

+ func (q *QueryFixture) Eq(v *QueryFixture) bool

+ func (r *QueryFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *QueryFixture) GetID() kallax.Identifier

+ func (r *QueryFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *QueryFixture) SetRelationship(field string, rel interface{}) error

+ func (r *QueryFixture) Value(col string) (interface{}, error)

+ type QueryFixtureQuery struct

+ func NewQueryFixtureQuery() *QueryFixtureQuery

+ func (q *QueryFixtureQuery) BatchSize(size uint64) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Copy() *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasArrAliasStringParam(v ...fixtures.AliasString) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasArrayParam(v ...string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasHereArrayParam(v ...string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasIntParam(cond kallax.ScalarCond, v fixtures.AliasInt) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasSliceParam(v ...string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByAliasStringParam(v fixtures.AliasString) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByArrayAliasHereStringParam(v ...AliasHereString) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByArrayParam(v ...string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByBoolean(v bool) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByFloat32(cond kallax.ScalarCond, v float32) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByFoo(v string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByID(v ...kallax.ULID) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByIDPropertyParam(v kallax.ULID) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByInline(v string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByInteger(cond kallax.ScalarCond, v int) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByInteger64(cond kallax.ScalarCond, v int64) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByInterfacePropParam(v fixtures.InterfaceImplementation) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByScannerValuerParam(v ScannerValuer) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindBySliceParam(v ...string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByStringProperty(v string) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByTimeParam(cond kallax.ScalarCond, v time.Time) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) FindByURLParam(v url.URL) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Limit(n uint64) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Offset(n uint64) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Order(cols ...kallax.ColumnOrder) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Select(columns ...kallax.SchemaField) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) SelectNot(columns ...kallax.SchemaField) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) Where(cond kallax.Condition) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) WithNRelation(cond kallax.Condition) *QueryFixtureQuery

+ func (q *QueryFixtureQuery) WithRelation() *QueryFixtureQuery

+ type QueryFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewQueryFixtureResultSet(rs kallax.ResultSet) *QueryFixtureResultSet

+ func (rs *QueryFixtureResultSet) All() ([]*QueryFixture, error)

+ func (rs *QueryFixtureResultSet) Close() error

+ func (rs *QueryFixtureResultSet) Err() error

+ func (rs *QueryFixtureResultSet) ForEach(fn func(*QueryFixture) error) error

+ func (rs *QueryFixtureResultSet) Get() (*QueryFixture, error)

+ func (rs *QueryFixtureResultSet) Next() bool

+ func (rs *QueryFixtureResultSet) One() (*QueryFixture, error)

+ type QueryFixtureStore struct

+ func NewQueryFixtureStore(db *sql.DB) *QueryFixtureStore

+ func (s *QueryFixtureStore) Count(q *QueryFixtureQuery) (int64, error)

+ func (s *QueryFixtureStore) Delete(record *QueryFixture) error

+ func (s *QueryFixtureStore) Find(q *QueryFixtureQuery) (*QueryFixtureResultSet, error)

+ func (s *QueryFixtureStore) FindOne(q *QueryFixtureQuery) (*QueryFixture, error)

+ func (s *QueryFixtureStore) Insert(record *QueryFixture) error

+ func (s *QueryFixtureStore) MustCount(q *QueryFixtureQuery) int64

+ func (s *QueryFixtureStore) MustFind(q *QueryFixtureQuery) *QueryFixtureResultSet

+ func (s *QueryFixtureStore) MustFindOne(q *QueryFixtureQuery) *QueryFixture

+ func (s *QueryFixtureStore) Reload(record *QueryFixture) error

+ func (s *QueryFixtureStore) RemoveNRelation(record *QueryFixture, deleted ...*QueryRelationFixture) error

+ func (s *QueryFixtureStore) RemoveRelation(record *QueryFixture) error

+ func (s *QueryFixtureStore) Save(record *QueryFixture) (updated bool, err error)

+ func (s *QueryFixtureStore) Transaction(callback func(*QueryFixtureStore) error) error

+ func (s *QueryFixtureStore) Update(record *QueryFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type QueryRelationFixture struct

+ ID kallax.ULID

+ Name string

+ Owner *QueryFixture

+ func NewQueryRelationFixture() (record *QueryRelationFixture)

+ func (r *QueryRelationFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *QueryRelationFixture) GetID() kallax.Identifier

+ func (r *QueryRelationFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *QueryRelationFixture) SetRelationship(field string, rel interface{}) error

+ func (r *QueryRelationFixture) Value(col string) (interface{}, error)

+ type QueryRelationFixtureQuery struct

+ func NewQueryRelationFixtureQuery() *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) BatchSize(size uint64) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Copy() *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) FindByID(v ...kallax.ULID) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) FindByName(v string) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Limit(n uint64) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Offset(n uint64) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Order(cols ...kallax.ColumnOrder) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Select(columns ...kallax.SchemaField) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) SelectNot(columns ...kallax.SchemaField) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) Where(cond kallax.Condition) *QueryRelationFixtureQuery

+ func (q *QueryRelationFixtureQuery) WithOwner() *QueryRelationFixtureQuery

+ type QueryRelationFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewQueryRelationFixtureResultSet(rs kallax.ResultSet) *QueryRelationFixtureResultSet

+ func (rs *QueryRelationFixtureResultSet) All() ([]*QueryRelationFixture, error)

+ func (rs *QueryRelationFixtureResultSet) Close() error

+ func (rs *QueryRelationFixtureResultSet) Err() error

+ func (rs *QueryRelationFixtureResultSet) ForEach(fn func(*QueryRelationFixture) error) error

+ func (rs *QueryRelationFixtureResultSet) Get() (*QueryRelationFixture, error)

+ func (rs *QueryRelationFixtureResultSet) Next() bool

+ func (rs *QueryRelationFixtureResultSet) One() (*QueryRelationFixture, error)

+ type QueryRelationFixtureStore struct

+ func NewQueryRelationFixtureStore(db *sql.DB) *QueryRelationFixtureStore

+ func (s *QueryRelationFixtureStore) Count(q *QueryRelationFixtureQuery) (int64, error)

+ func (s *QueryRelationFixtureStore) Delete(record *QueryRelationFixture) error

+ func (s *QueryRelationFixtureStore) Find(q *QueryRelationFixtureQuery) (*QueryRelationFixtureResultSet, error)

+ func (s *QueryRelationFixtureStore) FindOne(q *QueryRelationFixtureQuery) (*QueryRelationFixture, error)

+ func (s *QueryRelationFixtureStore) Insert(record *QueryRelationFixture) error

+ func (s *QueryRelationFixtureStore) MustCount(q *QueryRelationFixtureQuery) int64

+ func (s *QueryRelationFixtureStore) MustFind(q *QueryRelationFixtureQuery) *QueryRelationFixtureResultSet

+ func (s *QueryRelationFixtureStore) MustFindOne(q *QueryRelationFixtureQuery) *QueryRelationFixture

+ func (s *QueryRelationFixtureStore) Reload(record *QueryRelationFixture) error

+ func (s *QueryRelationFixtureStore) Save(record *QueryRelationFixture) (updated bool, err error)

+ func (s *QueryRelationFixtureStore) Transaction(callback func(*QueryRelationFixtureStore) error) error

+ func (s *QueryRelationFixtureStore) Update(record *QueryRelationFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type Qux struct

+ Balooga int

+ Boo float64

+ Schnooga string

+ type ResultSetFixture struct

+ Foo string

+ ID kallax.ULID

+ func NewResultSetFixture(f string) (record *ResultSetFixture)

+ func (r *ResultSetFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *ResultSetFixture) GetID() kallax.Identifier

+ func (r *ResultSetFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *ResultSetFixture) SetRelationship(field string, rel interface{}) error

+ func (r *ResultSetFixture) Value(col string) (interface{}, error)

+ type ResultSetFixtureQuery struct

+ func NewResultSetFixtureQuery() *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) BatchSize(size uint64) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Copy() *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) FindByFoo(v string) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) FindByID(v ...kallax.ULID) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Limit(n uint64) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Offset(n uint64) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Order(cols ...kallax.ColumnOrder) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Select(columns ...kallax.SchemaField) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) SelectNot(columns ...kallax.SchemaField) *ResultSetFixtureQuery

+ func (q *ResultSetFixtureQuery) Where(cond kallax.Condition) *ResultSetFixtureQuery

+ type ResultSetFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewResultSetFixtureResultSet(rs kallax.ResultSet) *ResultSetFixtureResultSet

+ func (rs *ResultSetFixtureResultSet) All() ([]*ResultSetFixture, error)

+ func (rs *ResultSetFixtureResultSet) Close() error

+ func (rs *ResultSetFixtureResultSet) Err() error

+ func (rs *ResultSetFixtureResultSet) ForEach(fn func(*ResultSetFixture) error) error

+ func (rs *ResultSetFixtureResultSet) Get() (*ResultSetFixture, error)

+ func (rs *ResultSetFixtureResultSet) Next() bool

+ func (rs *ResultSetFixtureResultSet) One() (*ResultSetFixture, error)

+ type ResultSetFixtureStore struct

+ func NewResultSetFixtureStore(db *sql.DB) *ResultSetFixtureStore

+ func (s *ResultSetFixtureStore) Count(q *ResultSetFixtureQuery) (int64, error)

+ func (s *ResultSetFixtureStore) Delete(record *ResultSetFixture) error

+ func (s *ResultSetFixtureStore) Find(q *ResultSetFixtureQuery) (*ResultSetFixtureResultSet, error)

+ func (s *ResultSetFixtureStore) FindOne(q *ResultSetFixtureQuery) (*ResultSetFixture, error)

+ func (s *ResultSetFixtureStore) Insert(record *ResultSetFixture) error

+ func (s *ResultSetFixtureStore) MustCount(q *ResultSetFixtureQuery) int64

+ func (s *ResultSetFixtureStore) MustFind(q *ResultSetFixtureQuery) *ResultSetFixtureResultSet

+ func (s *ResultSetFixtureStore) MustFindOne(q *ResultSetFixtureQuery) *ResultSetFixture

+ func (s *ResultSetFixtureStore) Reload(record *ResultSetFixture) error

+ func (s *ResultSetFixtureStore) Save(record *ResultSetFixture) (updated bool, err error)

+ func (s *ResultSetFixtureStore) Transaction(callback func(*ResultSetFixtureStore) error) error

+ func (s *ResultSetFixtureStore) Update(record *ResultSetFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type ScannerValuer struct

+ type SchemaFixture struct

+ ID kallax.ULID

+ Inline struct{ ... }

+ Int int

+ MapOfInterface map[string]interface{}

+ MapOfSomeType map[string]struct{ ... }

+ MapOfString map[string]string

+ Nested *SchemaFixture

+ ShouldIgnore string

+ String string

+ func NewSchemaFixture() (record *SchemaFixture)

+ func (r *SchemaFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *SchemaFixture) GetID() kallax.Identifier

+ func (r *SchemaFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *SchemaFixture) SetRelationship(field string, rel interface{}) error

+ func (r *SchemaFixture) Value(col string) (interface{}, error)

+ type SchemaFixtureQuery struct

+ func NewSchemaFixtureQuery() *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) BatchSize(size uint64) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Copy() *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) FindByID(v ...kallax.ULID) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) FindByInline(v string) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) FindByInt(cond kallax.ScalarCond, v int) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) FindByString(v string) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Limit(n uint64) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Offset(n uint64) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Order(cols ...kallax.ColumnOrder) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Select(columns ...kallax.SchemaField) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) SelectNot(columns ...kallax.SchemaField) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) Where(cond kallax.Condition) *SchemaFixtureQuery

+ func (q *SchemaFixtureQuery) WithNested() *SchemaFixtureQuery

+ type SchemaFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewSchemaFixtureResultSet(rs kallax.ResultSet) *SchemaFixtureResultSet

+ func (rs *SchemaFixtureResultSet) All() ([]*SchemaFixture, error)

+ func (rs *SchemaFixtureResultSet) Close() error

+ func (rs *SchemaFixtureResultSet) Err() error

+ func (rs *SchemaFixtureResultSet) ForEach(fn func(*SchemaFixture) error) error

+ func (rs *SchemaFixtureResultSet) Get() (*SchemaFixture, error)

+ func (rs *SchemaFixtureResultSet) Next() bool

+ func (rs *SchemaFixtureResultSet) One() (*SchemaFixture, error)

+ type SchemaFixtureStore struct

+ func NewSchemaFixtureStore(db *sql.DB) *SchemaFixtureStore

+ func (s *SchemaFixtureStore) Count(q *SchemaFixtureQuery) (int64, error)

+ func (s *SchemaFixtureStore) Delete(record *SchemaFixture) error

+ func (s *SchemaFixtureStore) Find(q *SchemaFixtureQuery) (*SchemaFixtureResultSet, error)

+ func (s *SchemaFixtureStore) FindOne(q *SchemaFixtureQuery) (*SchemaFixture, error)

+ func (s *SchemaFixtureStore) Insert(record *SchemaFixture) error

+ func (s *SchemaFixtureStore) MustCount(q *SchemaFixtureQuery) int64

+ func (s *SchemaFixtureStore) MustFind(q *SchemaFixtureQuery) *SchemaFixtureResultSet

+ func (s *SchemaFixtureStore) MustFindOne(q *SchemaFixtureQuery) *SchemaFixture

+ func (s *SchemaFixtureStore) Reload(record *SchemaFixture) error

+ func (s *SchemaFixtureStore) RemoveNested(record *SchemaFixture) error

+ func (s *SchemaFixtureStore) Save(record *SchemaFixture) (updated bool, err error)

+ func (s *SchemaFixtureStore) Transaction(callback func(*SchemaFixtureStore) error) error

+ func (s *SchemaFixtureStore) Update(record *SchemaFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type SomeJSON struct

+ Foo int

+ type StoreFixture struct

+ AliasSliceProp AliasSliceString

+ Foo string

+ ID kallax.ULID

+ SliceProp []string

+ func NewStoreFixture() (record *StoreFixture)

+ func (r *StoreFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *StoreFixture) GetID() kallax.Identifier

+ func (r *StoreFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *StoreFixture) SetRelationship(field string, rel interface{}) error

+ func (r *StoreFixture) Value(col string) (interface{}, error)

+ type StoreFixtureQuery struct

+ func NewStoreFixtureQuery() *StoreFixtureQuery

+ func (q *StoreFixtureQuery) BatchSize(size uint64) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Copy() *StoreFixtureQuery

+ func (q *StoreFixtureQuery) FindByAliasSliceProp(v ...string) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) FindByFoo(v string) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) FindByID(v ...kallax.ULID) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) FindBySliceProp(v ...string) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Limit(n uint64) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Offset(n uint64) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Order(cols ...kallax.ColumnOrder) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Select(columns ...kallax.SchemaField) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) SelectNot(columns ...kallax.SchemaField) *StoreFixtureQuery

+ func (q *StoreFixtureQuery) Where(cond kallax.Condition) *StoreFixtureQuery

+ type StoreFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewStoreFixtureResultSet(rs kallax.ResultSet) *StoreFixtureResultSet

+ func (rs *StoreFixtureResultSet) All() ([]*StoreFixture, error)

+ func (rs *StoreFixtureResultSet) Close() error

+ func (rs *StoreFixtureResultSet) Err() error

+ func (rs *StoreFixtureResultSet) ForEach(fn func(*StoreFixture) error) error

+ func (rs *StoreFixtureResultSet) Get() (*StoreFixture, error)

+ func (rs *StoreFixtureResultSet) Next() bool

+ func (rs *StoreFixtureResultSet) One() (*StoreFixture, error)

+ type StoreFixtureStore struct

+ func NewStoreFixtureStore(db *sql.DB) *StoreFixtureStore

+ func (s *StoreFixtureStore) Count(q *StoreFixtureQuery) (int64, error)

+ func (s *StoreFixtureStore) Delete(record *StoreFixture) error

+ func (s *StoreFixtureStore) Find(q *StoreFixtureQuery) (*StoreFixtureResultSet, error)

+ func (s *StoreFixtureStore) FindOne(q *StoreFixtureQuery) (*StoreFixture, error)

+ func (s *StoreFixtureStore) Insert(record *StoreFixture) error

+ func (s *StoreFixtureStore) MustCount(q *StoreFixtureQuery) int64

+ func (s *StoreFixtureStore) MustFind(q *StoreFixtureQuery) *StoreFixtureResultSet

+ func (s *StoreFixtureStore) MustFindOne(q *StoreFixtureQuery) *StoreFixture

+ func (s *StoreFixtureStore) Reload(record *StoreFixture) error

+ func (s *StoreFixtureStore) Save(record *StoreFixture) (updated bool, err error)

+ func (s *StoreFixtureStore) Transaction(callback func(*StoreFixtureStore) error) error

+ func (s *StoreFixtureStore) Update(record *StoreFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type StoreWithConstructFixture struct

+ Foo string

+ ID kallax.ULID

+ func NewStoreWithConstructFixture(f string) (record *StoreWithConstructFixture)

+ func (r *StoreWithConstructFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *StoreWithConstructFixture) GetID() kallax.Identifier

+ func (r *StoreWithConstructFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *StoreWithConstructFixture) SetRelationship(field string, rel interface{}) error

+ func (r *StoreWithConstructFixture) Value(col string) (interface{}, error)

+ type StoreWithConstructFixtureQuery struct

+ func NewStoreWithConstructFixtureQuery() *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) BatchSize(size uint64) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Copy() *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) FindByFoo(v string) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) FindByID(v ...kallax.ULID) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Limit(n uint64) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Offset(n uint64) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Order(cols ...kallax.ColumnOrder) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Select(columns ...kallax.SchemaField) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) SelectNot(columns ...kallax.SchemaField) *StoreWithConstructFixtureQuery

+ func (q *StoreWithConstructFixtureQuery) Where(cond kallax.Condition) *StoreWithConstructFixtureQuery

+ type StoreWithConstructFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewStoreWithConstructFixtureResultSet(rs kallax.ResultSet) *StoreWithConstructFixtureResultSet

+ func (rs *StoreWithConstructFixtureResultSet) All() ([]*StoreWithConstructFixture, error)

+ func (rs *StoreWithConstructFixtureResultSet) Close() error

+ func (rs *StoreWithConstructFixtureResultSet) Err() error

+ func (rs *StoreWithConstructFixtureResultSet) ForEach(fn func(*StoreWithConstructFixture) error) error

+ func (rs *StoreWithConstructFixtureResultSet) Get() (*StoreWithConstructFixture, error)

+ func (rs *StoreWithConstructFixtureResultSet) Next() bool

+ func (rs *StoreWithConstructFixtureResultSet) One() (*StoreWithConstructFixture, error)

+ type StoreWithConstructFixtureStore struct

+ func NewStoreWithConstructFixtureStore(db *sql.DB) *StoreWithConstructFixtureStore

+ func (s *StoreWithConstructFixtureStore) Count(q *StoreWithConstructFixtureQuery) (int64, error)

+ func (s *StoreWithConstructFixtureStore) Delete(record *StoreWithConstructFixture) error

+ func (s *StoreWithConstructFixtureStore) Find(q *StoreWithConstructFixtureQuery) (*StoreWithConstructFixtureResultSet, error)

+ func (s *StoreWithConstructFixtureStore) FindOne(q *StoreWithConstructFixtureQuery) (*StoreWithConstructFixture, error)

+ func (s *StoreWithConstructFixtureStore) Insert(record *StoreWithConstructFixture) error

+ func (s *StoreWithConstructFixtureStore) MustCount(q *StoreWithConstructFixtureQuery) int64

+ func (s *StoreWithConstructFixtureStore) MustFind(q *StoreWithConstructFixtureQuery) *StoreWithConstructFixtureResultSet

+ func (s *StoreWithConstructFixtureStore) MustFindOne(q *StoreWithConstructFixtureQuery) *StoreWithConstructFixture

+ func (s *StoreWithConstructFixtureStore) Reload(record *StoreWithConstructFixture) error

+ func (s *StoreWithConstructFixtureStore) Save(record *StoreWithConstructFixture) (updated bool, err error)

+ func (s *StoreWithConstructFixtureStore) Transaction(callback func(*StoreWithConstructFixtureStore) error) error

+ func (s *StoreWithConstructFixtureStore) Update(record *StoreWithConstructFixture, cols ...kallax.SchemaField) (updated int64, err error)

+ type StoreWithNewFixture struct

+ Bar string

+ Foo string

+ ID kallax.ULID

+ func NewStoreWithNewFixture() (record *StoreWithNewFixture)

+ func (r *StoreWithNewFixture) ColumnAddress(col string) (interface{}, error)

+ func (r *StoreWithNewFixture) GetID() kallax.Identifier

+ func (r *StoreWithNewFixture) NewRelationshipRecord(field string) (kallax.Record, error)

+ func (r *StoreWithNewFixture) SetRelationship(field string, rel interface{}) error

+ func (r *StoreWithNewFixture) Value(col string) (interface{}, error)

+ type StoreWithNewFixtureQuery struct

+ func NewStoreWithNewFixtureQuery() *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) BatchSize(size uint64) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Copy() *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) FindByBar(v string) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) FindByFoo(v string) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) FindByID(v ...kallax.ULID) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Limit(n uint64) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Offset(n uint64) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Order(cols ...kallax.ColumnOrder) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Select(columns ...kallax.SchemaField) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) SelectNot(columns ...kallax.SchemaField) *StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) Where(cond kallax.Condition) *StoreWithNewFixtureQuery

+ type StoreWithNewFixtureResultSet struct

+ ResultSet kallax.ResultSet

+ func NewStoreWithNewFixtureResultSet(rs kallax.ResultSet) *StoreWithNewFixtureResultSet

+ func (rs *StoreWithNewFixtureResultSet) All() ([]*StoreWithNewFixture, error)

+ func (rs *StoreWithNewFixtureResultSet) Close() error

+ func (rs *StoreWithNewFixtureResultSet) Err() error

+ func (rs *StoreWithNewFixtureResultSet) ForEach(fn func(*StoreWithNewFixture) error) error

+ func (rs *StoreWithNewFixtureResultSet) Get() (*StoreWithNewFixture, error)

+ func (rs *StoreWithNewFixtureResultSet) Next() bool

+ func (rs *StoreWithNewFixtureResultSet) One() (*StoreWithNewFixture, error)

+ type StoreWithNewFixtureStore struct

+ func NewStoreWithNewFixtureStore(db *sql.DB) *StoreWithNewFixtureStore

+ func (s *StoreWithNewFixtureStore) Count(q *StoreWithNewFixtureQuery) (int64, error)

+ func (s *StoreWithNewFixtureStore) Delete(record *StoreWithNewFixture) error

+ func (s *StoreWithNewFixtureStore) Find(q *StoreWithNewFixtureQuery) (*StoreWithNewFixtureResultSet, error)

+ func (s *StoreWithNewFixtureStore) FindOne(q *StoreWithNewFixtureQuery) (*StoreWithNewFixture, error)

+ func (s *StoreWithNewFixtureStore) Insert(record *StoreWithNewFixture) error

+ func (s *StoreWithNewFixtureStore) MustCount(q *StoreWithNewFixtureQuery) int64

+ func (s *StoreWithNewFixtureStore) MustFind(q *StoreWithNewFixtureQuery) *StoreWithNewFixtureResultSet

+ func (s *StoreWithNewFixtureStore) MustFindOne(q *StoreWithNewFixtureQuery) *StoreWithNewFixture

+ func (s *StoreWithNewFixtureStore) Reload(record *StoreWithNewFixture) error

+ func (s *StoreWithNewFixtureStore) Save(record *StoreWithNewFixture) (updated bool, err error)

+ func (s *StoreWithNewFixtureStore) Transaction(callback func(*StoreWithNewFixtureStore) error) error

+ func (s *StoreWithNewFixtureStore) Update(record *StoreWithNewFixture, cols ...kallax.SchemaField) (updated int64, err error)

Other modules containing this package

gopkg.in/src-d/go-kallax.v0

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL