tests

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

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

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)

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)

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)

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

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)

Feb 22, 2017

Changes in this version

+ type AliasHereArray [3]string

+ type AliasHereString string

+ type AliasID kallax.ULID

+ type AliasSliceString []string

type CarQuery

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

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

type EventsAllFixtureQuery

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

type EventsFixtureQuery

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

type EventsSaveFixtureQuery

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

type JSONModelQuery

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

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

type 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

+ 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

+ PetsArr [2]*Pet

type PersonQuery

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

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

type PetQuery

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

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

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

type QueryFixture

+ 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

+ 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 (q *QueryFixture) Eq(v *QueryFixture) bool

type 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) WithNRelation(cond kallax.Condition) *QueryFixtureQuery

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

type QueryFixtureStore

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

+ func (s *QueryFixtureStore) RemoveRelation(record *QueryFixture) 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 ResultSetFixtureQuery

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

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

+ type ScannerValuer struct

type 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

+ type SomeJSON struct

+ Foo int

type StoreFixture

+ AliasSliceProp AliasSliceString

+ SliceProp []string

type 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

type StoreWithConstructFixtureQuery

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

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

type StoreWithNewFixtureQuery

+ func (q *StoreWithNewFixtureQuery) FindByBar(v string) *StoreWithNewFixtureQuery

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

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

Feb 16, 2017

Changes in this version

+ type Bar struct

+ Mux string

+ Qux []Qux

+ type Baz struct

+ Mux string

type Car

+ ID kallax.ULID

+ func (c *Car) AfterDelete() error

+ func (c *Car) AfterSave() error

+ func (c *Car) BeforeDelete() error

+ func (c *Car) BeforeSave() error

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

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

+ ID kallax.ULID

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

type EventsSaveFixture

+ ID kallax.ULID

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

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

+ ID kallax.ULID

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

type Person

+ ID int64

+ func (c *Person) AfterDelete() error

+ func (c *Person) AfterSave() error

+ func (c *Person) BeforeDelete() error

+ func (c *Person) BeforeSave() error

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

type Pet

+ ID kallax.ULID

+ func (c *Pet) AfterDelete() error

+ func (c *Pet) AfterSave() error

+ func (c *Pet) BeforeDelete() error

+ func (c *Pet) BeforeSave() error

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

type QueryFixture

+ ID kallax.ULID

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

+ type Qux struct

+ Balooga int

+ Boo float64

+ Schnooga string

type ResultSetFixture

+ ID kallax.ULID

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

type SchemaFixture

+ ID kallax.ULID

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

type StoreFixture

+ ID kallax.ULID

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

type StoreWithConstructFixture

+ ID kallax.ULID

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

type StoreWithNewFixture

+ ID kallax.ULID

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

Jan 31, 2017

Changes in this version

+ type Car struct

+ ModelName string

+ Owner *Person

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

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

+ 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) 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 EventsFixture

+ func (s *EventsFixture) AfterInsert() error

+ func (s *EventsFixture) AfterUpdate() error

+ func (s *EventsFixture) BeforeInsert() error

+ func (s *EventsFixture) BeforeUpdate() error

type EventsFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *EventsFixtureResultSet) Close() error

+ func (rs *EventsFixtureResultSet) Err() error

type EventsSaveFixture

+ func (s *EventsSaveFixture) AfterSave() error

+ func (s *EventsSaveFixture) BeforeSave() error

type EventsSaveFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *EventsSaveFixtureResultSet) Close() error

+ func (rs *EventsSaveFixtureResultSet) Err() error

type MultiKeySortFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *MultiKeySortFixtureResultSet) Close() error

+ func (rs *MultiKeySortFixtureResultSet) Err() error

+ type Person struct

+ Car *Car

+ Name string

+ Pets []*Pet

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

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

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

+ Kind string

+ Name string

+ Owner *Person

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

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

+ 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) 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 QueryFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *QueryFixtureResultSet) Close() error

+ func (rs *QueryFixtureResultSet) Err() error

type ResultSetFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *ResultSetFixtureResultSet) Close() error

+ func (rs *ResultSetFixtureResultSet) Err() error

type SchemaFixture

+ ShouldIgnore string

type SchemaFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *SchemaFixtureResultSet) Close() error

+ func (rs *SchemaFixtureResultSet) Err() error

type SchemaFixtureStore

+ func (s *SchemaFixtureStore) RemoveNested(record *SchemaFixture) error

type StoreFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *StoreFixtureResultSet) Close() error

+ func (rs *StoreFixtureResultSet) Err() error

type StoreWithConstructFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *StoreWithConstructFixtureResultSet) Close() error

+ func (rs *StoreWithConstructFixtureResultSet) Err() error

type StoreWithNewFixtureResultSet

+ ResultSet kallax.ResultSet

+ func (rs *StoreWithNewFixtureResultSet) Close() error

+ func (rs *StoreWithNewFixtureResultSet) Err() error

Jan 24, 2017

Changes in this version

+ var Schema = &schema

+ type EventsFixture struct

+ Checks map[string]bool

+ MustFailAfter error

+ MustFailBefore error

+ func NewEventsFixture() (record *EventsFixture)

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

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

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

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

+ type EventsFixtureQuery struct

+ func NewEventsFixtureQuery() *EventsFixtureQuery

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

+ func (q *EventsFixtureQuery) Copy() *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

+ func NewEventsFixtureResultSet(rs *kallax.ResultSet) *EventsFixtureResultSet

+ func (rs *EventsFixtureResultSet) All() ([]*EventsFixture, 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) AfterInsert(doc *EventsFixture) error

+ func (s *EventsFixtureStore) AfterUpdate(doc *EventsFixture) error

+ func (s *EventsFixtureStore) BeforeInsert(doc *EventsFixture) error

+ func (s *EventsFixtureStore) BeforeUpdate(doc *EventsFixture) error

+ 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) (int64, error)

+ type EventsSaveFixture struct

+ Checks map[string]bool

+ MustFailAfter error

+ MustFailBefore error

+ func NewEventsSaveFixture() (record *EventsSaveFixture)

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

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

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

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

+ type EventsSaveFixtureQuery struct

+ func NewEventsSaveFixtureQuery() *EventsSaveFixtureQuery

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

+ func (q *EventsSaveFixtureQuery) Copy() *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

+ func NewEventsSaveFixtureResultSet(rs *kallax.ResultSet) *EventsSaveFixtureResultSet

+ func (rs *EventsSaveFixtureResultSet) All() ([]*EventsSaveFixture, 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) AfterSave(doc *EventsSaveFixture) error

+ func (s *EventsSaveFixtureStore) BeforeSave(doc *EventsSaveFixture) error

+ 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) (int64, error)

+ type MultiKeySortFixture struct

+ End time.Time

+ Name string

+ Start time.Time

+ func NewMultiKeySortFixture() (record *MultiKeySortFixture)

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

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

+ func (r *MultiKeySortFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewMultiKeySortFixtureResultSet(rs *kallax.ResultSet) *MultiKeySortFixtureResultSet

+ func (rs *MultiKeySortFixtureResultSet) All() ([]*MultiKeySortFixture, 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) (int64, error)

+ type QueryFixture struct

+ Foo string

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

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

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

+ func (r *QueryFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ type QueryFixtureResultSet struct

+ func NewQueryFixtureResultSet(rs *kallax.ResultSet) *QueryFixtureResultSet

+ func (rs *QueryFixtureResultSet) All() ([]*QueryFixture, 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) 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) (int64, error)

+ type ResultSetFixture struct

+ Foo string

+ func NewResultSetFixture(f string) (record *ResultSetFixture)

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

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

+ func (r *ResultSetFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewResultSetFixtureResultSet(rs *kallax.ResultSet) *ResultSetFixtureResultSet

+ func (rs *ResultSetFixtureResultSet) All() ([]*ResultSetFixture, 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) (int64, error)

+ type ResultSetInitFixture struct

+ Foo string

+ func NewResultSetInitFixture() (record *ResultSetInitFixture)

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

+ func (r *ResultSetInitFixture) Init(doc kallax.Record) error

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

+ func (r *ResultSetInitFixture) SetRelationship(field string, record kallax.Record) error

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

+ type ResultSetInitFixtureQuery struct

+ func NewResultSetInitFixtureQuery() *ResultSetInitFixtureQuery

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

+ func (q *ResultSetInitFixtureQuery) Copy() *ResultSetInitFixtureQuery

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

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

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

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

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

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

+ type ResultSetInitFixtureResultSet struct

+ func NewResultSetInitFixtureResultSet(rs *kallax.ResultSet) *ResultSetInitFixtureResultSet

+ func (rs *ResultSetInitFixtureResultSet) All() ([]*ResultSetInitFixture, error)

+ func (rs *ResultSetInitFixtureResultSet) ForEach(fn func(*ResultSetInitFixture) error) error

+ func (rs *ResultSetInitFixtureResultSet) Get() (*ResultSetInitFixture, error)

+ func (rs *ResultSetInitFixtureResultSet) Next() bool

+ func (rs *ResultSetInitFixtureResultSet) One() (*ResultSetInitFixture, error)

+ type ResultSetInitFixtureStore struct

+ func NewResultSetInitFixtureStore(db *sql.DB) *ResultSetInitFixtureStore

+ func (s *ResultSetInitFixtureStore) Count(q *ResultSetInitFixtureQuery) (int64, error)

+ func (s *ResultSetInitFixtureStore) Delete(record *ResultSetInitFixture) error

+ func (s *ResultSetInitFixtureStore) Find(q *ResultSetInitFixtureQuery) (*ResultSetInitFixtureResultSet, error)

+ func (s *ResultSetInitFixtureStore) FindOne(q *ResultSetInitFixtureQuery) (*ResultSetInitFixture, error)

+ func (s *ResultSetInitFixtureStore) Insert(record *ResultSetInitFixture) error

+ func (s *ResultSetInitFixtureStore) MustCount(q *ResultSetInitFixtureQuery) int64

+ func (s *ResultSetInitFixtureStore) MustFind(q *ResultSetInitFixtureQuery) *ResultSetInitFixtureResultSet

+ func (s *ResultSetInitFixtureStore) MustFindOne(q *ResultSetInitFixtureQuery) *ResultSetInitFixture

+ func (s *ResultSetInitFixtureStore) Reload(record *ResultSetInitFixture) error

+ func (s *ResultSetInitFixtureStore) Save(record *ResultSetInitFixture) (updated bool, err error)

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

+ func (s *ResultSetInitFixtureStore) Update(record *ResultSetInitFixture, cols ...kallax.SchemaField) (int64, error)

+ type SchemaFixture struct

+ Inline struct{ ... }

+ Int int

+ MapOfInterface map[string]interface{}

+ MapOfSomeType map[string]struct{ ... }

+ MapOfString map[string]string

+ Nested *SchemaFixture

+ String string

+ func NewSchemaFixture() (record *SchemaFixture)

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

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

+ func (r *SchemaFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewSchemaFixtureResultSet(rs *kallax.ResultSet) *SchemaFixtureResultSet

+ func (rs *SchemaFixtureResultSet) All() ([]*SchemaFixture, 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) 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) (int64, error)

+ type StoreFixture struct

+ Foo string

+ func NewStoreFixture() (record *StoreFixture)

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

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

+ func (r *StoreFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewStoreFixtureResultSet(rs *kallax.ResultSet) *StoreFixtureResultSet

+ func (rs *StoreFixtureResultSet) All() ([]*StoreFixture, 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) (int64, error)

+ type StoreWithConstructFixture struct

+ Foo string

+ func NewStoreWithConstructFixture(f string) (record *StoreWithConstructFixture)

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

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

+ func (r *StoreWithConstructFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewStoreWithConstructFixtureResultSet(rs *kallax.ResultSet) *StoreWithConstructFixtureResultSet

+ func (rs *StoreWithConstructFixtureResultSet) All() ([]*StoreWithConstructFixture, 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) (int64, error)

+ type StoreWithNewFixture struct

+ Bar string

+ Foo string

+ func NewStoreWithNewFixture() (record *StoreWithNewFixture)

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

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

+ func (r *StoreWithNewFixture) SetRelationship(field string, record kallax.Record) 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) 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

+ func NewStoreWithNewFixtureResultSet(rs *kallax.ResultSet) *StoreWithNewFixtureResultSet

+ func (rs *StoreWithNewFixtureResultSet) All() ([]*StoreWithNewFixture, 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) New(f, b string) *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) (int64, error)