HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

This commit is contained in:
Lunny Xiao 2021-07-03 00:09:36 +08:00
parent 67d1348f4f
commit 4f03689628
4 changed files with 11 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
engine.go
View File

@ -390,7 +390,7 @@ func (engine *Engine) loadTableInfo(table *schemas.Table) error {
if col := table.GetColumn(colName); col != nil {
col.Indexes[index.Name] = index.Type
} else {
return fmt.Errorf("Unknown col %s seq %d, in index %v of table %v, columns %v", name, seq, index.Name, table.Name, table.ColumnsSeq())
return fmt.Errorf("unknown col %s seq %d, in index %v of table %v, columns %v", name, seq, index.Name, table.Name, table.ColumnsSeq())
}
}
}
@ -510,7 +510,7 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d
return "'" + strings.Replace(v, "'", "''", -1) + "'"
} else if col.SQLType.IsBlob() {
if reflect.TypeOf(d).Kind() == reflect.Slice {
return fmt.Sprintf("%s", dstDialect.FormatBytes(d.([]byte)))
return dstDialect.FormatBytes(d.([]byte))
} else if reflect.TypeOf(d).Kind() == reflect.String {
return fmt.Sprintf("'%s'", d.(string))
}
@ -520,7 +520,7 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d
if col.SQLType.Name == schemas.Bool {
return fmt.Sprintf("%v", strconv.FormatBool(d.([]byte)[0] != byte('0')))
}
return fmt.Sprintf("%s", string(d.([]byte)))
return string(d.([]byte))
case reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64, reflect.Int:
if col.SQLType.Name == schemas.Bool {
v := reflect.ValueOf(d).Int() > 0
@ -568,7 +568,7 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch
} else {
dstDialect = dialects.QueryDialect(tp[0])
if dstDialect == nil {
return errors.New("Unsupported database type")
return errors.New("unsupported database type")
}
uri := engine.dialect.URI()
@ -653,13 +653,13 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch
return err
}
row, err := engine.scanInterfaceResults(rows, coltypes, dstCols)
row, err := engine.scanInterfaces(rows, coltypes)
if err != nil {
return err
}
for i, cell := range row {
s := engine.formatColumnValue(dstDialect, cell, dstColumns[i])
s := formatColumnValue(engine.DatabaseTZ, dstDialect, cell, dstColumns[i])
if _, err = io.WriteString(w, s); err != nil {
return err
}
@ -667,22 +667,11 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch
if _, err = io.WriteString(w, ","); err != nil {
return err
}
field := dataStruct.FieldByIndex(col.FieldIndex)
temp += "," + formatColumnValue(engine.DatabaseTZ, dstDialect, field.Interface(), col)
}
_, err = io.WriteString(w, temp[1:]+");\n")
if err != nil {
return err
}
}
temp += "," + formatColumnValue(engine.DatabaseTZ, dstDialect, d, col)
}
_, err = io.WriteString(w, temp[1:]+");\n")
if err != nil {
return err
}
_, err = io.WriteString(w, ");\n")
if err != nil {
return err
}
}

13
scan.go
View File

@ -177,19 +177,6 @@ func genScanResult(driver dialects.Driver, fieldValue reflect.Value, columnType
}
}
// genScanResults generating scan results according column types
func genScanResults(driver dialects.Driver, types []*sql.ColumnType) ([]interface{}, error) {
var scanResults = make([]interface{}, len(types))
var err error
for i, t := range types {
scanResults[i], err = driver.GenScanResult(t.DatabaseTypeName())
if err != nil {
return nil, err
}
}
return scanResults, nil
}
func genScanResultsWithTable(driver dialects.Driver, types []*sql.ColumnType, fields []string, values []reflect.Value, table *schemas.Table) ([]interface{}, error) {
var scanResults = make([]interface{}, 0, len(types))
for i, tp := range types {

4
session_query.go
View File

@ -72,7 +72,7 @@ func (session *Session) rows2SliceString(rows *core.Rows) (resultsSlice [][]stri
if err != nil {
return nil, err
}
resultsSlice = append(resultsSlice, record)
resultsSlice = append(resultsSlice, result)
}
return resultsSlice, nil
@ -95,7 +95,7 @@ func (session *Session) QueryString(sqlOrArgs ...interface{}) ([]map[string]stri
}
defer rows.Close()
return session.engine.rows2Strings(rows)
return session.rows2Strings(rows)
}
// QuerySliceString runs a raw sql and return records as [][]string

52
session_raw.go
View File

@ -6,13 +6,8 @@ package xorm
import (
"database/sql"
"fmt"
"reflect"
"strconv"
"time"
"xorm.io/xorm/core"
"xorm.io/xorm/schemas"
)
func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
@ -75,53 +70,6 @@ func (session *Session) queryRow(sqlStr string, args ...interface{}) *core.Row {
return core.NewRow(session.queryRows(sqlStr, args...))
}
func value2String(rawValue *reflect.Value) (str string, err error) {
aa := reflect.TypeOf((*rawValue).Interface())
vv := reflect.ValueOf((*rawValue).Interface())
switch aa.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
str = strconv.FormatInt(vv.Int(), 10)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
str = strconv.FormatUint(vv.Uint(), 10)
case reflect.Float32, reflect.Float64:
str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
case reflect.String:
str = vv.String()
case reflect.Array, reflect.Slice:
switch aa.Elem().Kind() {
case reflect.Uint8:
data := rawValue.Interface().([]byte)
str = string(data)
if str == "\x00" {
str = "0"
}
default:
err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
}
// time type
case reflect.Struct:
if aa.ConvertibleTo(schemas.TimeType) {
str = vv.Convert(schemas.TimeType).Interface().(time.Time).Format(time.RFC3339Nano)
} else {
err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
}
case reflect.Bool:
str = strconv.FormatBool(vv.Bool())
case reflect.Complex128, reflect.Complex64:
str = fmt.Sprintf("%v", vv.Complex())
/* TODO: unsupported types below
case reflect.Map:
case reflect.Ptr:
case reflect.Uintptr:
case reflect.UnsafePointer:
case reflect.Chan, reflect.Func, reflect.Interface:
*/
default:
err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
}
return
}
func (session *Session) queryBytes(sqlStr string, args ...interface{}) ([]map[string][]byte, error) {
rows, err := session.queryRows(sqlStr, args...)
if err != nil {