463 lines
13 KiB
Go
463 lines
13 KiB
Go
package db
|
|
|
|
import (
|
|
//"database/sql"
|
|
"fmt"
|
|
"reflect"
|
|
"server/GoUtil"
|
|
"server/conf"
|
|
"server/pkg/github.com/name5566/leaf/log"
|
|
"strings"
|
|
|
|
// "server/game"
|
|
_ "github.com/go-sql-driver/mysql"
|
|
"github.com/jmoiron/sqlx"
|
|
)
|
|
|
|
type user struct {
|
|
Id int `db:"user_id"`
|
|
Sex int `db:"sex"`
|
|
UserName string `db:"username"`
|
|
Email string `db:"email"`
|
|
}
|
|
|
|
var SqlDb *sqlx.DB
|
|
|
|
func InitDB() {
|
|
//"用户名:密码@[连接方式](主机名:端口号)/数据库名"
|
|
MysqlPwd, _ := GoUtil.Decrypt(conf.Server.MySqlPwd)
|
|
connect := fmt.Sprintf("%s:%s@(%s:%s)/%s", conf.Server.MySqlUsr, MysqlPwd, conf.Server.MySqlAddr, conf.Server.MySqlPort, conf.Server.DbName)
|
|
SqlDb = sqlx.MustConnect("mysql", connect) // 设置连接数据库的参数
|
|
SqlDb.SetMaxOpenConns(20) // 设置最大打开的连接数
|
|
log.Debug("connect mysql success")
|
|
}
|
|
|
|
func SeriesTransaction(sqlstrs []string, params [][]any) (err error) {
|
|
tx, err := SqlDb.Begin()
|
|
if err != nil {
|
|
log.Debug("Transaction failed, err:%v\n", err)
|
|
return err
|
|
}
|
|
|
|
defer func() {
|
|
if err != nil {
|
|
log.Debug("Transaction failed, err:%v\n", err)
|
|
_ = tx.Rollback()
|
|
} else {
|
|
err = tx.Commit()
|
|
return
|
|
}
|
|
}()
|
|
|
|
for i := 0; i < len(sqlstrs); i++ {
|
|
_, err := tx.Exec(sqlstrs[i], params[i]...)
|
|
if err != nil {
|
|
log.Debug("Transaction failed, err:%v\n", err)
|
|
return err
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 更新数据
|
|
func FormatUpdateOneAttrRow(u interface{}, tableName string, UpdateAttr string, Exclude string) (err error) {
|
|
t := reflect.TypeOf(u)
|
|
len1 := t.Elem().NumField()
|
|
Fields := make([]string, len1)
|
|
Values := make([]interface{}, len1)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "UPDATE " + tableName + " SET "
|
|
index := 0
|
|
var keyValue interface{}
|
|
for i := 0; i < len1; i++ {
|
|
field := t.Elem().Field(i)
|
|
if field.Tag.Get("db") != Exclude {
|
|
if field.Tag.Get("db") == UpdateAttr {
|
|
Fields[index] = field.Tag.Get("db") + " = ?"
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
Values[index] = ufield.String()
|
|
}
|
|
if k == reflect.Int32 {
|
|
Values[index] = ufield.Int()
|
|
}
|
|
index++
|
|
}
|
|
|
|
} else {
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
keyValue = ufield.String()
|
|
}
|
|
if k == reflect.Int32 {
|
|
keyValue = ufield.Int()
|
|
}
|
|
}
|
|
}
|
|
Values[index] = keyValue
|
|
// Values = append(Values, keyValue)
|
|
origin += strings.Join(Fields, ",")
|
|
strLen := len(origin)
|
|
origin = origin[:strLen-1]
|
|
origin = origin + " WHERE " + Exclude + " = ?"
|
|
sqlStr := origin
|
|
_, err = SqlDb.Exec(sqlStr, Values...)
|
|
if err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", tableName, sqlStr, err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// "UPDATE user SET age = ?, degree = ? WHERE id = ?"
|
|
func FormatAllMemUpdateDb(u interface{}, tableName string, Exclude string) (err error) {
|
|
t := reflect.TypeOf(u)
|
|
len1 := t.Elem().NumField()
|
|
Fields := make([]string, len1)
|
|
Values := make([]interface{}, len1)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "UPDATE " + tableName + " SET "
|
|
index := 0
|
|
var keyValue interface{}
|
|
for i := 0; i < len1; i++ {
|
|
field := t.Elem().Field(i)
|
|
if field.Tag.Get("db") != Exclude {
|
|
Fields[index] = "`" + field.Tag.Get("db") + "` = ?"
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
Values[index] = ufield.String()
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
Values[index] = ufield.Int()
|
|
}
|
|
index++
|
|
} else {
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
keyValue = ufield.String()
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
keyValue = ufield.Int()
|
|
}
|
|
}
|
|
}
|
|
Values[index] = keyValue
|
|
// Values = append(Values, keyValue)
|
|
origin += strings.Join(Fields, ",")
|
|
strLen := len(origin)
|
|
origin = origin[:strLen-1]
|
|
origin = origin + " WHERE `" + Exclude + "` = ?"
|
|
sqlStr := origin
|
|
|
|
_, err = SqlDb.Exec(sqlStr, Values...)
|
|
if err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", tableName, sqlStr, err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func FormatAllMemInsertDb(u interface{}, tableName string) (insertID int64, err error) {
|
|
t := reflect.TypeOf(u)
|
|
len := t.Elem().NumField()
|
|
Fields := make([]string, len)
|
|
Fields1 := make([]string, len)
|
|
FieldNames := make([]string, len)
|
|
Values := make([]interface{}, len)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "INSERT INTO " + tableName + "("
|
|
for i := 0; i < len; i++ {
|
|
field := t.Elem().Field(i)
|
|
Fields[i] = field.Tag.Get("db")
|
|
Fields1[i] = "?"
|
|
FieldNames[i] = field.Name
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
Values[i] = ufield.String()
|
|
}
|
|
if k == reflect.Int32 {
|
|
Values[i] = ufield.Int()
|
|
}
|
|
if k == reflect.Int64 {
|
|
Values[i] = ufield.Int()
|
|
}
|
|
}
|
|
for i := range Fields {
|
|
Fields[i] = "`" + Fields[i] + "`"
|
|
}
|
|
origin += strings.Join(Fields, ",")
|
|
origin += ") VALUES("
|
|
origin += strings.Join(Fields1, ",")
|
|
origin += ")"
|
|
sqlStr := origin
|
|
result, err := SqlDb.Exec(sqlStr, Values...)
|
|
if err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", tableName, sqlStr, err)
|
|
return
|
|
}
|
|
insertID, err = result.LastInsertId()
|
|
if err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", tableName, sqlStr, err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetPlayerBaseInfoFromDbByName(name string) *ResPlayerBaseInfo {
|
|
sqlStr := "SELECT * FROM t_player_baseinfo WHERE user_name = ?"
|
|
var res ResPlayerBaseInfo
|
|
if err := SqlDb.Get(&res, sqlStr, name); err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", "PlayerBaseInfo", sqlStr, err)
|
|
return nil
|
|
}
|
|
return &res
|
|
}
|
|
|
|
func GetPlayerBaseInfoFromDbById(id int32) *ResPlayerBaseInfo {
|
|
sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
|
|
var res ResPlayerBaseInfo
|
|
if err := SqlDb.Get(&res, sqlStr, id); err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", "PlayerBaseInfo", sqlStr, err)
|
|
return nil
|
|
}
|
|
return &res
|
|
}
|
|
|
|
func GetAccountInfoFromDb(name string) *Db_Account {
|
|
sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
|
|
var res Db_Account
|
|
if err := SqlDb.Get(&res, sqlStr, name); err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", "account", sqlStr, err)
|
|
return nil
|
|
}
|
|
return &res
|
|
}
|
|
|
|
func FormatAllMemLoadDb(u interface{}, tableName string, Exclude string) (err error) {
|
|
t := reflect.TypeOf(u)
|
|
len := t.Elem().NumField()
|
|
Fields := make([]string, len)
|
|
Values := make([]interface{}, len)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "SELECT * FROM " + tableName + " WHERE "
|
|
index := 0
|
|
var keyValue interface{}
|
|
for i := 0; i < len; i++ {
|
|
field := t.Elem().Field(i)
|
|
if field.Tag.Get("db") != Exclude {
|
|
Fields[index] = field.Tag.Get("db") + " = ?"
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
Values[index] = ufield.String()
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
Values[index] = ufield.Int()
|
|
}
|
|
index++
|
|
} else {
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String {
|
|
keyValue = ufield.String()
|
|
}
|
|
if k == reflect.Int32 {
|
|
keyValue = ufield.Int()
|
|
}
|
|
}
|
|
}
|
|
Values[index] = keyValue
|
|
// Values = append(Values, keyValue)
|
|
origin += strings.Join(Fields, " AND ")
|
|
sqlStr := origin
|
|
if err := SqlDb.Get(u, sqlStr, Values...); err != nil {
|
|
log.Debug("table: %s, sql :%s, exec failed, err:%v\n", tableName, sqlStr, err)
|
|
return err
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetServerData(d interface{}, Key string) (err error) {
|
|
sql := "select * from t_server_mod where `key` = ?"
|
|
err = SqlDb.Get(d, sql, Key)
|
|
return
|
|
}
|
|
|
|
func SaveServerData(data *SqlServerModStruct) error {
|
|
sql := "update t_server_mod set `mData` = ? , `updateTime` = ? where `key` = ?"
|
|
_, err := SqlDb.Exec(sql, data.ModData, data.UpdataTime, data.Key)
|
|
return err
|
|
}
|
|
|
|
func InsertServerData(data *SqlServerModStruct) error {
|
|
sql := "insert into t_server_mod (`mData` , `updateTime` ,`key`) Values (?,?,?)"
|
|
_, err := SqlDb.Exec(sql, data.ModData, data.UpdataTime, data.Key)
|
|
return err
|
|
}
|
|
|
|
func SavePlayerModData(data *SqlModStruct) error {
|
|
sql := "INSERT INTO `t_player_mod` (`mData` , `updateTime` ,`dwUin`) Values (?,?,?) ON DUPLICATE KEY UPDATE `mData` = ? , `updateTime` = ? "
|
|
_, err := SqlDb.Exec(sql, data.ModData, data.UpdataTime, data.DwUin, data.ModData, data.UpdataTime)
|
|
return err
|
|
}
|
|
|
|
func InsertPlayerModData(data *SqlModStruct) error {
|
|
sql := "insert into t_player_mod (`mData` , `updateTime` ,`dwUin`) Values (?,?,?)"
|
|
_, err := SqlDb.Exec(sql, data.ModData, data.UpdataTime, data.DwUin)
|
|
return err
|
|
}
|
|
|
|
func SavePlayerClientData(data *SqlModStruct) error {
|
|
sql := "INSERT INTO `t_player_client_data` (`mData` , `updateTime` ,`dwUin`) Values (?,?,?) ON DUPLICATE KEY UPDATE `mData` = ? , `updateTime` = ? "
|
|
_, err := SqlDb.Exec(sql, data.ModData, data.UpdataTime, data.DwUin, data.ModData, data.UpdataTime)
|
|
return err
|
|
}
|
|
|
|
func GetPlayerClientData(d interface{}, Key string) (err error) {
|
|
sql := "select * from t_server_mod where `dwUin` = ?"
|
|
err = SqlDb.Get(d, sql, Key)
|
|
return
|
|
}
|
|
|
|
func InsertData(u interface{}, tableName string) (insertID int64, err error) {
|
|
t := reflect.TypeOf(u)
|
|
len := t.Elem().NumField()
|
|
Fields := make([]string, 0)
|
|
Fields1 := make([]string, 0)
|
|
Values := make([]interface{}, 0)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "INSERT INTO " + tableName + "("
|
|
for i := 0; i < len; i++ {
|
|
field := t.Elem().Field(i)
|
|
if field.Tag.Get("db") == "id" {
|
|
continue
|
|
}
|
|
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if k == reflect.String && ufield.String() == "" {
|
|
continue
|
|
}
|
|
if (k == reflect.Int32 || k == reflect.Int || k == reflect.Int64) && ufield.Int() == 0 {
|
|
continue
|
|
}
|
|
|
|
if k == reflect.String {
|
|
Values = append(Values, ufield.String())
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
Values = append(Values, ufield.Int())
|
|
}
|
|
Fields = append(Fields, field.Tag.Get("db"))
|
|
Fields1 = append(Fields1, "?")
|
|
}
|
|
for i := range Fields {
|
|
Fields[i] = "`" + Fields[i] + "`"
|
|
}
|
|
origin += strings.Join(Fields, ",")
|
|
origin += ") VALUES("
|
|
origin += strings.Join(Fields1, ",")
|
|
origin += ")"
|
|
sqlStr := origin
|
|
result, err := SqlDb.Exec(sqlStr, Values...)
|
|
if err != nil {
|
|
log.Debug("InsertData exec failed, sql : %s ;err:%v\n", sqlStr, err)
|
|
return
|
|
}
|
|
insertID, err = result.LastInsertId()
|
|
if err != nil {
|
|
log.Debug("InsertData exec failed, err:%v\n", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func UpdateData(u interface{}, tableName string, Exclude string) (err error) {
|
|
t := reflect.TypeOf(u)
|
|
len1 := t.Elem().NumField()
|
|
Fields := make([]string, 0)
|
|
Values := make([]interface{}, 0)
|
|
pp := reflect.ValueOf(u)
|
|
origin := "UPDATE " + tableName + " SET "
|
|
var ExcludeValue interface{}
|
|
for i := 0; i < len1; i++ {
|
|
field := t.Elem().Field(i)
|
|
ufield := pp.Elem().FieldByName(field.Name)
|
|
k := ufield.Kind()
|
|
if field.Tag.Get("db") != Exclude && field.Tag.Get("db") != "id" {
|
|
|
|
if k == reflect.String {
|
|
Values = append(Values, ufield.String())
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
Values = append(Values, ufield.Int())
|
|
}
|
|
Fields = append(Fields, "`"+field.Tag.Get("db")+"` = ?")
|
|
}
|
|
if field.Tag.Get("db") == Exclude {
|
|
if k == reflect.String {
|
|
ExcludeValue = ufield.String()
|
|
}
|
|
if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
|
|
ExcludeValue = append(Values, ufield.Int())
|
|
}
|
|
}
|
|
}
|
|
Values = append(Values, ExcludeValue)
|
|
origin += strings.Join(Fields, ",")
|
|
origin = origin + " WHERE `" + Exclude + "` = ?"
|
|
sqlStr := origin
|
|
|
|
_, err = SqlDb.Exec(sqlStr, Values...)
|
|
if err != nil {
|
|
log.Debug("update failed, sql %s err:%v\n", sqlStr, err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetServerMailData(data *[]*SqlServerMailStruct) error {
|
|
sql := "select * from system_mail_info"
|
|
err := SqlDb.Select(data, sql)
|
|
return err
|
|
}
|
|
|
|
func CreateOrderSn(Uid, ChargeId int, OrderSn, Platform, Channel string, Price float64, Currency string) error {
|
|
sql := "insert into t_player_charge (`Uid`,`OrderId`, `ProductId`, `Price`,`Currency`, `CreateTime`, `PayPlatform`, `PayChannel`) Values (?,?,?,?,?,?,?,?)"
|
|
Now := GoUtil.Now()
|
|
_, err := SqlDb.Exec(sql, Uid, OrderSn, ChargeId, Price, Currency, Now, Platform, Channel)
|
|
return err
|
|
}
|
|
|
|
func GetPlayerChargeData(OrderSn string) (*SqlChargeOrderStruct, error) {
|
|
sql := "select * from t_player_charge where OrderId = ?"
|
|
data := &SqlChargeOrderStruct{}
|
|
err := SqlDb.Get(data, sql, OrderSn)
|
|
return data, err
|
|
}
|
|
|
|
func UpdatePlayerChargeData(data *SqlChargeOrderStruct) error {
|
|
sql := "update t_player_charge set PayTime = ?, PayStatus = ?, PayChannelOrderId = ? where OrderId = ?"
|
|
_, err := SqlDb.Exec(sql, data.PayTime, data.PayStatus, data.PayChannelOrderId, data.OrderId)
|
|
return err
|
|
}
|
|
|
|
func SearchPlayer(key string) ([]*ResPlayerBaseInfo, error) {
|
|
sql := "select * from t_player_baseinfo where user_name like ? limit 10"
|
|
data := &[]*ResPlayerBaseInfo{}
|
|
err := SqlDb.Select(data, sql, "%"+key+"%")
|
|
return *data, err
|
|
}
|