go orm库开发

gorm带来数据库操作的便捷深入人心，本文心血来潮简单编写一下基于go的数据库操作类

package orm

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "github.com/syyongx/php2go"
)

type Db struct {
    Conn        *sql.DB
    sqlUrl      string
    Row         *sql.Rows
    table       string
    fetchSql    bool
    Sql         string
    data        interface{}
    option      map[string]interface{}
}

//创建mysql 连接
func (db *Db) NewMysqlConn(sqlUrl string) ( *Db, error) {
    var err error
    db.sqlUrl = sqlUrl
    db.Conn, err = sql.Open("mysql", db.sqlUrl)
    db.option = make(map[string]interface{})
    return db,err
}

//设置连接信息
func (db *Db)SetConnectUrl(sqlUrl string) *Db {
    db.sqlUrl = sqlUrl
    return db
}
//设置table
func (db *Db)Table(tableName string) *Db {
    db.table = tableName
    return db
}
//获取返回值，获取一条
func (db *Db) Get() map[string]string{
    db.Result()
    columns, _ := db.Row.Columns()
    scanArgs := make([]interface{}, len(columns))
    values := make([]interface{}, len(columns))
    for j := range values {
        scanArgs[j] = &values[j]
    }
    record := make(map[string]string)
    for db.Row.Next() {
        //将行数据保存到record字典
        db.Row.Scan(scanArgs...)
        for i, v := range values {
            if v != nil {
                record[columns[i]] = string(v.([]byte))
            }
        }
    }
    return record
}

//获取所有
func (db *Db)dealResult() interface{} {
    res := db.Result()
    if db.fetchSql{
        return res
    }
    //返回所有列
    columns, _ := db.Row.Columns()
    //这里表示一行所有列的值，用[]byte表示
    vals := make([][]byte, len(columns))
    //这里表示一行填充数据
    scans := make([]interface{}, len(columns))
    //这里scans引用vals，把数据填充到[]byte里
    for k, _ := range vals {
        scans[k] = &vals[k]
    }
    i := 0
    result := make(map[int]map[string]string)
    for db.Row.Next() {
        //填充数据
        db.Row.Scan(scans...)
        //每行数据
        row := make(map[string]string)
        //把vals中的数据复制到row中
        for k, v := range vals {
            key := columns[k]
            //这里把[]byte数据转成string
            row[key] = string(v)
        }
        //放入结果集
        result[i] = row
        i++
    }
    return result
}

//查询
func (db *Db)Select() interface{} {
    return db.dealResult()
}

func (db *Db)Find() interface{} {
    res := db.dealResult()
    if db.fetchSql{
        return res
    }
    resMap := res.(map[int]map[string]string)
    return resMap[0]

}

//构造sql
func (db *Db)BuildSql()  {
    if db.Sql == ""{
        field,where,order,limit := "*","","",""
        if db.option["field"] != nil{
            field = db.filedHandle()
        }

        if db.option["where"] != nil{
            where = db.whereHandle()
        }

        if db.option["order"] != nil{
            order = " order by " + db.option["order"].(string)
        }

        if db.option["limit"] != nil{
            limit = " limit " + db.option["limit"].(string)
        }
        db.Sql = "select " + field + " from " + db.table + where + order + limit
    }
}
//field处理
func (db *Db) filedHandle() string {
    t := fmt.Sprintf("%T", db.option["field"])
    var field string
    switch t {
        case "string":
            field = db.option["field"].(string)
        case "[]string":
            for _,v :=range db.option["field"].([]string){
                field += v + ","
            }
            field = php2go.Rtrim(",")
    }
    return field
}

//where处理
func (db *Db) whereHandle() string {
    where := " where"
    whereType := "and"
    for _,v :=range db.option["where"].([]map[string]string){
        for key,value :=range v {
            where += " `" + key + "`='" + value + "' " + whereType
        }
    }
    where = php2go.Rtrim(where,whereType)
    return where
}
//写入数据
func (db *Db)Data(data interface{}) *Db {
    db.data = data
    return db
}

//Where条件
func (db *Db)Where(where map[string]string) *Db {
    if db.option["where"] == nil{
        db.option["where"] = []map[string]string{}
    }
    db.option["where"] = append(db.option["where"].([]map[string]string),where)
    return db
}

//WhereIn条件
func (db *Db)WhereIn(filed string,value interface{}) *Db  {
    return db
}

//Where条件
func (db *Db)WhereOr(where interface{}) *Db {
    db.option["where"] = where
    return db
}

//执行sql并返回结果
func (db *Db)Result() interface{} {
    var err error
    db.BuildSql()
    if db.fetchSql {
        return db.Sql
    }
    db.Row ,err = db.Conn.Query(db.Sql)
    if err != nil{
        panic(err)
    }
    return db
}

//直接执行sql
func (db *Db)Query(sql string) interface{} {
    db.Sql = sql
    return db.Select()
}

//order处理
func (db *Db)Order(order string)*Db  {
    db.option["order"] = order
    return db
}

//limit处理
func (db *Db)Limit(start,offset string)*Db  {
    db.option["order"] = start + "," + offset
    return db
}


//打印生成的sql
func  (db *Db) FetchSql() *Db {
    db.fetchSql = true
    return db
}

使用示例

package main

import (
    "fmt"
    "gopro/orm"
)
//orm测试包
func main() {
    connectUrl := "root:root@tcp(127.0.0.1:3306)/test?charset=utf8"
    dbClass := orm.Db{}
    db,err := dbClass.NewMysqlConn(connectUrl)
    if err != nil{
        panic(err)
    }
    //result := db.Query("select * from teacher")
    where := make(map[string]string)
    where["id"] = "1"
    where["name"] = "老师2"
    whereTow := make(map[string]string)
    whereTow["name"] = "老师3"
    result := db.Table("teacher").Where(where).Where(whereTow).Order("id desc").FetchSql().Find();
    fmt.Println(result)
}

func describe(i interface{}) {
    x := fmt.Sprintf("%T",i)
    //fmt.Printf("(%v, %T)\n", i, i)
    fmt.Println(x)
}

查看结果

E:\project\gopro>go run main.go
select * from teacher where `id`='1' and `name`='老师2' and `name`='老师3'  order by id desc

db将持续更新,将支持丰富的where操作以及插入，批量插入 集合 链表等复杂查询，敬请期待