query

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IOmsCartItemDo
• type IOmsCompanyAddressDo
• type IOmsOrderDo
• type IOmsOrderItemDo
• type IOmsOrderOperateHistoryDo
• type IOmsOrderReturnApplyDo
• type IOmsOrderReturnReasonDo
• type IOmsOrderSettingDo
• type Query
  • func Use(db *gorm.DB, opts ...gen.DOOption) *Query
  • func (q *Query) Available() bool
  • func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx
  • func (q *Query) ReadDB() *Query
  • func (q *Query) ReplaceDB(db *gorm.DB) *Query
  • func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error
  • func (q *Query) WithContext(ctx context.Context) *queryCtx
  • func (q *Query) WriteDB() *Query
• type QueryTx
  • func (q *QueryTx) Commit() error
  • func (q *QueryTx) Rollback() error
  • func (q *QueryTx) RollbackTo(name string) error
  • func (q *QueryTx) SavePoint(name string) error

Variables

var (
	Q                      = new(Query)
	OmsCartItem            *omsCartItem
	OmsCompanyAddress      *omsCompanyAddress
	OmsOrder               *omsOrder
	OmsOrderItem           *omsOrderItem
	OmsOrderOperateHistory *omsOrderOperateHistory
	OmsOrderReturnApply    *omsOrderReturnApply
	OmsOrderReturnReason   *omsOrderReturnReason
	OmsOrderSetting        *omsOrderSetting
)

Functions

func SetDefault

func SetDefault(db *gorm.DB, opts ...gen.DOOption)

Types

type IOmsCartItemDo

type IOmsCartItemDo interface {
	gen.SubQuery
	Debug() IOmsCartItemDo
	WithContext(ctx context.Context) IOmsCartItemDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsCartItemDo
	WriteDB() IOmsCartItemDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsCartItemDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsCartItemDo
	Not(conds ...gen.Condition) IOmsCartItemDo
	Or(conds ...gen.Condition) IOmsCartItemDo
	Select(conds ...field.Expr) IOmsCartItemDo
	Where(conds ...gen.Condition) IOmsCartItemDo
	Order(conds ...field.Expr) IOmsCartItemDo
	Distinct(cols ...field.Expr) IOmsCartItemDo
	Omit(cols ...field.Expr) IOmsCartItemDo
	Join(table schema.Tabler, on ...field.Expr) IOmsCartItemDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsCartItemDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsCartItemDo
	Group(cols ...field.Expr) IOmsCartItemDo
	Having(conds ...gen.Condition) IOmsCartItemDo
	Limit(limit int) IOmsCartItemDo
	Offset(offset int) IOmsCartItemDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsCartItemDo
	Unscoped() IOmsCartItemDo
	Create(values ...*model.OmsCartItem) error
	CreateInBatches(values []*model.OmsCartItem, batchSize int) error
	Save(values ...*model.OmsCartItem) error
	First() (*model.OmsCartItem, error)
	Take() (*model.OmsCartItem, error)
	Last() (*model.OmsCartItem, error)
	Find() ([]*model.OmsCartItem, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsCartItem, err error)
	FindInBatches(result *[]*model.OmsCartItem, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsCartItem) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsCartItemDo
	Assign(attrs ...field.AssignExpr) IOmsCartItemDo
	Joins(fields ...field.RelationField) IOmsCartItemDo
	Preload(fields ...field.RelationField) IOmsCartItemDo
	FirstOrInit() (*model.OmsCartItem, error)
	FirstOrCreate() (*model.OmsCartItem, error)
	FindByPage(offset int, limit int) (result []*model.OmsCartItem, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsCartItemDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsCompanyAddressDo

type IOmsCompanyAddressDo interface {
	gen.SubQuery
	Debug() IOmsCompanyAddressDo
	WithContext(ctx context.Context) IOmsCompanyAddressDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsCompanyAddressDo
	WriteDB() IOmsCompanyAddressDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsCompanyAddressDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsCompanyAddressDo
	Not(conds ...gen.Condition) IOmsCompanyAddressDo
	Or(conds ...gen.Condition) IOmsCompanyAddressDo
	Select(conds ...field.Expr) IOmsCompanyAddressDo
	Where(conds ...gen.Condition) IOmsCompanyAddressDo
	Order(conds ...field.Expr) IOmsCompanyAddressDo
	Distinct(cols ...field.Expr) IOmsCompanyAddressDo
	Omit(cols ...field.Expr) IOmsCompanyAddressDo
	Join(table schema.Tabler, on ...field.Expr) IOmsCompanyAddressDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsCompanyAddressDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsCompanyAddressDo
	Group(cols ...field.Expr) IOmsCompanyAddressDo
	Having(conds ...gen.Condition) IOmsCompanyAddressDo
	Limit(limit int) IOmsCompanyAddressDo
	Offset(offset int) IOmsCompanyAddressDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsCompanyAddressDo
	Unscoped() IOmsCompanyAddressDo
	Create(values ...*model.OmsCompanyAddress) error
	CreateInBatches(values []*model.OmsCompanyAddress, batchSize int) error
	Save(values ...*model.OmsCompanyAddress) error
	First() (*model.OmsCompanyAddress, error)
	Take() (*model.OmsCompanyAddress, error)
	Last() (*model.OmsCompanyAddress, error)
	Find() ([]*model.OmsCompanyAddress, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsCompanyAddress, err error)
	FindInBatches(result *[]*model.OmsCompanyAddress, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsCompanyAddress) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsCompanyAddressDo
	Assign(attrs ...field.AssignExpr) IOmsCompanyAddressDo
	Joins(fields ...field.RelationField) IOmsCompanyAddressDo
	Preload(fields ...field.RelationField) IOmsCompanyAddressDo
	FirstOrInit() (*model.OmsCompanyAddress, error)
	FirstOrCreate() (*model.OmsCompanyAddress, error)
	FindByPage(offset int, limit int) (result []*model.OmsCompanyAddress, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsCompanyAddressDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderDo

type IOmsOrderDo interface {
	gen.SubQuery
	Debug() IOmsOrderDo
	WithContext(ctx context.Context) IOmsOrderDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderDo
	WriteDB() IOmsOrderDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderDo
	Not(conds ...gen.Condition) IOmsOrderDo
	Or(conds ...gen.Condition) IOmsOrderDo
	Select(conds ...field.Expr) IOmsOrderDo
	Where(conds ...gen.Condition) IOmsOrderDo
	Order(conds ...field.Expr) IOmsOrderDo
	Distinct(cols ...field.Expr) IOmsOrderDo
	Omit(cols ...field.Expr) IOmsOrderDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderDo
	Group(cols ...field.Expr) IOmsOrderDo
	Having(conds ...gen.Condition) IOmsOrderDo
	Limit(limit int) IOmsOrderDo
	Offset(offset int) IOmsOrderDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderDo
	Unscoped() IOmsOrderDo
	Create(values ...*model.OmsOrder) error
	CreateInBatches(values []*model.OmsOrder, batchSize int) error
	Save(values ...*model.OmsOrder) error
	First() (*model.OmsOrder, error)
	Take() (*model.OmsOrder, error)
	Last() (*model.OmsOrder, error)
	Find() ([]*model.OmsOrder, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrder, err error)
	FindInBatches(result *[]*model.OmsOrder, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrder) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderDo
	Assign(attrs ...field.AssignExpr) IOmsOrderDo
	Joins(fields ...field.RelationField) IOmsOrderDo
	Preload(fields ...field.RelationField) IOmsOrderDo
	FirstOrInit() (*model.OmsOrder, error)
	FirstOrCreate() (*model.OmsOrder, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrder, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderItemDo

type IOmsOrderItemDo interface {
	gen.SubQuery
	Debug() IOmsOrderItemDo
	WithContext(ctx context.Context) IOmsOrderItemDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderItemDo
	WriteDB() IOmsOrderItemDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderItemDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderItemDo
	Not(conds ...gen.Condition) IOmsOrderItemDo
	Or(conds ...gen.Condition) IOmsOrderItemDo
	Select(conds ...field.Expr) IOmsOrderItemDo
	Where(conds ...gen.Condition) IOmsOrderItemDo
	Order(conds ...field.Expr) IOmsOrderItemDo
	Distinct(cols ...field.Expr) IOmsOrderItemDo
	Omit(cols ...field.Expr) IOmsOrderItemDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderItemDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderItemDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderItemDo
	Group(cols ...field.Expr) IOmsOrderItemDo
	Having(conds ...gen.Condition) IOmsOrderItemDo
	Limit(limit int) IOmsOrderItemDo
	Offset(offset int) IOmsOrderItemDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderItemDo
	Unscoped() IOmsOrderItemDo
	Create(values ...*model.OmsOrderItem) error
	CreateInBatches(values []*model.OmsOrderItem, batchSize int) error
	Save(values ...*model.OmsOrderItem) error
	First() (*model.OmsOrderItem, error)
	Take() (*model.OmsOrderItem, error)
	Last() (*model.OmsOrderItem, error)
	Find() ([]*model.OmsOrderItem, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrderItem, err error)
	FindInBatches(result *[]*model.OmsOrderItem, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrderItem) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderItemDo
	Assign(attrs ...field.AssignExpr) IOmsOrderItemDo
	Joins(fields ...field.RelationField) IOmsOrderItemDo
	Preload(fields ...field.RelationField) IOmsOrderItemDo
	FirstOrInit() (*model.OmsOrderItem, error)
	FirstOrCreate() (*model.OmsOrderItem, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrderItem, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderItemDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderOperateHistoryDo

type IOmsOrderOperateHistoryDo interface {
	gen.SubQuery
	Debug() IOmsOrderOperateHistoryDo
	WithContext(ctx context.Context) IOmsOrderOperateHistoryDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderOperateHistoryDo
	WriteDB() IOmsOrderOperateHistoryDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderOperateHistoryDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderOperateHistoryDo
	Not(conds ...gen.Condition) IOmsOrderOperateHistoryDo
	Or(conds ...gen.Condition) IOmsOrderOperateHistoryDo
	Select(conds ...field.Expr) IOmsOrderOperateHistoryDo
	Where(conds ...gen.Condition) IOmsOrderOperateHistoryDo
	Order(conds ...field.Expr) IOmsOrderOperateHistoryDo
	Distinct(cols ...field.Expr) IOmsOrderOperateHistoryDo
	Omit(cols ...field.Expr) IOmsOrderOperateHistoryDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderOperateHistoryDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderOperateHistoryDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderOperateHistoryDo
	Group(cols ...field.Expr) IOmsOrderOperateHistoryDo
	Having(conds ...gen.Condition) IOmsOrderOperateHistoryDo
	Limit(limit int) IOmsOrderOperateHistoryDo
	Offset(offset int) IOmsOrderOperateHistoryDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderOperateHistoryDo
	Unscoped() IOmsOrderOperateHistoryDo
	Create(values ...*model.OmsOrderOperateHistory) error
	CreateInBatches(values []*model.OmsOrderOperateHistory, batchSize int) error
	Save(values ...*model.OmsOrderOperateHistory) error
	First() (*model.OmsOrderOperateHistory, error)
	Take() (*model.OmsOrderOperateHistory, error)
	Last() (*model.OmsOrderOperateHistory, error)
	Find() ([]*model.OmsOrderOperateHistory, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrderOperateHistory, err error)
	FindInBatches(result *[]*model.OmsOrderOperateHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrderOperateHistory) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderOperateHistoryDo
	Assign(attrs ...field.AssignExpr) IOmsOrderOperateHistoryDo
	Joins(fields ...field.RelationField) IOmsOrderOperateHistoryDo
	Preload(fields ...field.RelationField) IOmsOrderOperateHistoryDo
	FirstOrInit() (*model.OmsOrderOperateHistory, error)
	FirstOrCreate() (*model.OmsOrderOperateHistory, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrderOperateHistory, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderOperateHistoryDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderReturnApplyDo

type IOmsOrderReturnApplyDo interface {
	gen.SubQuery
	Debug() IOmsOrderReturnApplyDo
	WithContext(ctx context.Context) IOmsOrderReturnApplyDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderReturnApplyDo
	WriteDB() IOmsOrderReturnApplyDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderReturnApplyDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderReturnApplyDo
	Not(conds ...gen.Condition) IOmsOrderReturnApplyDo
	Or(conds ...gen.Condition) IOmsOrderReturnApplyDo
	Select(conds ...field.Expr) IOmsOrderReturnApplyDo
	Where(conds ...gen.Condition) IOmsOrderReturnApplyDo
	Order(conds ...field.Expr) IOmsOrderReturnApplyDo
	Distinct(cols ...field.Expr) IOmsOrderReturnApplyDo
	Omit(cols ...field.Expr) IOmsOrderReturnApplyDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderReturnApplyDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderReturnApplyDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderReturnApplyDo
	Group(cols ...field.Expr) IOmsOrderReturnApplyDo
	Having(conds ...gen.Condition) IOmsOrderReturnApplyDo
	Limit(limit int) IOmsOrderReturnApplyDo
	Offset(offset int) IOmsOrderReturnApplyDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderReturnApplyDo
	Unscoped() IOmsOrderReturnApplyDo
	Create(values ...*model.OmsOrderReturnApply) error
	CreateInBatches(values []*model.OmsOrderReturnApply, batchSize int) error
	Save(values ...*model.OmsOrderReturnApply) error
	First() (*model.OmsOrderReturnApply, error)
	Take() (*model.OmsOrderReturnApply, error)
	Last() (*model.OmsOrderReturnApply, error)
	Find() ([]*model.OmsOrderReturnApply, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrderReturnApply, err error)
	FindInBatches(result *[]*model.OmsOrderReturnApply, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrderReturnApply) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderReturnApplyDo
	Assign(attrs ...field.AssignExpr) IOmsOrderReturnApplyDo
	Joins(fields ...field.RelationField) IOmsOrderReturnApplyDo
	Preload(fields ...field.RelationField) IOmsOrderReturnApplyDo
	FirstOrInit() (*model.OmsOrderReturnApply, error)
	FirstOrCreate() (*model.OmsOrderReturnApply, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrderReturnApply, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderReturnApplyDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderReturnReasonDo

type IOmsOrderReturnReasonDo interface {
	gen.SubQuery
	Debug() IOmsOrderReturnReasonDo
	WithContext(ctx context.Context) IOmsOrderReturnReasonDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderReturnReasonDo
	WriteDB() IOmsOrderReturnReasonDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderReturnReasonDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderReturnReasonDo
	Not(conds ...gen.Condition) IOmsOrderReturnReasonDo
	Or(conds ...gen.Condition) IOmsOrderReturnReasonDo
	Select(conds ...field.Expr) IOmsOrderReturnReasonDo
	Where(conds ...gen.Condition) IOmsOrderReturnReasonDo
	Order(conds ...field.Expr) IOmsOrderReturnReasonDo
	Distinct(cols ...field.Expr) IOmsOrderReturnReasonDo
	Omit(cols ...field.Expr) IOmsOrderReturnReasonDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderReturnReasonDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderReturnReasonDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderReturnReasonDo
	Group(cols ...field.Expr) IOmsOrderReturnReasonDo
	Having(conds ...gen.Condition) IOmsOrderReturnReasonDo
	Limit(limit int) IOmsOrderReturnReasonDo
	Offset(offset int) IOmsOrderReturnReasonDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderReturnReasonDo
	Unscoped() IOmsOrderReturnReasonDo
	Create(values ...*model.OmsOrderReturnReason) error
	CreateInBatches(values []*model.OmsOrderReturnReason, batchSize int) error
	Save(values ...*model.OmsOrderReturnReason) error
	First() (*model.OmsOrderReturnReason, error)
	Take() (*model.OmsOrderReturnReason, error)
	Last() (*model.OmsOrderReturnReason, error)
	Find() ([]*model.OmsOrderReturnReason, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrderReturnReason, err error)
	FindInBatches(result *[]*model.OmsOrderReturnReason, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrderReturnReason) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderReturnReasonDo
	Assign(attrs ...field.AssignExpr) IOmsOrderReturnReasonDo
	Joins(fields ...field.RelationField) IOmsOrderReturnReasonDo
	Preload(fields ...field.RelationField) IOmsOrderReturnReasonDo
	FirstOrInit() (*model.OmsOrderReturnReason, error)
	FirstOrCreate() (*model.OmsOrderReturnReason, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrderReturnReason, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderReturnReasonDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IOmsOrderSettingDo

type IOmsOrderSettingDo interface {
	gen.SubQuery
	Debug() IOmsOrderSettingDo
	WithContext(ctx context.Context) IOmsOrderSettingDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IOmsOrderSettingDo
	WriteDB() IOmsOrderSettingDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IOmsOrderSettingDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IOmsOrderSettingDo
	Not(conds ...gen.Condition) IOmsOrderSettingDo
	Or(conds ...gen.Condition) IOmsOrderSettingDo
	Select(conds ...field.Expr) IOmsOrderSettingDo
	Where(conds ...gen.Condition) IOmsOrderSettingDo
	Order(conds ...field.Expr) IOmsOrderSettingDo
	Distinct(cols ...field.Expr) IOmsOrderSettingDo
	Omit(cols ...field.Expr) IOmsOrderSettingDo
	Join(table schema.Tabler, on ...field.Expr) IOmsOrderSettingDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IOmsOrderSettingDo
	RightJoin(table schema.Tabler, on ...field.Expr) IOmsOrderSettingDo
	Group(cols ...field.Expr) IOmsOrderSettingDo
	Having(conds ...gen.Condition) IOmsOrderSettingDo
	Limit(limit int) IOmsOrderSettingDo
	Offset(offset int) IOmsOrderSettingDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IOmsOrderSettingDo
	Unscoped() IOmsOrderSettingDo
	Create(values ...*model.OmsOrderSetting) error
	CreateInBatches(values []*model.OmsOrderSetting, batchSize int) error
	Save(values ...*model.OmsOrderSetting) error
	First() (*model.OmsOrderSetting, error)
	Take() (*model.OmsOrderSetting, error)
	Last() (*model.OmsOrderSetting, error)
	Find() ([]*model.OmsOrderSetting, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OmsOrderSetting, err error)
	FindInBatches(result *[]*model.OmsOrderSetting, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.OmsOrderSetting) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IOmsOrderSettingDo
	Assign(attrs ...field.AssignExpr) IOmsOrderSettingDo
	Joins(fields ...field.RelationField) IOmsOrderSettingDo
	Preload(fields ...field.RelationField) IOmsOrderSettingDo
	FirstOrInit() (*model.OmsOrderSetting, error)
	FirstOrCreate() (*model.OmsOrderSetting, error)
	FindByPage(offset int, limit int) (result []*model.OmsOrderSetting, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IOmsOrderSettingDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type Query

type Query struct {
	OmsCartItem            omsCartItem
	OmsCompanyAddress      omsCompanyAddress
	OmsOrder               omsOrder
	OmsOrderItem           omsOrderItem
	OmsOrderOperateHistory omsOrderOperateHistory
	OmsOrderReturnApply    omsOrderReturnApply
	OmsOrderReturnReason   omsOrderReturnReason
	OmsOrderSetting        omsOrderSetting
	// contains filtered or unexported fields
}

func Use

func Use(db *gorm.DB, opts ...gen.DOOption) *Query

func (*Query) Available

func (q *Query) Available() bool

func (*Query) Begin

func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx

func (*Query) ReadDB

func (q *Query) ReadDB() *Query

func (*Query) ReplaceDB

func (q *Query) ReplaceDB(db *gorm.DB) *Query

func (*Query) Transaction

func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error

func (*Query) WithContext

func (q *Query) WithContext(ctx context.Context) *queryCtx

func (*Query) WriteDB

func (q *Query) WriteDB() *Query

type QueryTx

type QueryTx struct {
	*Query
	Error error
}

func (*QueryTx) Commit

func (q *QueryTx) Commit() error

func (*QueryTx) Rollback

func (q *QueryTx) Rollback() error

func (*QueryTx) RollbackTo

func (q *QueryTx) RollbackTo(name string) error

func (*QueryTx) SavePoint

func (q *QueryTx) SavePoint(name string) error