mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-16 07:08:48 +01:00
Register a custom SQLite collation function (NATURALSORT) that compares strings using natural sort ordering, where embedded numeric sequences are compared as numbers rather than lexicographically. This fixes the issue where albums like "Bravo Hits 1-132" sort as 1, 10, 100... instead of 1, 2, 3... 10, 11... Closes navidrome/navidrome#4891
100 lines
2.7 KiB
Go
100 lines
2.7 KiB
Go
package persistence
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/Masterminds/squirrel"
|
|
"github.com/fatih/structs"
|
|
)
|
|
|
|
type PostMapper interface {
|
|
PostMapArgs(map[string]any) error
|
|
}
|
|
|
|
func toSQLArgs(rec any) (map[string]any, error) {
|
|
m := structs.Map(rec)
|
|
for k, v := range m {
|
|
switch t := v.(type) {
|
|
case *time.Time:
|
|
if t != nil {
|
|
m[k] = *t
|
|
}
|
|
case driver.Valuer:
|
|
var err error
|
|
m[k], err = t.Value()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
if r, ok := rec.(PostMapper); ok {
|
|
err := r.PostMapArgs(m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
|
|
var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
|
|
|
|
func toSnakeCase(str string) string {
|
|
snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
|
|
snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
|
|
return strings.ToLower(snake)
|
|
}
|
|
|
|
var matchUnderscore = regexp.MustCompile("_([A-Za-z])")
|
|
|
|
func toCamelCase(str string) string {
|
|
return matchUnderscore.ReplaceAllStringFunc(str, func(s string) string {
|
|
return strings.ToUpper(strings.Replace(s, "_", "", -1))
|
|
})
|
|
}
|
|
|
|
func Exists(subTable string, cond squirrel.Sqlizer) existsCond {
|
|
return existsCond{subTable: subTable, cond: cond, not: false}
|
|
}
|
|
|
|
func NotExists(subTable string, cond squirrel.Sqlizer) existsCond {
|
|
return existsCond{subTable: subTable, cond: cond, not: true}
|
|
}
|
|
|
|
type existsCond struct {
|
|
subTable string
|
|
cond squirrel.Sqlizer
|
|
not bool
|
|
}
|
|
|
|
func (e existsCond) ToSql() (string, []any, error) {
|
|
sql, args, err := e.cond.ToSql()
|
|
sql = fmt.Sprintf("exists (select 1 from %s where %s)", e.subTable, sql)
|
|
if e.not {
|
|
sql = "not " + sql
|
|
}
|
|
return sql, args, err
|
|
}
|
|
|
|
var sortOrderRegex = regexp.MustCompile(`order_([a-z_]+)`)
|
|
|
|
// mapSortOrder converts order_* columns to an expression using sort_* columns with NATURALSORT collation. Example:
|
|
// order_album_name -> (coalesce(nullif(sort_album_name,”),order_album_name) collate NATURALSORT)
|
|
// It finds order column names anywhere in the substring
|
|
func mapSortOrder(tableName, order string) string {
|
|
order = strings.ToLower(order)
|
|
repl := fmt.Sprintf("(coalesce(nullif(%[1]s.sort_$1,''),%[1]s.order_$1) collate NATURALSORT)", tableName)
|
|
return sortOrderRegex.ReplaceAllString(order, repl)
|
|
}
|
|
|
|
// mapNaturalSortCollation wraps bare order_* column references with NATURALSORT collation. Example:
|
|
// order_album_name -> (order_album_name collate NATURALSORT)
|
|
// It finds order column names anywhere in the substring
|
|
func mapNaturalSortCollation(order string) string {
|
|
order = strings.ToLower(order)
|
|
return sortOrderRegex.ReplaceAllString(order, "(order_$1 collate NATURALSORT)")
|
|
}
|