Upgrade xorm to v1.0.2 (#11900)

Co-authored-by: techknowlogick <techknowlogick@gitea.io>

vendor/xorm.io/xorm/internal/statements/insert.go

@@ -5,6 +5,7 @@
 package statements
 
 import (
+	"fmt"
 	"strings"
 
 	"xorm.io/builder"
@@ -23,18 +24,15 @@ func (statement *Statement) writeInsertOutput(buf *strings.Builder, table *schem
 	return nil
 }
 
+// GenInsertSQL generates insert beans SQL
 func (statement *Statement) GenInsertSQL(colNames []string, args []interface{}) (string, []interface{}, error) {
 	var (
+		buf       = builder.NewWriter()
+		exprs     = statement.ExprColumns
 		table     = statement.RefTable
 		tableName = statement.TableName()
-		exprs     = statement.ExprColumns
-		colPlaces = strings.Repeat("?, ", len(colNames))
 	)
-	if exprs.Len() <= 0 && len(colPlaces) > 0 {
-		colPlaces = colPlaces[0 : len(colPlaces)-2]
-	}
 
-	var buf = builder.NewWriter()
 	if _, err := buf.WriteString("INSERT INTO "); err != nil {
 		return "", nil, err
 	}
@@ -43,7 +41,7 @@ func (statement *Statement) GenInsertSQL(colNames []string, args []interface{})
 		return "", nil, err
 	}
 
-	if len(colPlaces) <= 0 {
+	if len(colNames) <= 0 {
 		if statement.dialect.URI().DBType == schemas.MYSQL {
 			if _, err := buf.WriteString(" VALUES ()"); err != nil {
 				return "", nil, err
@@ -65,13 +63,14 @@ func (statement *Statement) GenInsertSQL(colNames []string, args []interface{})
 			return "", nil, err
 		}
 
+		if _, err := buf.WriteString(")"); err != nil {
+			return "", nil, err
+		}
+		if err := statement.writeInsertOutput(buf.Builder, table); err != nil {
+			return "", nil, err
+		}
+
 		if statement.Conds().IsValid() {
-			if _, err := buf.WriteString(")"); err != nil {
-				return "", nil, err
-			}
-			if err := statement.writeInsertOutput(buf.Builder, table); err != nil {
-				return "", nil, err
-			}
 			if _, err := buf.WriteString(" SELECT "); err != nil {
 				return "", nil, err
 			}
@@ -105,21 +104,20 @@ func (statement *Statement) GenInsertSQL(colNames []string, args []interface{})
 				return "", nil, err
 			}
 		} else {
-			buf.Append(args...)
-
-			if _, err := buf.WriteString(")"); err != nil {
-				return "", nil, err
-			}
-			if err := statement.writeInsertOutput(buf.Builder, table); err != nil {
-				return "", nil, err
-			}
 			if _, err := buf.WriteString(" VALUES ("); err != nil {
 				return "", nil, err
 			}
-			if _, err := buf.WriteString(colPlaces); err != nil {
+
+			if err := statement.WriteArgs(buf, args); err != nil {
 				return "", nil, err
 			}
 
+			if len(exprs.Args) > 0 {
+				if _, err := buf.WriteString(","); err != nil {
+					return "", nil, err
+				}
+			}
+
 			if err := exprs.WriteArgs(buf); err != nil {
 				return "", nil, err
 			}
@@ -141,3 +139,69 @@ func (statement *Statement) GenInsertSQL(colNames []string, args []interface{})
 
 	return buf.String(), buf.Args(), nil
 }
+
+// GenInsertMapSQL generates insert map SQL
+func (statement *Statement) GenInsertMapSQL(columns []string, args []interface{}) (string, []interface{}, error) {
+	var (
+		buf       = builder.NewWriter()
+		exprs     = statement.ExprColumns
+		tableName = statement.TableName()
+	)
+
+	if _, err := buf.WriteString(fmt.Sprintf("INSERT INTO %s (", statement.quote(tableName))); err != nil {
+		return "", nil, err
+	}
+
+	if err := statement.dialect.Quoter().JoinWrite(buf.Builder, append(columns, exprs.ColNames...), ","); err != nil {
+		return "", nil, err
+	}
+
+	// if insert where
+	if statement.Conds().IsValid() {
+		if _, err := buf.WriteString(") SELECT "); err != nil {
+			return "", nil, err
+		}
+
+		if err := statement.WriteArgs(buf, args); err != nil {
+			return "", nil, err
+		}
+
+		if len(exprs.Args) > 0 {
+			if _, err := buf.WriteString(","); err != nil {
+				return "", nil, err
+			}
+			if err := exprs.WriteArgs(buf); err != nil {
+				return "", nil, err
+			}
+		}
+
+		if _, err := buf.WriteString(fmt.Sprintf(" FROM %s WHERE ", statement.quote(tableName))); err != nil {
+			return "", nil, err
+		}
+
+		if err := statement.Conds().WriteTo(buf); err != nil {
+			return "", nil, err
+		}
+	} else {
+		if _, err := buf.WriteString(") VALUES ("); err != nil {
+			return "", nil, err
+		}
+		if err := statement.WriteArgs(buf, args); err != nil {
+			return "", nil, err
+		}
+
+		if len(exprs.Args) > 0 {
+			if _, err := buf.WriteString(","); err != nil {
+				return "", nil, err
+			}
+			if err := exprs.WriteArgs(buf); err != nil {
+				return "", nil, err
+			}
+		}
+		if _, err := buf.WriteString(")"); err != nil {
+			return "", nil, err
+		}
+	}
+
+	return buf.String(), buf.Args(), nil
+}

vendor/xorm.io/xorm/internal/statements/pk.go

@@ -20,6 +20,21 @@ var (
 	uintType   = reflect.TypeOf(uint64(0))
 )
 
+// ErrIDConditionWithNoTable represents an error there is no reference table with an ID condition
+type ErrIDConditionWithNoTable struct {
+	ID schemas.PK
+}
+
+func (err ErrIDConditionWithNoTable) Error() string {
+	return fmt.Sprintf("ID condition %#v need reference table", err.ID)
+}
+
+// IsIDConditionWithNoTableErr return true if the err is ErrIDConditionWithNoTable
+func IsIDConditionWithNoTableErr(err error) bool {
+	_, ok := err.(ErrIDConditionWithNoTable)
+	return ok
+}
+
 // ID generate "where id = ? " statement or for composite key "where key1 = ? and key2 = ?"
 func (statement *Statement) ID(id interface{}) *Statement {
 	switch t := id.(type) {
@@ -58,13 +73,17 @@ func (statement *Statement) ID(id interface{}) *Statement {
 	return statement
 }
 
+// ProcessIDParam handles the process of id condition
 func (statement *Statement) ProcessIDParam() error {
-	if statement.idParam == nil || statement.RefTable == nil {
+	if statement.idParam == nil {
 		return nil
 	}
 
+	if statement.RefTable == nil {
+		return ErrIDConditionWithNoTable{statement.idParam}
+	}
+
 	if len(statement.RefTable.PrimaryKeys) != len(statement.idParam) {
-		fmt.Println("=====", statement.RefTable.PrimaryKeys, statement.idParam)
 		return fmt.Errorf("ID condition is error, expect %d primarykeys, there are %d",
 			len(statement.RefTable.PrimaryKeys),
 			len(statement.idParam),

vendor/xorm.io/xorm/internal/statements/statement.go

@@ -797,8 +797,7 @@ func (statement *Statement) buildConds2(table *schemas.Table, bean interface{},
 			if !requiredField && fieldValue.Uint() == 0 {
 				continue
 			}
-			t := int64(fieldValue.Uint())
-			val = reflect.ValueOf(&t).Interface()
+			val = fieldValue.Interface()
 		case reflect.Struct:
 			if fieldType.ConvertibleTo(schemas.TimeType) {
 				t := fieldValue.Convert(schemas.TimeType).Interface().(time.Time)

vendor/xorm.io/xorm/internal/statements/statement_args.go

@@ -79,28 +79,6 @@ const insertSelectPlaceHolder = true
 
 func (statement *Statement) WriteArg(w *builder.BytesWriter, arg interface{}) error {
 	switch argv := arg.(type) {
-	case bool:
-		if statement.dialect.URI().DBType == schemas.MSSQL {
-			if argv {
-				if _, err := w.WriteString("1"); err != nil {
-					return err
-				}
-			} else {
-				if _, err := w.WriteString("0"); err != nil {
-					return err
-				}
-			}
-		} else {
-			if argv {
-				if _, err := w.WriteString("true"); err != nil {
-					return err
-				}
-			} else {
-				if _, err := w.WriteString("false"); err != nil {
-					return err
-				}
-			}
-		}
 	case *builder.Builder:
 		if _, err := w.WriteString("("); err != nil {
 			return err
@@ -116,7 +94,15 @@ func (statement *Statement) WriteArg(w *builder.BytesWriter, arg interface{}) er
 			if err := w.WriteByte('?'); err != nil {
 				return err
 			}
-			w.Append(arg)
+			if v, ok := arg.(bool); ok && statement.dialect.URI().DBType == schemas.MSSQL {
+				if v {
+					w.Append(1)
+				} else {
+					w.Append(0)
+				}
+			} else {
+				w.Append(arg)
+			}
 		} else {
 			var convertFunc = convertStringSingleQuote
 			if statement.dialect.URI().DBType == schemas.MYSQL {

vendor/xorm.io/xorm/internal/statements/update.go

@@ -190,8 +190,7 @@ func (statement *Statement) BuildUpdates(tableValue reflect.Value,
 			if !requiredField && fieldValue.Uint() == 0 {
 				continue
 			}
-			t := int64(fieldValue.Uint())
-			val = reflect.ValueOf(&t).Interface()
+			val = fieldValue.Interface()
 		case reflect.Struct:
 			if fieldType.ConvertibleTo(schemas.TimeType) {
 				t := fieldValue.Convert(schemas.TimeType).Interface().(time.Time)

vendor/xorm.io/xorm/internal/statements/values.go

@@ -147,7 +147,7 @@ func (statement *Statement) Value2Interface(col *schemas.Column, fieldValue refl
 		}
 		return nil, ErrUnSupportedType
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return int64(fieldValue.Uint()), nil
+		return fieldValue.Uint(), nil
 	default:
 		return fieldValue.Interface(), nil
 	}