golang map to struct
type operConf struct {Id uint32 `sql:
"oper_id"`
Name
string `sql:"oper_name"`
MsgRetyTimes uint32 `sql:
"msg_retry_times"`
MsgRetyInterval uint32 `sql:
"msg_retry_interval"`
HeartBeartInterval uint32 `sql:
"heartbeat_interval"`
OfflineDetectTimeuint32 `sql:
"offline_detect_time"`
}
func GetOperConf() ([]operConf, error) {
host :
= GetConf().MySql.Host
port :
= GetConf().MySql.Port
user :
= GetConf().MySql.User
password :
= GetConf().MySql.Pwd
dbName :
= GetConf().MySql.Db
table :
= GetConf().MySql.Table
sql :
= new(mysql)
defer sql.Close()
if err := sql.Connect(host, port, user, password, dbName, table); err != nil {
logger.DEBUG(LOG_NAME,
"slq.Connect err:%s", err.Error())
return nil, err
}
sqlStr :
= "SELECT oper_id, oper_name, msg_retry_times, msg_retry_interval, heartbeat_interval, offline_detect_time"
sqlStr
+= " From " + table
result, err :
= sql.Query(sqlStr)
if err != nil {
return nil, err
}
confArr :
= make([]operConf, len(result))
for i, v := range result {
oc :
= new(operConf)
DataToStruct(v, oc)
logger.DEBUG(LOG_NAME,
"oc:%+v", oc)
confArr
= *oc
}
return nil, nil
}
type mysql
struct {
m_db
*sql.DB
}
func (
this *mysql) Connect(host string, port int, user, password, dbName, table string) error {
dsn :
= fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?",
user, password, host, port, dbName)
var err error
this.m_db, err = sql.Open("mysql", dsn)
if err != nil {
fmt.Println(
"error: %s\n", err.Error())
return err
}
err
= this.m_db.Ping()
if err != nil {
this.m_db.Close()
}
return err
}
func (
this *mysql) Close() {
this.m_db.Close()
}
func (
this *mysql) Query(sql string) (mapmapstring, error) {
if this.m_db == nil {
return nil, errors.New("mysql not connect")
}
var query = strings.TrimSpace(sql)
s, err :
= regexp.MatchString(`(?i)^select`, query) //(?i) igonre upper/lower case
if err != nil {
return nil, err
}
if s == false {
return nil, errors.New("not select sql")
}
rows, _ := this.m_db.Query(sql)
c, err := this.GetQueryResult(rows)
return c, err
}
func (this *mysql) GetQueryResult(rows *sql.Rows) (mapmapstring, error) {
var result = make(mapmapstring)
columns, _ := rows.Columns()
values := make([]sql.RawBytes, len(columns))
scanArgs := make([]interface{}, len(values))
for i := range values {
scanArgs = &values
}
var n = 0
for rows.Next() {
result = make(mapstring)
err := rows.Scan(scanArgs...)
if err != nil {
return nil, err
}
for i, v := range values {
result] = string(v)
}
n++
}
logger.DEBUG(LOG_NAME, "Query Result:%+v", result)
return result, nil
}
func DataToStruct(data mapstring, out interface{}) {
ss := reflect.ValueOf(out).Elem()
for i := 0; i < ss.NumField(); i++ {
val := data
name := ss.Type().Field(i).Name
logger.DEBUG(LOG_NAME, "tag:%s, tag value:%s, filed name:%s", ss.Type().Field(i).Tag.Get("sql"), val, name)
switch ss.Field(i).Kind() {
case reflect.String:
ss.FieldByName(name).SetString(val)
case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
i, err := strconv.Atoi(val)
//fmt.Println("i:", i, name)
if err != nil {
logger.ERROR(LOG_NAME, "can't not atoi:%v", val)
continue
}
ss.FieldByName(name).SetInt(int64(i))
case reflect.Uint16, reflect.Uint32, reflect.Uint64:
i, err := strconv.Atoi(val)
//fmt.Println("i:", i, name)
if err != nil {
logger.ERROR(LOG_NAME, "can't not atoi:%v", val)
continue
}
ss.FieldByName(name).SetUint(uint64(i))
case reflect.Float32, reflect.Float64:
f, err := strconv.ParseFloat(val, 64)
if err != nil {
logger.ERROR(LOG_NAME, "can't not ParseFloat:%v", val)
continue
}
ss.FieldByName(name).SetFloat(f)
default:
logger.ERROR(LOG_NAME, "unknown type:%+v", ss.Field(i).Kind())
}
}
return
}
页:
[1]