gf/g/database/gdb/gdb_func.go

// Copyright 2017-2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.

package gdb

import (
    "bytes"
    "errors"
    "fmt"
    "github.com/gogf/gf/g/os/glog"
    "github.com/gogf/gf/g/os/gtime"
    "github.com/gogf/gf/g/text/gregex"
    "github.com/gogf/gf/g/text/gstr"
    "github.com/gogf/gf/g/util/gconv"
    "reflect"
    "strings"
	"time"
)

// Type assert api for String().
type apiString interface {
	String() string
}

// 格式化SQL查询条件
func formatCondition(where interface{}, args []interface{}) (newWhere string, newArgs []interface{}) {
    // 条件字符串处理
    buffer := bytes.NewBuffer(nil)
    // 使用反射进行类型判断
    rv   := reflect.ValueOf(where)
    kind := rv.Kind()
    if kind == reflect.Ptr {
        rv   = rv.Elem()
        kind = rv.Kind()
    }
    tmpArgs := []interface{}(nil)
    switch kind {
        // map/struct类型
        case reflect.Map:   fallthrough
        case reflect.Struct:
            for key, value := range gconv.Map(where) {
                if buffer.Len() > 0 {
                    buffer.WriteString(" AND ")
                }
                // 支持slice键值/属性，如果只有一个?占位符号，那么作为IN查询，否则打散作为多个查询参数
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                    case reflect.Slice: fallthrough
                    case reflect.Array:
                        count := gstr.Count(key, "?")
                        if count == 0 {
                            buffer.WriteString(key + " IN(?)")
                            tmpArgs = append(tmpArgs, value)
                        } else if count != rv.Len() {
                            buffer.WriteString(key)
                            tmpArgs = append(tmpArgs, value)
                        } else {
                            buffer.WriteString(key)
                            // 如果键名/属性名称中带有多个?占位符号，那么将参数打散
                            tmpArgs = append(tmpArgs, gconv.Interfaces(value)...)
                        }
                    default:
                        if value == nil {
                            buffer.WriteString(key)
                        } else {
                            if gstr.Pos(key, "?") == -1 {
                                if gstr.Pos(key, "<") == -1 && gstr.Pos(key, ">") == -1 && gstr.Pos(key, "=") == -1 {
                                    buffer.WriteString(key + "=?")
                                } else {
                                    buffer.WriteString(key + "?")
                                }
                            } else {
                                buffer.WriteString(key)
                            }
                            tmpArgs = append(tmpArgs, value)
                        }
                }
            }

        default:
            buffer.WriteString(gconv.String(where))
    }
    // 没有任何条件查询参数，直接返回
    if buffer.Len() == 0 {
        return "", args
    }
    newWhere = buffer.String()
    tmpArgs  = append(tmpArgs, args...)
    // 查询条件参数处理，主要处理slice参数类型
    if len(tmpArgs) > 0 {
        for index, arg := range tmpArgs {
            rv   := reflect.ValueOf(arg)
            kind := rv.Kind()
            if kind == reflect.Ptr {
                rv   = rv.Elem()
                kind = rv.Kind()
            }
            switch kind {
                // '?'占位符支持slice类型,
                // 这里会将slice参数拆散，并更新原有占位符'?'为多个'?'，使用','符号连接。
                case reflect.Slice: fallthrough
                case reflect.Array:
                    for i := 0; i < rv.Len(); i++ {
                        newArgs = append(newArgs, rv.Index(i).Interface())
                    }
                    // counter用于匹配该参数的位置(与index对应)
                    counter    := 0
                    newWhere, _ = gregex.ReplaceStringFunc(`\?`, newWhere, func(s string) string {
                        counter++
                        if counter == index + 1 {
                            return "?" + strings.Repeat(",?", rv.Len() - 1)
                        }
                        return s
                    })
                default:
                    // 支持例如 Where/And/Or("uid", 1) 这种格式
                    if gstr.Pos(newWhere, "?") == -1 {
                        if gstr.Pos(newWhere, "<") == -1 && gstr.Pos(newWhere, ">") == -1 && gstr.Pos(newWhere, "=") == -1 {
                            newWhere += "=?"
                        } else {
                            newWhere += "?"
                        }
                    }
                    newArgs = append(newArgs, arg)
            }
        }
    }
    return
}

// 将预处理参数转换为底层数据库引擎支持的格式。
// 主要是判断参数是否为复杂数据类型，如果是，那么转换为基础类型。
func convertParam(value interface{}) interface{} {
    rv   := reflect.ValueOf(value)
    kind := rv.Kind()
    if kind == reflect.Ptr {
        rv   = rv.Elem()
        kind = rv.Kind()
    }
    switch kind {
        case reflect.Struct:
        	// 底层数据库引擎支持 time.Time 类型
        	if _, ok := value.(time.Time); ok {
        		return value
	        }
            return gconv.String(value)
    }
    return value
}

// 打印SQL对象(仅在debug=true时有效)
func printSql(v *Sql) {
    s := fmt.Sprintf("%s, %v, %s, %s, %d ms, %s", v.Sql, v.Args,
        gtime.NewFromTimeStamp(v.Start).Format("Y-m-d H:i:s.u"),
        gtime.NewFromTimeStamp(v.End).Format("Y-m-d H:i:s.u"),
        v.End - v.Start,
        v.Func,
    )
    if v.Error != nil {
        s += "\nError: " + v.Error.Error()
        glog.Backtrace(true, 2).Error(s)
    } else {
        glog.Debug(s)
    }
}

// 格式化错误信息
func formatError(err error, query string, args ...interface{}) error {
    if err != nil {
        errstr := fmt.Sprintf("DB ERROR: %s\n", err.Error())
        errstr += fmt.Sprintf("DB QUERY: %s\n", query)
        if len(args) > 0 {
            errstr += fmt.Sprintf("DB PARAM: %v\n", args)
        }
        err = errors.New(errstr)
    }
    return err
}

// 根据insert选项获得操作名称
func getInsertOperationByOption(option int) string {
    operator := "INSERT"
    switch option {
        case OPTION_REPLACE:
            operator = "REPLACE"
        case OPTION_SAVE:
        case OPTION_IGNORE:
            operator = "INSERT IGNORE"
    }
    return operator
}

// 将对象转换为map，如果对象带有继承对象，那么执行递归转换。
// 该方法用于将变量传递给数据库执行之前。
func structToMap(obj interface{}) map[string]interface{} {
	data := gconv.Map(obj)
	for k, v := range data {
		rv   := reflect.ValueOf(v)
		kind := rv.Kind()
		if kind == reflect.Ptr {
			rv   = rv.Elem()
			kind = rv.Kind()
		}
		switch kind {
			case reflect.Struct:
				// 底层数据库引擎支持 time.Time 类型
				if _, ok := v.(time.Time); ok {
					continue
				}
				// 如果执行String方法，那么执行字符串转换
				if s, ok := v.(apiString); ok {
					data[k] = s.String()
				}
				for k, v := range structToMap(v) {
					data[k] = v
				}
		}
	}
	return data
}