toolset/console/commands/pgorm/pgsql.go.subtext

type Orm{orm_table_name} struct {
	db *gorm.DB
}

func (orm *Orm{orm_table_name}) GetDB() *gorm.DB {
	return orm.db
}

func (orm *Orm{orm_table_name}) GetTableInfo() interface{} {
	return &{orm_table_name}{}
}

// Create insert the value into database
func (orm *Orm{orm_table_name}) Create(value interface{}) *gorm.DB {
	return orm.db.Create(value)
}

// CreateInBatches insert the value in batches into database
func (orm *Orm{orm_table_name}) CreateInBatches(value interface{}, batchSize int) *gorm.DB {
	return orm.db.CreateInBatches(value, batchSize)
}

// Save update value in database, if the value doesn't have primary key, will insert it
func (orm *Orm{orm_table_name}) Save(value interface{}) *gorm.DB {
	return orm.db.Save(value)
}

func (orm *Orm{orm_table_name}) Row() *sql.Row {
	return orm.db.Row()
}

func (orm *Orm{orm_table_name}) Rows() (*sql.Rows, error) {
	return orm.db.Rows()
}

// Scan scan value to a struct
func (orm *Orm{orm_table_name}) Scan(dest interface{}) *gorm.DB {
	return orm.db.Scan(dest)
}

func (orm *Orm{orm_table_name}) ScanRows(rows *sql.Rows, dest interface{}) error {
	return orm.db.ScanRows(rows, dest)
}

// Connection  use a db conn to execute Multiple commands,this conn will put conn pool after it is executed.
func (orm *Orm{orm_table_name}) Connection(fc func(tx *gorm.DB) error) (err error) {
	return orm.db.Connection(fc)
}

// Transaction start a transaction as a block, return error will rollback, otherwise to commit.
func (orm *Orm{orm_table_name}) Transaction(fc func(tx *gorm.DB) error, opts ...*sql.TxOptions) (err error) {
	return orm.db.Transaction(fc, opts...)
}

// Begin begins a transaction
func (orm *Orm{orm_table_name}) Begin(opts ...*sql.TxOptions) *gorm.DB {
	return orm.db.Begin(opts...)
}

// Commit commit a transaction
func (orm *Orm{orm_table_name}) Commit() *gorm.DB {
	return orm.db.Commit()
}

// Rollback rollback a transaction
func (orm *Orm{orm_table_name}) Rollback() *gorm.DB {
	return orm.db.Rollback()
}

func (orm *Orm{orm_table_name}) SavePoint(name string) *gorm.DB {
	return orm.db.SavePoint(name)
}

func (orm *Orm{orm_table_name}) RollbackTo(name string) *gorm.DB {
	return orm.db.RollbackTo(name)
}

// Exec execute raw sql
func (orm *Orm{orm_table_name}) Exec(sql string, values ...interface{}) *gorm.DB {
	return orm.db.Exec(sql, values...)
}

// Exists 检索对象是否存在
func (orm *Orm{orm_table_name}) Exists() (bool, error) {
	dest := &struct {
		H int `json:"h"`
	}{}
	db := orm.db.Select("1 as h").Limit(1).Find(dest)
	return dest.H == 1, db.Error
}

func (orm *Orm{orm_table_name}) Unscoped() *Orm{orm_table_name} {
	orm.db.Unscoped()
	return orm
}
// ------------ 以下是单表独有的函数, 便捷字段条件, Laravel风格操作 ---------

func (orm *Orm{orm_table_name}) Insert(row *{orm_table_name}) error {
	return orm.db.Create(row).Error
}

func (orm *Orm{orm_table_name}) Inserts(rows []*{orm_table_name}) *gorm.DB {
	return orm.db.Create(rows)
}

func (orm *Orm{orm_table_name}) Order(value interface{}) *Orm{orm_table_name} {
	orm.db.Order(value)
	return orm
}

func (orm *Orm{orm_table_name}) Group(name string) *Orm{orm_table_name} {
	orm.db.Group(name)
	return orm
}

func (orm *Orm{orm_table_name}) Limit(limit int) *Orm{orm_table_name} {
	orm.db.Limit(limit)
	return orm
}

func (orm *Orm{orm_table_name}) Offset(offset int) *Orm{orm_table_name} {
	orm.db.Offset(offset)
	return orm
}
// Get 直接查询列表, 如果需要条数, 使用Find()
func (orm *Orm{orm_table_name}) Get() {orm_table_name}List {
	got, _ := orm.Find()
	return got
}

// Pluck used to query single column from a model as a map
//     var ages []int64
//     db.Model(&users).Pluck("age", &ages)
func (orm *Orm{orm_table_name}) Pluck(column string, dest interface{}) *gorm.DB {
	return orm.db.Pluck(column, dest)
}

// Delete 有条件删除
func (orm *Orm{orm_table_name}) Delete(conds ...interface{}) *gorm.DB {
	return orm.db.Delete(&{orm_table_name}{}, conds...)
}

// DeleteAll 删除所有
func (orm *Orm{orm_table_name}) DeleteAll() *gorm.DB {
	return orm.db.Exec("DELETE FROM {table_name}")
}

func (orm *Orm{orm_table_name}) Count() int64 {
	var count int64
	orm.db.Count(&count)
	return count
}

// First 检索单个对象
func (orm *Orm{orm_table_name}) First(conds ...interface{}) (*{orm_table_name}, bool) {
	dest := &{orm_table_name}{}
	db := orm.db.Limit(1).Find(dest, conds...)
	return dest, db.RowsAffected == 1
}

// Take return a record that match given conditions, the order will depend on the database implementation
func (orm *Orm{orm_table_name}) Take(conds ...interface{}) (*{orm_table_name}, int64) {
	dest := &{orm_table_name}{}
	db := orm.db.Take(dest, conds...)
	return dest, db.RowsAffected
}

// Last find last record that match given conditions, order by primary key
func (orm *Orm{orm_table_name}) Last(conds ...interface{}) (*{orm_table_name}, int64) {
	dest := &{orm_table_name}{}
	db := orm.db.Last(dest, conds...)
	return dest, db.RowsAffected
}

func (orm *Orm{orm_table_name}) Find(conds ...interface{}) ({orm_table_name}List, int64) {
	list := make([]*{orm_table_name}, 0)
	tx := orm.db.Find(&list, conds...)
	if tx.Error != nil {
		logrus.Error(tx.Error)
	}
	return list, tx.RowsAffected
}

// Paginate 分页
func (orm *Orm{orm_table_name}) Paginate(page int, limit int) ({orm_table_name}List, int64) {
	var total int64
	list := make([]*{orm_table_name}, 0)
	orm.db.Count(&total)
	if total > 0 {
		if page == 0 {
			page = 1
		}

		offset := (page - 1) * limit
		tx := orm.db.Offset(offset).Limit(limit).Find(&list)
		if tx.Error != nil {
			logrus.Error(tx.Error)
		}
	}

	return list, total
}

// SimplePaginate 不统计总数的分页
func (orm *Orm{orm_table_name}) SimplePaginate(page int, limit int) {orm_table_name}List {
	list := make([]*{orm_table_name}, 0)
    if page == 0 {
        page = 1
    }
    offset := (page - 1) * limit
    tx := orm.db.Offset(offset).Limit(limit).Find(&list)
    if tx.Error != nil {
        logrus.Error(tx.Error)
    }
	return list
}

// FindInBatches find records in batches
func (orm *Orm{orm_table_name}) FindInBatches(dest interface{}, batchSize int, fc func(tx *gorm.DB, batch int) error) *gorm.DB {
	return orm.db.FindInBatches(dest, batchSize, fc)
}

// FirstOrInit gets the first matched record or initialize a new instance with given conditions (only works with struct or map conditions)
func (orm *Orm{orm_table_name}) FirstOrInit(dest *{orm_table_name}, conds ...interface{}) (*{orm_table_name}, *gorm.DB) {
	return dest, orm.db.FirstOrInit(dest, conds...)
}

// FirstOrCreate gets the first matched record or create a new one with given conditions (only works with struct, map conditions)
func (orm *Orm{orm_table_name}) FirstOrCreate(dest interface{}, conds ...interface{}) *gorm.DB {
	return orm.db.FirstOrCreate(dest, conds...)
}

// Update update attributes with callbacks, refer: https://gorm.io/docs/update.html#Update-Changed-Fields
func (orm *Orm{orm_table_name}) Update(column string, value interface{}) *gorm.DB {
	return orm.db.Update(column, value)
}

// Updates update attributes with callbacks, refer: https://gorm.io/docs/update.html#Update-Changed-Fields
func (orm *Orm{orm_table_name}) Updates(values interface{}) *gorm.DB {
	return orm.db.Updates(values)
}

func (orm *Orm{orm_table_name}) UpdateColumn(column string, value interface{}) *gorm.DB {
	return orm.db.UpdateColumn(column, value)
}

func (orm *Orm{orm_table_name}) UpdateColumns(values interface{}) *gorm.DB {
	return orm.db.UpdateColumns(values)
}

func (orm *Orm{orm_table_name}) Where(query interface{}, args ...interface{}) *Orm{orm_table_name} {
	orm.db.Where(query, args...)
	return orm
}

func (orm *Orm{orm_table_name}) Select(query interface{}, args ...interface{}) *Orm{orm_table_name} {
	orm.db.Select(query, args...)
	return orm
}

func (orm *Orm{orm_table_name}) Sum(field string) int64 {
	type result struct {
		S int64 `json:"s"`
	}
	ret := result{}
	orm.db.Select("SUM(\""+field+"\") AS s").Scan(&ret)
	return ret.S
}

// Preload preload associations with given conditions
// db.Preload("Orders|orders", "state NOT IN (?)", "cancelled").Find(&users)
func (orm *Orm{orm_table_name}) Preload(query string, args ...interface{}) *Orm{orm_table_name} {
    arr := strings.Split(query, ".")
    for i, _ := range arr {
        arr[i] = home.StringToHump(arr[i])
    }
    orm.db.Preload(strings.Join(arr, "."), args...)
    return orm
}

// Joins specify Joins conditions
// db.Joins("Account|account").Find(&user)
// db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Find(&user)
// db.Joins("Account", DB.Select("id").Where("user_id = users.id AND name = ?", "someName").Model(&Account{}))
func (orm *Orm{orm_table_name}) Joins(query string, args ...interface{}) *Orm{orm_table_name} {
	if !strings.Contains(query, " ") {
	    query = home.StringToHump(query)
	}
	orm.db.Joins(query, args...)
	return orm
}