diff --git a/engine.go b/engine.go index 36c618e5..8ded7f90 100644 --- a/engine.go +++ b/engine.go @@ -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 } } diff --git a/scan.go b/scan.go index 64021c0d..0d8e44aa 100644 --- a/scan.go +++ b/scan.go @@ -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 { diff --git a/session_query.go b/session_query.go index c24b4e64..0bb1595a 100644 --- a/session_query.go +++ b/session_query.go @@ -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 diff --git a/session_raw.go b/session_raw.go index 362eab8c..7eb8585d 100644 --- a/session_raw.go +++ b/session_raw.go @@ -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 {