Documentation
¶
Index ¶
- Variables
- type GuserDao
- func (d *GuserDao) All(where ...interface{}) ([]*model.Guser, error)
- func (d *GuserDao) And(where interface{}, args ...interface{}) *GuserDao
- func (d *GuserDao) Args(args ...interface{}) *GuserDao
- func (d *GuserDao) As(as string) *GuserDao
- func (d *GuserDao) Batch(batch int) *GuserDao
- func (d *GuserDao) Cache(duration time.Duration, name ...string) *GuserDao
- func (d *GuserDao) Chunk(limit int, callback func(entities []*model.Guser, err error) bool)
- func (d *GuserDao) Ctx(ctx context.Context) *GuserDao
- func (d *GuserDao) Data(data ...interface{}) *GuserDao
- func (d *GuserDao) Fields(fieldNamesOrMapStruct ...interface{}) *GuserDao
- func (d *GuserDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *GuserDao
- func (d *GuserDao) Filter() *GuserDao
- func (d *GuserDao) FindAll(where ...interface{}) ([]*model.Guser, error)
- func (d *GuserDao) FindOne(where ...interface{}) (*model.Guser, error)
- func (d *GuserDao) Group(groupBy string) *GuserDao
- func (d *GuserDao) InnerJoin(table ...string) *GuserDao
- func (d *GuserDao) LeftJoin(table ...string) *GuserDao
- func (d *GuserDao) Limit(limit ...int) *GuserDao
- func (d *GuserDao) LockShared() *GuserDao
- func (d *GuserDao) LockUpdate() *GuserDao
- func (d *GuserDao) Master() *GuserDao
- func (d *GuserDao) Offset(offset int) *GuserDao
- func (d *GuserDao) OmitEmpty() *GuserDao
- func (d *GuserDao) One(where ...interface{}) (*model.Guser, error)
- func (d *GuserDao) Option(option int) *GuserDao
- func (d *GuserDao) Or(where interface{}, args ...interface{}) *GuserDao
- func (d *GuserDao) Order(orderBy ...string) *GuserDao
- func (d *GuserDao) Page(page, limit int) *GuserDao
- func (d *GuserDao) RightJoin(table ...string) *GuserDao
- func (d *GuserDao) Scan(pointer interface{}, where ...interface{}) error
- func (d *GuserDao) Slave() *GuserDao
- func (d *GuserDao) Struct(pointer interface{}, where ...interface{}) error
- func (d *GuserDao) Structs(pointer interface{}, where ...interface{}) error
- func (d *GuserDao) TX(tx *gdb.TX) *GuserDao
- func (d *GuserDao) Unscoped() *GuserDao
- func (d *GuserDao) Where(where interface{}, args ...interface{}) *GuserDao
- func (d *GuserDao) WherePri(where interface{}, args ...interface{}) *GuserDao
Constants ¶
This section is empty.
Variables ¶
Functions ¶
This section is empty.
Types ¶
type GuserDao ¶
GuserDao is the manager for logic model data accessing and custom defined data operations functions management.
func (*GuserDao) All ¶
All does "SELECT FROM ..." statement for the model. It retrieves the records from table and returns the result as []*model.Guser. It returns nil if there's no record retrieved with the given conditions from table.
The optional parameter <where> is the same as the parameter of M.Where function, see M.Where.
func (*GuserDao) Cache ¶
Cache sets the cache feature for the model. It caches the result of the sql, which means if there's another same sql request, it just reads and returns the result from cache, it but not committed and executed into the database.
If the parameter <duration> < 0, which means it clear the cache with given <name>. If the parameter <duration> = 0, which means it never expires. If the parameter <duration> > 0, which means it expires after <duration>.
The optional parameter <name> is used to bind a name to the cache, which means you can later control the cache like changing the <duration> or clearing the cache with specified <name>.
Note that, the cache feature is disabled if the model is operating on a transaction.
func (*GuserDao) Ctx ¶
Ctx is a chaining function, which creates and returns a new DB that is a shallow copy of current DB object and with given context in it. Note that this returned DB object can be used only once, so do not assign it to a global or package variable for long using.
func (*GuserDao) Data ¶
Data sets the operation data for the model. The parameter <data> can be type of string/map/gmap/slice/struct/*struct, etc. Eg: Data("uid=10000") Data("uid", 10000) Data(g.Map{"uid": 10000, "name":"john"}) Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
func (*GuserDao) Fields ¶
Fields sets the operation fields of the model, multiple fields joined using char ','. The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
func (*GuserDao) FieldsEx ¶
FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','. The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
func (*GuserDao) Filter ¶
Filter marks filtering the fields which does not exist in the fields of the operated table.
func (*GuserDao) FindAll ¶
FindAll retrieves and returns Result by by M.WherePri and M.All. Also see M.WherePri and M.All.
func (*GuserDao) FindOne ¶
FindOne retrieves and returns a single Record by M.WherePri and M.One. Also see M.WherePri and M.One.
func (*GuserDao) InnerJoin ¶
InnerJoin does "INNER JOIN ... ON ..." statement on the model. The parameter <table> can be joined table and its joined condition, and also with its alias name, like: Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid") Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
func (*GuserDao) LeftJoin ¶
LeftJoin does "LEFT JOIN ... ON ..." statement on the model. The parameter <table> can be joined table and its joined condition, and also with its alias name, like: Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid") Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
func (*GuserDao) Limit ¶
Limit sets the "LIMIT" statement for the model. The parameter <limit> can be either one or two number, if passed two number is passed, it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]" statement.
func (*GuserDao) LockShared ¶
LockShared sets the lock in share mode for current operation.
func (*GuserDao) LockUpdate ¶
LockUpdate sets the lock for update for current operation.
func (*GuserDao) Offset ¶
Offset sets the "OFFSET" statement for the model. It only makes sense for some databases like SQLServer, PostgreSQL, etc.
func (*GuserDao) OmitEmpty ¶
OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers the data and where attributes for empty values.
func (*GuserDao) One ¶
One retrieves one record from table and returns the result as *model.Guser. It returns nil if there's no record retrieved with the given conditions from table.
The optional parameter <where> is the same as the parameter of M.Where function, see M.Where.
func (*GuserDao) Page ¶
Page sets the paging number for the model. The parameter <page> is started from 1 for paging. Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
func (*GuserDao) RightJoin ¶
RightJoin does "RIGHT JOIN ... ON ..." statement on the model. The parameter <table> can be joined table and its joined condition, and also with its alias name, like: Table("user").RightJoin("user_detail", "user_detail.uid=user.uid") Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
func (*GuserDao) Scan ¶
Scan automatically calls Struct or Structs function according to the type of parameter <pointer>. It calls function Struct if <pointer> is type of *struct/**struct. It calls function Structs if <pointer> is type of *[]struct/*[]*struct.
The optional parameter <where> is the same as the parameter of Model.Where function, see Model.Where.
Note that it returns sql.ErrNoRows if there's no record retrieved and given pointer is not empty or nil.
Eg: user := new(User) err := dao.User.Where("id", 1).Scan(user)
user := (*User)(nil) err := dao.User.Where("id", 1).Scan(&user)
users := ([]User)(nil) err := dao.User.Scan(&users)
users := ([]*User)(nil) err := dao.User.Scan(&users)
func (*GuserDao) Slave ¶
Slave marks the following operation on slave node. Note that it makes sense only if there's any slave node configured.
func (*GuserDao) Struct ¶
Struct retrieves one record from table and converts it into given struct. The parameter <pointer> should be type of *struct/**struct. If type **struct is given, it can create the struct internally during converting.
The optional parameter <where> is the same as the parameter of Model.Where function, see Model.Where.
Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions from table and <pointer> is not nil.
Eg: user := new(User) err := dao.User.Where("id", 1).Struct(user)
user := (*User)(nil) err := dao.User.Where("id", 1).Struct(&user)
func (*GuserDao) Structs ¶
Structs retrieves records from table and converts them into given struct slice. The parameter <pointer> should be type of *[]struct/*[]*struct. It can create and fill the struct slice internally during converting.
The optional parameter <where> is the same as the parameter of Model.Where function, see Model.Where.
Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions from table and <pointer> is not empty.
Eg: users := ([]User)(nil) err := dao.User.Structs(&users)
users := ([]*User)(nil) err := dao.User.Structs(&users)
func (*GuserDao) Where ¶
Where sets the condition statement for the model. The parameter <where> can be type of string/map/gmap/slice/struct/*struct, etc. Note that, if it's called more than one times, multiple conditions will be joined into where statement using "AND". Eg: Where("uid=10000") Where("uid", 10000) Where("money>? AND name like ?", 99999, "vip_%") Where("uid", 1).Where("name", "john") Where("status IN (?)", g.Slice{1,2,3}) Where("age IN(?,?)", 18, 50) Where(User{ Id : 1, UserName : "john"})
func (*GuserDao) WherePri ¶
WherePri does the same logic as M.Where except that if the parameter <where> is a single condition like int/string/float/slice, it treats the condition as the primary key value. That is, if primary key is "id" and given <where> parameter as "123", the WherePri function treats the condition as "id=123", but M.Where treats the condition as string "123".
Source Files