user.gen.go

// Code generated by 'micro gen' command.
// DO NOT EDIT!

package model

import (
	"database/sql"
	"time"

	"github.com/henrylee2cn/goutil/coarsetime"
	tp "github.com/henrylee2cn/teleport"
	"github.com/xiaoenai/tp-micro/model/mysql"
	"github.com/xiaoenai/tp-micro/model/sqlx"
)

// User user info
type User struct {
	Id        int64  `json:"id"`
	Name      string `json:"name"`
	Age       int32  `json:"age"`
	CreatedAt int64  `json:"created_at"`
	UpdatedAt int64  `json:"updated_at"`
}

// TableName implements 'github.com/xiaoenai/tp-micro/model'.Cacheable
func (*User) TableName() string {
	return "user"
}

var userDB, _ = dbHandler.RegCacheableDB(new(User), time.Hour*24, ``)

// GetUserDB returns the User DB handler.
func GetUserDB() *mysql.CacheableDB {
	return userDB
}

// InsertUser insert a User data into database.
// NOTE:
//  Without cache layer.
func InsertUser(_u *User, tx ...*sqlx.Tx) (int64, error) {
	_u.UpdatedAt = coarsetime.FloorTimeNow().Unix()
	if _u.CreatedAt == 0 {
		_u.CreatedAt = _u.UpdatedAt
	}
	err := userDB.Callback(func(tx sqlx.DbOrTx) error {
		var query string
		if _u.Id > 0 {
			query = "INSERT INTO `user` (id,`name`,`age`,`created_at`,`updated_at`)VALUES(:id,:name,:age,:created_at,:updated_at);"
		} else {
			query = "INSERT INTO `user` (`name`,`age`,`created_at`,`updated_at`)VALUES(:name,:age,:created_at,:updated_at);"
		}
		r, err := tx.NamedExec(query, _u)
		if err != nil {
			return err
		}
		id, err := r.LastInsertId()
		if err != nil {
			return err
		}
		_u.Id = id
		return nil
	}, tx...)
	return _u.Id, err
}

// UpdateUserByPrimary update the User data in database by primary key.
// NOTE:
//  With cache layer;
//  _updateFields' members must be snake format;
//  Automatic update updated_at field;
//  Don't update the primary key and the created_at key;
//  Update all fields except the primary key and the created_at key if _updateFields is empty.
func UpdateUserByPrimary(_u *User, _updateFields []string, tx ...*sqlx.Tx) error {
	_u.UpdatedAt = coarsetime.FloorTimeNow().Unix()
	err := userDB.Callback(func(tx sqlx.DbOrTx) error {
		query := "UPDATE `user` SET "
		if len(_updateFields) == 0 {
			query += "`name`=:name,`age`=:age,`updated_at`=:updated_at WHERE id=:id LIMIT 1;"
		} else {
			for _, s := range _updateFields {
				if s == "updated_at" || s == "id" || s == "created_at" {
					continue
				}
				query += "`" + s + "`=:" + s + ","
			}
			if query[len(query)-1] != ',' {
				return nil
			}
			query += "`updated_at`=:updated_at WHERE id=:id LIMIT 1;"
		}
		_, err := tx.NamedExec(query, _u)
		return err
	}, tx...)
	if err != nil {
		return err
	}
	err = userDB.DeleteCache(_u)
	if err != nil {
		tp.Errorf("%s", err.Error())
	}
	return nil
}

// UpsertUser insert or update the User data by primary key.
// NOTE:
//  With cache layer;
//  Insert data if the primary key is specified;
//  Update data based on _updateFields if no primary key is specified;
//  _updateFields' members must be snake format;
//  Automatic update updated_at field;
//  Don't update the primary key and the created_at key;
//  Update all fields except the primary key and the created_at key if _updateFields is empty.
func UpsertUser(_u *User, _updateFields []string, tx ...*sqlx.Tx) (int64, error) {
	if _u.Id <= 0 {
		return InsertUser(_u, tx...)
	}
	if _u.UpdatedAt == 0 {
		_u.UpdatedAt = coarsetime.FloorTimeNow().Unix()
	}
	if _u.CreatedAt == 0 {
		_u.CreatedAt = _u.UpdatedAt
	}
	err := userDB.Callback(func(tx sqlx.DbOrTx) error {
		query := "INSERT INTO `user` (id,`name`,`age`,`created_at`,`updated_at`)VALUES(:id,:name,:age,:created_at,:updated_at)" +
			" ON DUPLICATE KEY UPDATE "
		if len(_updateFields) == 0 {
			query += "`name`=VALUES(`name`),`age`=VALUES(`age`),`updated_at`=VALUES(`updated_at`);"
		} else {
			for _, s := range _updateFields {
				if s == "updated_at" || s == "id" || s == "created_at" {
					continue
				}
				query += "`" + s + "`=VALUES(`" + s + "`),"
			}
			if query[len(query)-1] != ',' {
				return nil
			}
			query += "`updated_at`=VALUES(`updated_at`);"
		}
		_, err := tx.NamedExec(query, _u)
		return err
	}, tx...)
	if err != nil {
		return 0, err
	}
	err = userDB.DeleteCache(_u)
	if err != nil {
		tp.Errorf("%s", err.Error())
	}
	return _u.Id, nil
}

// DeleteUserByPrimary delete a User data in database by primary key.
// NOTE:
//  With cache layer.
func DeleteUserByPrimary(id int64, tx ...*sqlx.Tx) error {
	err := userDB.Callback(func(tx sqlx.DbOrTx) error {
		_, err := tx.Exec("DELETE FROM `user` WHERE id=?;", id)
		return err
	}, tx...)
	if err != nil {
		return err
	}
	err = userDB.PutCache(&User{
		Id: id,
	})
	if err != nil {
		tp.Errorf("%s", err.Error())
	}
	return nil
}

// GetUserByPrimary query a User data from database by primary key.
// NOTE:
//  With cache layer;
//  If @return bool=false error=nil, means the data is not exist.
func GetUserByPrimary(id int64) (*User, bool, error) {
	var _u = &User{
		Id: id,
	}
	err := userDB.CacheGet(_u)
	switch err {
	case nil:
		if _u.CreatedAt == 0 {
			return nil, false, nil
		}
		return _u, true, nil
	case sql.ErrNoRows:
		err2 := userDB.PutCache(_u)
		if err2 != nil {
			tp.Errorf("%s", err2.Error())
		}
		return nil, false, nil
	default:
		return nil, false, err
	}
}

// BindUserByFields query the User data from database by field keys, and bind it to _u.
// NOTE:
//  With cache layer;
//  _fields' members should be snake format;
//  Query by the primary key field if fields is empty;
//  If @return bool=false error=nil, means the data is not exist.
func BindUserByFields(_u *User, _fields ...string) (bool, error) {
	err := userDB.CacheGet(_u, _fields...)
	switch err {
	case nil:
		if _u.CreatedAt == 0 {
			return false, nil
		}
		return true, nil
	case sql.ErrNoRows:
		err2 := userDB.PutCache(_u)
		if err2 != nil {
			tp.Errorf("%s", err2.Error())
		}
		return false, nil
	default:
		return false, err
	}
}

// BindUserByWhere query the User data from database by WHERE condition(whereNamedCond), and bind it to _u.
// NOTE:
//  With cache layer;
//  If @return bool=false error=nil, means the data is not exist;
//  whereNamedCond e.g. 'id=:id AND created_at>1520000000'.
func BindUserByWhere(_u *User, whereNamedCond string) (bool, error) {
	err := userDB.CacheGetByWhere(_u, whereNamedCond)
	switch err {
	case nil:
		if _u.CreatedAt == 0 {
			return false, nil
		}
		return true, nil
	case sql.ErrNoRows:
		err2 := userDB.PutCache(_u)
		if err2 != nil {
			tp.Errorf("%s", err2.Error())
		}
		return false, nil
	default:
		return false, err
	}
}

// GetUserByWhere query a User data from database by WHERE condition.
// NOTE:
//  Without cache layer;
//  If @return bool=false error=nil, means the data is not exist.
func GetUserByWhere(whereCond string, arg ...interface{}) (*User, bool, error) {
	var _u = new(User)
	err := userDB.Get(_u, "SELECT id,`name`,`age`,`created_at`,`updated_at` FROM `user` WHERE "+whereCond+" LIMIT 1;", arg...)
	switch err {
	case nil:
		return _u, true, nil
	case sql.ErrNoRows:
		return nil, false, nil
	default:
		return nil, false, err
	}
}

// SelectUserByWhere query some User data from database by WHERE condition.
// NOTE:
//  Without cache layer.
func SelectUserByWhere(whereCond string, arg ...interface{}) ([]*User, error) {
	var objs = new([]*User)
	err := userDB.Select(objs, "SELECT id,`name`,`age`,`created_at`,`updated_at` FROM `user` WHERE "+whereCond, arg...)
	return *objs, err
}

// CountUserByWhere count User data number from database by WHERE condition.
// NOTE:
//  Without cache layer.
func CountUserByWhere(whereCond string, arg ...interface{}) (int64, error) {
	var count int64
	err := userDB.Get(&count, "SELECT count(1) FROM `user` WHERE "+whereCond, arg...)
	return count, err
}