大佬写的orm框架，mark一下稍后阅读

package db

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"reflect"
	"strconv"
	"util"
)

// 数据库操作处理结构体
type DB struct {
	pool  *sql.DB
	prefix string
	table  string
	field  string
	where  string
	group  string
	having string
	order  string
	limit  string
	args   map[string][]interface{}
}

func Open(c map[string]string)(dbPool DB,err error) {
	//var dbPool DB //等同 dbPool = new(DB)
	dsn:= fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s",c["db_user"],c["db_pwd"],c["db_host"],c["db_port"],c["db_name"], "utf8mb4,utf8")
	connPool,err:= sql.Open("mysql", dsn)//创建连接池，此时只是初始化了连接池，并没有连接数据库
	if err!= nil {
		return
	}
	connMaxOpen := util.Str_to_int(c["db_max_open"],10)
	connMaxIdle := util.Str_to_int(c["db_max_idle"],5)
	connPool.SetMaxOpenConns(connMaxOpen)//是设置的最大连接数，也就是甭管你多少并发，只能最多创建N条tcp连接，还有要注意的一点是，当执行完sql，连接转移到rows对象上，如果rows不关闭，这条连接不会被放回池里，其他并发获取不到连接会被阻塞住。
	connPool.SetMaxIdleConns(connMaxIdle)//是设置的执行完闲置的连接，这些就算是执行结束了连接还是会保留着的   简单点理解 上面那个是最大连接数  下面这个是最小连接数
   //connPool.SetConnMaxLifetime(time.Second * 15) //设置连接超时时间 一般不用设置 这样空置的连接会被一直保持 等待被复用
	err = connPool.Ping()
	if err != nil {
		return
    }
	dbPool.pool = connPool
	dbPool.prefix = c["db_prefix"]
	return
}

//表名
func (this DB) Table(name string) DB {
	this.table = fmt.Sprintf("%s%s",this.prefix,name)
	return this
}

//字段
func (this DB) Field(name string) DB {
	this.field = name
	return this
}

//条件语句
func (this DB) Where(query string, params ...interface{}) DB {
	this.where = query
	if(len(this.args)>0){//已有值
		this.args["where"] = params
	}else{
		this.args = map[string][]interface{}{"where":params}
	}
	return this
}

//排序
func (this DB) Order(params string) DB {
	this.order = params
	return this
}

//分组
func (this DB) Group(params string) DB {
	this.group = params
	return this
}

//分组 HAVING
func (this DB) Having(query string, params ...interface{}) DB {
	this.having = query
	if(len(this.args)>0){//已有值
		this.args["having"] = params
	}else{
		this.args = map[string][]interface{}{"having":params}
	}
	return this
}

//限制
func (this DB) Limit(params string) DB {
	this.limit = params
	return this
}

//-------------------------------------------------------------------------------------------------------------------------------------------------
// 获取第一条数据,返回数据类型为map
func (this DB) Get() map[string]interface{} {
	var RetOne map[string]interface{}
	this.limit = "1"
	GetSql := this.build_sql()
	GetArg := this.build_arg()
	rows, err := this.pool.Query(GetSql,GetArg...)
	if err != nil {
		log.Print("Get查询错误 ",GetSql,err)
		return RetOne
	}
	RetMap:= dealMysqlRows(rows)
	if len(RetMap) > 0 {
		RetOne = RetMap[0]
	}
	return RetOne
}
//获取单条数据的特定字段数据
func (this DB) GetVal(field string) interface{} {
	this.field = field
	RetMap:= this.Get()
	RetOne:= RetMap[field]
	return RetOne
}
//获取多条数据
func (this DB) GetList() []map[string]interface{} {
	GetSql := this.build_sql()
	GetArg := this.build_arg()
	rows, err := this.pool.Query(GetSql,GetArg...)
	if err != nil {
		log.Print("GetList查询错误 ",GetSql,err)
		return nil
	}
	RetMap := dealMysqlRows(rows)
	return RetMap
}
//判断是否有对应数据
func (this DB) Has() int{
	GetSql := "SELECT EXISTS(" + this.build_sql() + ")"
	GetArg := this.build_arg()
	rows,err:= this.pool.Query(GetSql,GetArg...)
	if err != nil {
		log.Print("Has查询错误 ",GetSql,err)
		return 0
	}
	RetMap := dealMysqlRows(rows)
	var RetOne int
	for _,v:= range RetMap[0]{
		i,err:= strconv.Atoi(reflect.ValueOf(v).String())
        if(err!=nil){
			RetOne = 0
		}else{
			RetOne = i
		}
	}
	return RetOne
}
//新增
func (this DB) Insert(d map[string]interface{})(int,error){
	var Args []interface{}
	InsertTable,InsertCols,InsertArgs := this.table,"",""
	this.table = ""
	for k, v := range d {
		// 数据列只能为string类型
		if InsertCols == "" {
			InsertCols += fmt.Sprintf("%s", k)
			InsertArgs += "?"
		} else {
			InsertCols += fmt.Sprintf(",%s", k)
			InsertArgs += ",?"
		}
		Args = append(Args,v)
	}
	// 组合数据写入SQL
	Sql := fmt.Sprintf("INSERT INTO %v (%v) VALUES (%v);", InsertTable, InsertCols, InsertArgs)
	retData, err1 := this.pool.Exec(Sql,Args...)
	if err1 != nil {
		log.Print("Insert错误 ",Sql,err1)
		return 0, nil
	}
	LastId, err2 := retData.LastInsertId()
	if err2 != nil {
		log.Print("Insert错误 ",Sql,err2)
		return 0, err2
	}
	return int(LastId), err2
}
//更新
func (this DB) Update(d map[string]interface{})(int,error){
	var Args []interface{}
	UpdateTable,UpdateArgs,UpdateWhere,UpdateOrder,UpdateLimit:= this.table,"","","",""
	this.table = ""
	for k, v := range d {
		// 数据列只能为string类型
		if UpdateArgs == "" {
			UpdateArgs += fmt.Sprintf("%s=?", k)
		} else {
			UpdateArgs += fmt.Sprintf(",%s=?", k)
		}
		Args = append(Args,v)
	}
	if len(this.where) > 0 {
		UpdateWhere = fmt.Sprintf(" WHERE %v", this.where)
		this.where = ""
		if(len(this.args)>0) {
			if (len(this.args["where"]) > 0) {
				Args = append(Args, this.args["where"]...)
			}
			this.args = nil
		}
	}else{//如果没有更新条件不更新 提示出错
		log.Print("Update错误 无更新条件")
		return 0, nil
	}
	if(len(this.order)>0) {
		UpdateOrder = fmt.Sprintf(" ORDER BY %v", this.order)
		this.order = ""
	}
	if(len(this.limit)>0) {
		UpdateLimit = fmt.Sprintf(" LIMIT %v", this.limit)
		this.limit = ""
	}
	Sql := fmt.Sprintf("UPDATE %v SET %v %v%v%v;",UpdateTable,UpdateArgs,UpdateWhere,UpdateOrder,UpdateLimit)
	retData, err1 := this.pool.Exec(Sql,Args...)
	if err1 != nil {
		log.Print("Update错误 ",Sql,err1)
		return 0, nil
	}
	ARows, err2 := retData.RowsAffected()
	if err2 != nil {
		log.Print("Update错误 ",Sql,err2)
		return 0, err2
	}
	return int(ARows), nil
}
//删除
func (this DB) Delete()(int,error){
	var Args []interface{}
	DeleteTable,DeleteWhere,DeleteOrder,DeleteLimit:= this.table,"","",""
	this.table = ""
	if len(this.where) > 0 {
		DeleteWhere = fmt.Sprintf(" WHERE %v", this.where)
		this.where = ""
		if(len(this.args)>0) {
			if (len(this.args["where"]) > 0) {
				Args = append(Args, this.args["where"]...)
			}
			this.args = nil
		}
	}else{//如果无条件不删除 提示出错
		log.Print("Delete错误 无删除条件")
		return 0, nil
	}
	if(len(this.order)>0) {
		DeleteOrder = fmt.Sprintf(" ORDER BY %v", this.order)
		this.order = ""
	}
	if(len(this.limit)>0) {
		DeleteLimit = fmt.Sprintf(" LIMIT %v", this.limit)
		this.limit = ""
	}
	// 组合删除数据SQL
	Sql := fmt.Sprintf("DELETE FROM %v%v%v%v;",DeleteTable,DeleteWhere,DeleteOrder,DeleteLimit)
	fmt.Println(Sql)
	retData, err1 := this.pool.Exec(Sql,Args...)
	if err1 != nil {
		log.Print("Delete错误 ",Sql,err1)
		return 0, err1
	}
	ARows, err2 := retData.RowsAffected()
	if err2 != nil {
		log.Print("Delete错误 ",Sql,err2)
		return 0, err2
	}
	return int(ARows), nil
}
//原生
func (this DB) Query(Sql string,Args ...interface{}) []map[string]interface{} {
	rows, err := this.pool.Query(Sql,Args...)
	if err != nil {
		log.Print("Query查询错误 ",Sql,err)
		return nil
	}
	RetMap := dealMysqlRows(rows)
	return RetMap
}
//表名前缀
func (this DB) Pre(table_name string) string{
	return fmt.Sprintf("%s%s",this.prefix,table_name)
}
//获取当前SQL
func (this DB) GetSql() string{
	return this.build_sql()
}
//-------------------------------------------------------------------------------------------------------------------------------------------------

//解析SQL 语句
func (this DB) build_sql() string {
	TableFilter,FieldFilter,WhereFilter,GroupFilter,HavingFilter,OrderFilter,LimitFilter:= this.table,"*","","","","",""
	if(len(TableFilter)>0) {
		this.table = ""
	}else{//如果表名为空 直接输出空
		return ""
	}
	if(len(this.field)>0) {
		FieldFilter = this.field
		this.field = ""
	}
	if len(this.where) > 0 {
		WhereFilter = fmt.Sprintf(" WHERE %v", this.where)
		this.where = ""
	}
	if(len(this.group)>0) {
		GroupFilter = fmt.Sprintf(" GROUP BY %v", this.group)
		this.group = ""
	}
	if(len(this.having)>0) {
		HavingFilter = fmt.Sprintf(" HAVING %v", this.having)
	}
	if(len(this.order)>0) {
		OrderFilter = fmt.Sprintf(" ORDER BY %v", this.order)
		this.order = ""
	}
	if(len(this.limit)>0) {
		LimitFilter = fmt.Sprintf(" LIMIT %v", this.limit)
		this.limit = ""
	}
	Sql := fmt.Sprintf("SELECT %v FROM %v%v%v%v%v%v", FieldFilter, TableFilter, WhereFilter, GroupFilter, HavingFilter, OrderFilter, LimitFilter)
	return Sql
}
//解析SQL 语句占位符 值
func (this DB) build_arg() []interface{} {
	var Args []interface{}
	if(len(this.args)>0) {
		if(len(this.args["where"])>0){
			Args = append(Args,this.args["where"]...)
		}
		if (len(this.args["having"]) > 0) {
			Args = append(Args,this.args["having"]...)
		}
		this.args = nil
	}
	return Args
}

// 数据库返回数据处理,返回数据类型为slice,slice内层为map
func dealMysqlRows(rows *sql.Rows) []map[string]interface{} {
	defer rows.Close()
	columns, _:= rows.Columns()// 获取列名
	columnTypes, _:= rows.ColumnTypes()
	// 获取每列的数据类型
	ColumnTypeMap := make(map[string]string)
	for _, v := range columnTypes {
		ColumnTypeMap[v.Name()] = v.DatabaseTypeName()
	}
	// 定义返回参数的slice
	retValues := make([]sql.RawBytes, len(columns))
	// 定义数据列名的slice
	scanArgs := make([]interface{}, len(retValues))
	// 数据列赋值
	for i := range retValues {
		scanArgs[i] = &retValues[i]
	}
	// 定义返回数据类型slice
	var resList []map[string]interface{}
	// 返回数据赋值
	for rows.Next() {
		// Scan将当前行各列结果填充进指定的各个值中
		_=rows.Scan(scanArgs...)
		// 内层数据格式
		rowMap := make(map[string]interface{})
		for i, colVal := range retValues {
			if colVal != nil {
				keyName := columns[i]
				value := string(colVal)
				// 数据类型转换
				switch ColumnTypeMap[keyName] {
					case "MEDIUMINT","INT","TINYINT":
						newValue, _ := strconv.Atoi(value)//字符串转int
						rowMap[keyName] = newValue
					case "VARCHAR":
						rowMap[keyName] = value
					case "DATETIME":
						//newValue, _ := time.ParseInLocation(value,value,time.Local)
						//rowMap[keyName] = newValue
						rowMap[keyName] = value
					default:
						rowMap[keyName] = value
				}
			}
		}
		resList = append(resList, rowMap)
	}
	return resList
}

大佬写的orm框架，mark一下稍后阅读