Merge

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
 				}
 			}
-
+			_, err = io.WriteString(w, ");\n")
-					temp += "," + formatColumnValue(engine.DatabaseTZ, dstDialect, d, col)
+			if err != nil {
-				}
+				return err
-				_, err = io.WriteString(w, temp[1:]+");\n")
-				if err != nil {
-					return err
-				}
 			}
 		}
 

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 {

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

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 {