feat: vendor gitea 1.16.2

package/gitea/source/models/db/collation.go

@@ -98,7 +98,7 @@ func CheckCollations(x *xorm.Engine) (*CheckCollationsResult, error) {
 			return nil, err
 		}
 	} else {
-		return nil, nil
+		return nil, nil //nolint:nilnil // return nil for unsupported database types
 	}
 
 	if res.DatabaseCollation == "" {

package/gitea/source/models/db/common.go

@@ -12,30 +12,30 @@ import (
 	"xorm.io/builder"
 )
 
-// BuildCaseInsensitiveLike returns a condition to check if the given value is like the given key case-insensitively.
-// Handles especially SQLite correctly as UPPER there only transforms ASCII letters.
+// BuildCaseInsensitiveLike returns a case-insensitive LIKE condition for the given key and value.
+// Cast the search value and the database column value to the same case for case-insensitive matching.
+// * SQLite: only cast ASCII chars because it doesn't handle complete Unicode case folding
+// * Other databases: use database's string function, assuming that they are able to handle complete Unicode case folding correctly
 func BuildCaseInsensitiveLike(key, value string) builder.Cond {
+	// ToLowerASCII is about 7% faster than ToUpperASCII (according to Golang's benchmark)
 	if setting.Database.Type.IsSQLite3() {
-		return builder.Like{"UPPER(" + key + ")", util.ToUpperASCII(value)}
+		return builder.Like{"LOWER(" + key + ")", util.ToLowerASCII(value)}
 	}
-	return builder.Like{"UPPER(" + key + ")", strings.ToUpper(value)}
+	return builder.Like{"LOWER(" + key + ")", strings.ToLower(value)}
 }
 
 // BuildCaseInsensitiveIn returns a condition to check if the given value is in the given values case-insensitively.
-// Handles especially SQLite correctly as UPPER there only transforms ASCII letters.
+// See BuildCaseInsensitiveLike for more details
 func BuildCaseInsensitiveIn(key string, values []string) builder.Cond {
-	uppers := make([]string, 0, len(values))
+	incaseValues := make([]string, len(values))
+	caseCast := strings.ToLower
 	if setting.Database.Type.IsSQLite3() {
-		for _, value := range values {
-			uppers = append(uppers, util.ToUpperASCII(value))
-		}
-	} else {
-		for _, value := range values {
-			uppers = append(uppers, strings.ToUpper(value))
-		}
+		caseCast = util.ToLowerASCII
 	}
-
-	return builder.In("UPPER("+key+")", uppers)
+	for i, value := range values {
+		incaseValues[i] = caseCast(value)
+	}
+	return builder.In("LOWER("+key+")", incaseValues)
 }
 
 // BuilderDialect returns the xorm.Builder dialect of the engine

package/gitea/source/models/db/convert.go

@@ -5,12 +5,11 @@ package db
 
 import (
 	"fmt"
-	"strconv"
 
-	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 
 	"xorm.io/xorm"
+	"xorm.io/xorm/convert"
 	"xorm.io/xorm/schemas"
 )
 
@@ -74,15 +73,14 @@ WHERE ST.name ='varchar'`)
 	return err
 }
 
-// Cell2Int64 converts a xorm.Cell type to int64,
-// and handles possible irregular cases.
-func Cell2Int64(val xorm.Cell) int64 {
-	switch (*val).(type) {
-	case []uint8:
-		log.Trace("Cell2Int64 ([]uint8): %v", *val)
-
-		v, _ := strconv.ParseInt(string((*val).([]uint8)), 10, 64)
-		return v
+// CellToInt converts a xorm.Cell field value to an int value
+func CellToInt[T ~int | int64](cell xorm.Cell, def T) (ret T, has bool, err error) {
+	if *cell == nil {
+		return def, false, nil
 	}
-	return (*val).(int64)
+	val, err := convert.AsInt64(*cell)
+	if err != nil {
+		return def, false, err
+	}
+	return T(val), true, err
 }

package/gitea/source/models/db/engine_init.go

@@ -57,7 +57,7 @@ func InitEngine(ctx context.Context) error {
 	xe, err := newXORMEngine()
 	if err != nil {
 		if strings.Contains(err.Error(), "SQLite3 support") {
-			return fmt.Errorf(`sqlite3 requires: -tags sqlite,sqlite_unlock_notify%s%w`, "\n", err)
+			return fmt.Errorf("sqlite3 requires: -tags sqlite,sqlite_unlock_notify\n%w", err)
 		}
 		return fmt.Errorf("failed to connect to database: %w", err)
 	}