fix(server): fix case-insensitive sort order and add indexes to improve performance (#3425)

* refactor(server): better sort mappings

* refactor(server): simplify GetIndex

* fix: recreate tables and indexes using proper collation

Also add tests to ensure proper collation

* chore: remove unused method

* fix: sort expressions

* fix: lint errors

* fix: cleanup

persistence/album_repository.go

@@ -69,27 +69,15 @@ func NewAlbumRepository(ctx context.Context, db dbx.Builder) model.AlbumReposito
 		"has_rating":      hasRatingFilter,
 		"genre_id":        eqFilter,
 	})
-	if conf.Server.PreferSortTags {
-		r.sortMappings = map[string]string{
-			"name":           "COALESCE(NULLIF(sort_album_name,''),order_album_name)",
-			"artist":         "compilation asc, COALESCE(NULLIF(sort_album_artist_name,''),order_album_artist_name) asc, COALESCE(NULLIF(sort_album_name,''),order_album_name) asc",
-			"album_artist":   "compilation asc, COALESCE(NULLIF(sort_album_artist_name,''),order_album_artist_name) asc, COALESCE(NULLIF(sort_album_name,''),order_album_name) asc",
-			"max_year":       "coalesce(nullif(original_date,''), cast(max_year as text)), release_date, name, COALESCE(NULLIF(sort_album_name,''),order_album_name) asc",
-			"random":         "random",
-			"recently_added": recentlyAddedSort(),
-			"starred_at":     "starred, starred_at",
-		}
-	} else {
-		r.sortMappings = map[string]string{
-			"name":           "order_album_name asc, order_album_artist_name asc",
-			"artist":         "compilation asc, order_album_artist_name asc, order_album_name asc",
-			"album_artist":   "compilation asc, order_album_artist_name asc, order_album_name asc",
-			"max_year":       "coalesce(nullif(original_date,''), cast(max_year as text)), release_date, name, order_album_name asc",
-			"random":         "random",
-			"recently_added": recentlyAddedSort(),
-			"starred_at":     "starred, starred_at",
-		}
-	}
+	r.setSortMappings(map[string]string{
+		"name":           "order_album_name, order_album_artist_name",
+		"artist":         "compilation, order_album_artist_name, order_album_name",
+		"album_artist":   "compilation, order_album_artist_name, order_album_name",
+		"max_year":       "coalesce(nullif(original_date,''), cast(max_year as text)), release_date, name",
+		"random":         "random",
+		"recently_added": recentlyAddedSort(),
+		"starred_at":     "starred, starred_at",
+	})
 
 	return r
 }

persistence/artist_repository.go

@@ -5,7 +5,7 @@ import (
 	"context"
 	"fmt"
 	"net/url"
-	"sort"
+	"slices"
 	"strings"
 
 	. "github.com/Masterminds/squirrel"
@@ -15,7 +15,7 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils"
-	"github.com/navidrome/navidrome/utils/str"
+	"github.com/navidrome/navidrome/utils/slice"
 	"github.com/pocketbase/dbx"
 )
 
@@ -67,17 +67,10 @@ func NewArtistRepository(ctx context.Context, db dbx.Builder) model.ArtistReposi
 		"starred":  booleanFilter,
 		"genre_id": eqFilter,
 	})
-	if conf.Server.PreferSortTags {
-		r.sortMappings = map[string]string{
-			"name":       "COALESCE(NULLIF(sort_artist_name,''),order_artist_name)",
-			"starred_at": "starred, starred_at",
-		}
-	} else {
-		r.sortMappings = map[string]string{
-			"name":       "order_artist_name",
-			"starred_at": "starred, starred_at",
-		}
-	}
+	r.setSortMappings(map[string]string{
+		"name":       "order_artist_name",
+		"starred_at": "starred, starred_at",
+	})
 	return r
 }
 
@@ -143,15 +136,14 @@ func (r *artistRepository) toModels(dba []dbArtist) model.Artists {
 	return res
 }
 
-func (r *artistRepository) getIndexKey(a *model.Artist) string {
-	source := a.Name
+func (r *artistRepository) getIndexKey(a model.Artist) string {
+	source := a.OrderArtistName
 	if conf.Server.PreferSortTags {
-		source = cmp.Or(a.SortArtistName, a.OrderArtistName, source)
+		source = cmp.Or(a.SortArtistName, a.OrderArtistName)
 	}
-	name := strings.ToLower(str.RemoveArticle(source))
+	name := strings.ToLower(source)
 	for k, v := range r.indexGroups {
-		key := strings.ToLower(k)
-		if strings.HasPrefix(name, key) {
+		if strings.HasPrefix(name, strings.ToLower(k)) {
 			return v
 		}
 	}
@@ -160,32 +152,16 @@ func (r *artistRepository) getIndexKey(a *model.Artist) string {
 
 // TODO Cache the index (recalculate when there are changes to the DB)
 func (r *artistRepository) GetIndex() (model.ArtistIndexes, error) {
-	sortColumn := "order_artist_name"
-	if conf.Server.PreferSortTags {
-		sortColumn = "sort_artist_name, order_artist_name"
-	}
-	all, err := r.GetAll(model.QueryOptions{Sort: sortColumn})
+	artists, err := r.GetAll(model.QueryOptions{Sort: "name"})
 	if err != nil {
 		return nil, err
 	}
-
-	fullIdx := make(map[string]*model.ArtistIndex)
-	for i := range all {
-		a := all[i]
-		ax := r.getIndexKey(&a)
-		idx, ok := fullIdx[ax]
-		if !ok {
-			idx = &model.ArtistIndex{ID: ax}
-			fullIdx[ax] = idx
-		}
-		idx.Artists = append(idx.Artists, a)
-	}
 	var result model.ArtistIndexes
-	for _, idx := range fullIdx {
-		result = append(result, *idx)
+	for k, v := range slice.Group(artists, r.getIndexKey) {
+		result = append(result, model.ArtistIndex{ID: k, Artists: v})
 	}
-	sort.Slice(result, func(i, j int) bool {
-		return result[i].ID < result[j].ID
+	slices.SortFunc(result, func(a, b model.ArtistIndex) int {
+		return cmp.Compare(a.ID, b.ID)
 	})
 	return result, nil
 }

persistence/artist_repository_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/fatih/structs"
 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
@@ -46,163 +47,146 @@ var _ = Describe("ArtistRepository", func() {
 	})
 
 	Describe("GetIndexKey", func() {
+		// Note: OrderArtistName should never be empty, so we don't need to test for that
 		r := artistRepository{indexGroups: utils.ParseIndexGroups(conf.Server.IndexGroups)}
-		It("returns the index key when PreferSortTags is true and SortArtistName is not empty", func() {
-			conf.Server.PreferSortTags = true
-			a := model.Artist{SortArtistName: "Foo", OrderArtistName: "Bar", Name: "Qux"}
-			idx := GetIndexKey(&r, &a) // defines export_test.go
-			Expect(idx).To(Equal("F"))
-
-			a = model.Artist{SortArtistName: "foo", OrderArtistName: "Bar", Name: "Qux"}
-			idx = GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("F"))
+		When("PreferSortTags is false", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig)
+				conf.Server.PreferSortTags = false
+			})
+			It("returns the OrderArtistName key is SortArtistName is empty", func() {
+				conf.Server.PreferSortTags = false
+				a := model.Artist{SortArtistName: "", OrderArtistName: "Bar", Name: "Qux"}
+				idx := GetIndexKey(&r, a)
+				Expect(idx).To(Equal("B"))
+			})
+			It("returns the OrderArtistName key even if SortArtistName is not empty", func() {
+				a := model.Artist{SortArtistName: "Foo", OrderArtistName: "Bar", Name: "Qux"}
+				idx := GetIndexKey(&r, a)
+				Expect(idx).To(Equal("B"))
+			})
 		})
-
-		It("returns the index key when PreferSortTags is true, SortArtistName is empty and OrderArtistName is not empty", func() {
-			conf.Server.PreferSortTags = true
-			a := model.Artist{SortArtistName: "", OrderArtistName: "Bar", Name: "Qux"}
-			idx := GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("B"))
-
-			a = model.Artist{SortArtistName: "", OrderArtistName: "bar", Name: "Qux"}
-			idx = GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("B"))
-		})
-
-		It("returns the index key when PreferSortTags is true, both SortArtistName, OrderArtistName are empty", func() {
-			conf.Server.PreferSortTags = true
-			a := model.Artist{SortArtistName: "", OrderArtistName: "", Name: "Qux"}
-			idx := GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
-
-			a = model.Artist{SortArtistName: "", OrderArtistName: "", Name: "qux"}
-			idx = GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
-		})
-
-		It("returns the index key when PreferSortTags is false and SortArtistName is not empty", func() {
-			conf.Server.PreferSortTags = false
-			a := model.Artist{SortArtistName: "Foo", OrderArtistName: "Bar", Name: "Qux"}
-			idx := GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
-		})
-
-		It("returns the index key when PreferSortTags is true, SortArtistName is empty and OrderArtistName is not empty", func() {
-			conf.Server.PreferSortTags = false
-			a := model.Artist{SortArtistName: "", OrderArtistName: "Bar", Name: "Qux"}
-			idx := GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
-		})
-
-		It("returns the index key when PreferSortTags is true, both sort_artist_name, order_artist_name are empty", func() {
-			conf.Server.PreferSortTags = false
-			a := model.Artist{SortArtistName: "", OrderArtistName: "", Name: "Qux"}
-			idx := GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
-
-			a = model.Artist{SortArtistName: "", OrderArtistName: "", Name: "qux"}
-			idx = GetIndexKey(&r, &a)
-			Expect(idx).To(Equal("Q"))
+		When("PreferSortTags is true", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig)
+				conf.Server.PreferSortTags = true
+			})
+			It("returns the SortArtistName key if it is not empty", func() {
+				a := model.Artist{SortArtistName: "Foo", OrderArtistName: "Bar", Name: "Qux"}
+				idx := GetIndexKey(&r, a)
+				Expect(idx).To(Equal("F"))
+			})
+			It("returns the OrderArtistName key if SortArtistName is empty", func() {
+				a := model.Artist{SortArtistName: "", OrderArtistName: "Bar", Name: "Qux"}
+				idx := GetIndexKey(&r, a)
+				Expect(idx).To(Equal("B"))
+			})
 		})
 	})
 
 	Describe("GetIndex", func() {
-		It("returns the index when PreferSortTags is true and SortArtistName is not empty", func() {
-			conf.Server.PreferSortTags = true
+		When("PreferSortTags is true", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig)
+				conf.Server.PreferSortTags = true
+			})
+			It("returns the index when SortArtistName is not empty", func() {
+				artistBeatles.SortArtistName = "Foo"
+				er := repo.Put(&artistBeatles)
+				Expect(er).To(BeNil())
 
-			artistBeatles.SortArtistName = "Foo"
-			er := repo.Put(&artistBeatles)
-			Expect(er).To(BeNil())
-
-			idx, err := repo.GetIndex()
-			Expect(err).To(BeNil())
-			Expect(idx).To(Equal(model.ArtistIndexes{
-				{
-					ID: "F",
-					Artists: model.Artists{
-						artistBeatles,
+				idx, err := repo.GetIndex()
+				Expect(err).To(BeNil())
+				Expect(idx).To(Equal(model.ArtistIndexes{
+					{
+						ID: "F",
+						Artists: model.Artists{
+							artistBeatles,
+						},
 					},
-				},
-				{
-					ID: "K",
-					Artists: model.Artists{
-						artistKraftwerk,
+					{
+						ID: "K",
+						Artists: model.Artists{
+							artistKraftwerk,
+						},
 					},
-				},
-			}))
+				}))
 
-			artistBeatles.SortArtistName = ""
-			er = repo.Put(&artistBeatles)
-			Expect(er).To(BeNil())
+				artistBeatles.SortArtistName = ""
+				er = repo.Put(&artistBeatles)
+				Expect(er).To(BeNil())
+			})
+
+			It("returns the index when SortArtistName is empty", func() {
+				idx, err := repo.GetIndex()
+				Expect(err).To(BeNil())
+				Expect(idx).To(Equal(model.ArtistIndexes{
+					{
+						ID: "B",
+						Artists: model.Artists{
+							artistBeatles,
+						},
+					},
+					{
+						ID: "K",
+						Artists: model.Artists{
+							artistKraftwerk,
+						},
+					},
+				}))
+			})
 		})
 
-		It("returns the index when PreferSortTags is true and SortArtistName is empty", func() {
-			conf.Server.PreferSortTags = true
-			idx, err := repo.GetIndex()
-			Expect(err).To(BeNil())
-			Expect(idx).To(Equal(model.ArtistIndexes{
-				{
-					ID: "B",
-					Artists: model.Artists{
-						artistBeatles,
-					},
-				},
-				{
-					ID: "K",
-					Artists: model.Artists{
-						artistKraftwerk,
-					},
-				},
-			}))
-		})
+		When("PreferSortTags is false", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig)
+				conf.Server.PreferSortTags = false
+			})
+			It("returns the index when SortArtistName is not empty", func() {
+				artistBeatles.SortArtistName = "Foo"
+				er := repo.Put(&artistBeatles)
+				Expect(er).To(BeNil())
 
-		It("returns the index when PreferSortTags is false and SortArtistName is not empty", func() {
-			conf.Server.PreferSortTags = false
-
-			artistBeatles.SortArtistName = "Foo"
-			er := repo.Put(&artistBeatles)
-			Expect(er).To(BeNil())
-
-			idx, err := repo.GetIndex()
-			Expect(err).To(BeNil())
-			Expect(idx).To(Equal(model.ArtistIndexes{
-				{
-					ID: "B",
-					Artists: model.Artists{
-						artistBeatles,
+				idx, err := repo.GetIndex()
+				Expect(err).To(BeNil())
+				Expect(idx).To(Equal(model.ArtistIndexes{
+					{
+						ID: "B",
+						Artists: model.Artists{
+							artistBeatles,
+						},
 					},
-				},
-				{
-					ID: "K",
-					Artists: model.Artists{
-						artistKraftwerk,
+					{
+						ID: "K",
+						Artists: model.Artists{
+							artistKraftwerk,
+						},
 					},
-				},
-			}))
+				}))
 
-			artistBeatles.SortArtistName = ""
-			er = repo.Put(&artistBeatles)
-			Expect(er).To(BeNil())
-		})
+				artistBeatles.SortArtistName = ""
+				er = repo.Put(&artistBeatles)
+				Expect(er).To(BeNil())
+			})
 
-		It("returns the index when PreferSortTags is false and SortArtistName is empty", func() {
-			conf.Server.PreferSortTags = false
-			idx, err := repo.GetIndex()
-			Expect(err).To(BeNil())
-			Expect(idx).To(Equal(model.ArtistIndexes{
-				{
-					ID: "B",
-					Artists: model.Artists{
-						artistBeatles,
+			It("returns the index when SortArtistName is empty", func() {
+				idx, err := repo.GetIndex()
+				Expect(err).To(BeNil())
+				Expect(idx).To(Equal(model.ArtistIndexes{
+					{
+						ID: "B",
+						Artists: model.Artists{
+							artistBeatles,
+						},
 					},
-				},
-				{
-					ID: "K",
-					Artists: model.Artists{
-						artistKraftwerk,
+					{
+						ID: "K",
+						Artists: model.Artists{
+							artistKraftwerk,
+						},
 					},
-				},
-			}))
+				}))
+			})
 		})
 	})
 

persistence/collation_test.go

@@ -0,0 +1,122 @@
+package persistence
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"regexp"
+
+	"github.com/navidrome/navidrome/db"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+// When creating migrations that change existing columns, it is easy to miss the original collation of a column.
+// These tests enforce that the required collation of the columns and indexes in the database are kept in place.
+// This is important to ensure that the database can perform fast case-insensitive searches and sorts.
+var _ = Describe("Collation", func() {
+	conn := db.Db().ReadDB()
+	DescribeTable("Column collation",
+		func(table, column string) {
+			Expect(checkCollation(conn, table, column)).To(Succeed())
+		},
+		Entry("artist.order_artist_name", "artist", "order_artist_name"),
+		Entry("artist.sort_artist_name", "artist", "sort_artist_name"),
+		Entry("album.order_album_name", "album", "order_album_name"),
+		Entry("album.order_album_artist_name", "album", "order_album_artist_name"),
+		Entry("album.sort_album_name", "album", "sort_album_name"),
+		Entry("album.sort_album_artist_name", "album", "sort_album_artist_name"),
+		Entry("media_file.order_title", "media_file", "order_title"),
+		Entry("media_file.order_album_name", "media_file", "order_album_name"),
+		Entry("media_file.order_artist_name", "media_file", "order_artist_name"),
+		Entry("media_file.sort_title", "media_file", "sort_title"),
+		Entry("media_file.sort_album_name", "media_file", "sort_album_name"),
+		Entry("media_file.sort_artist_name", "media_file", "sort_artist_name"),
+		Entry("radio.name", "radio", "name"),
+		Entry("user.name", "user", "name"),
+	)
+
+	DescribeTable("Index collation",
+		func(table, column string) {
+			Expect(checkIndexUsage(conn, table, column)).To(Succeed())
+		},
+		Entry("artist.order_artist_name", "artist", "order_artist_name collate nocase"),
+		Entry("artist.sort_artist_name", "artist", "coalesce(nullif(sort_artist_name,''),order_artist_name) collate nocase"),
+		Entry("album.order_album_name", "album", "order_album_name collate nocase"),
+		Entry("album.order_album_artist_name", "album", "order_album_artist_name collate nocase"),
+		Entry("album.sort_album_name", "album", "coalesce(nullif(sort_album_name,''),order_album_name) collate nocase"),
+		Entry("album.sort_album_artist_name", "album", "coalesce(nullif(sort_album_artist_name,''),order_album_artist_name) collate nocase"),
+		Entry("media_file.order_title", "media_file", "order_title collate nocase"),
+		Entry("media_file.order_album_name", "media_file", "order_album_name collate nocase"),
+		Entry("media_file.order_artist_name", "media_file", "order_artist_name collate nocase"),
+		Entry("media_file.sort_title", "media_file", "coalesce(nullif(sort_title,''),order_title) collate nocase"),
+		Entry("media_file.sort_album_name", "media_file", "coalesce(nullif(sort_album_name,''),order_album_name) collate nocase"),
+		Entry("media_file.sort_artist_name", "media_file", "coalesce(nullif(sort_artist_name,''),order_artist_name) collate nocase"),
+		Entry("media_file.path", "media_file", "path collate nocase"),
+		Entry("radio.name", "radio", "name collate nocase"),
+		Entry("user.user_name", "user", "user_name collate nocase"),
+	)
+})
+
+func checkIndexUsage(conn *sql.DB, table string, column string) error {
+	rows, err := conn.Query(fmt.Sprintf(`
+explain query plan select * from %[1]s
+where %[2]s = 'test'
+order by %[2]s`, table, column))
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+
+	err = rows.Err()
+	if err != nil {
+		return err
+	}
+
+	if rows.Next() {
+		var dummy int
+		var detail string
+		err = rows.Scan(&dummy, &dummy, &dummy, &detail)
+		if err != nil {
+			return nil
+		}
+		if ok, _ := regexp.MatchString("SEARCH.*USING INDEX", detail); ok {
+			return nil
+		} else {
+			return fmt.Errorf("INDEX for '%s' not used: %s", column, detail)
+		}
+	}
+	return errors.New("no rows returned")
+}
+
+func checkCollation(conn *sql.DB, table string, column string) error {
+	rows, err := conn.Query(fmt.Sprintf("SELECT sql FROM sqlite_master WHERE type='table' AND tbl_name='%s'", table))
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+
+	err = rows.Err()
+	if err != nil {
+		return err
+	}
+
+	if rows.Next() {
+		var res string
+		err = rows.Scan(&res)
+		if err != nil {
+			return err
+		}
+		re := regexp.MustCompile(fmt.Sprintf(`(?i)\b%s\b.*varchar`, column))
+		if !re.MatchString(res) {
+			return fmt.Errorf("column '%s' not found in table '%s'", column, table)
+		}
+		re = regexp.MustCompile(fmt.Sprintf(`(?i)\b%s\b.*collate\s+NOCASE`, column))
+		if re.MatchString(res) {
+			return nil
+		}
+	} else {
+		return fmt.Errorf("table '%s' not found", table)
+	}
+	return fmt.Errorf("column '%s' in table '%s' does not have NOCASE collation", column, table)
+}

persistence/helpers.go

@@ -81,3 +81,13 @@ func (e existsCond) ToSql() (string, []interface{}, error) {
 	}
 	return sql, args, err
 }
+
+var sortOrderRegex = regexp.MustCompile(`order_([a-z_]+)`)
+
+// Convert the order_* columns to an expression using sort_* columns. Example:
+// sort_album_name -> (coalesce(nullif(sort_album_name,”),order_album_name) collate nocase)
+// It finds order column names anywhere in the substring
+func mapSortOrder(order string) string {
+	order = strings.ToLower(order)
+	return sortOrderRegex.ReplaceAllString(order, "(coalesce(nullif(sort_$1,''),order_$1) collate nocase)")
+}

persistence/helpers_test.go

@@ -83,4 +83,23 @@ var _ = Describe("Helpers", func() {
 			Expect(err).To(BeNil())
 		})
 	})
+
+	Describe("mapSortOrder", func() {
+		It("does not change the sort string if there are no order columns", func() {
+			sort := "album_name asc"
+			mapped := mapSortOrder(sort)
+			Expect(mapped).To(Equal(sort))
+		})
+		It("changes order columns to sort expression", func() {
+			sort := "ORDER_ALBUM_NAME asc"
+			mapped := mapSortOrder(sort)
+			Expect(mapped).To(Equal("(coalesce(nullif(sort_album_name,''),order_album_name) collate nocase) asc"))
+		})
+		It("changes multiple order columns to sort expressions", func() {
+			sort := "compilation, order_title asc, order_album_artist_name desc, year desc"
+			mapped := mapSortOrder(sort)
+			Expect(mapped).To(Equal(`compilation, (coalesce(nullif(sort_title,''),order_title) collate nocase) asc,` +
+				` (coalesce(nullif(sort_album_artist_name,''),order_album_artist_name) collate nocase) desc, year desc`))
+		})
+	})
 })

persistence/mediafile_repository.go

@@ -10,7 +10,6 @@ import (
 
 	. "github.com/Masterminds/squirrel"
 	"github.com/deluan/rest"
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/pocketbase/dbx"
@@ -31,25 +30,14 @@ func NewMediaFileRepository(ctx context.Context, db dbx.Builder) *mediaFileRepos
 		"starred":  booleanFilter,
 		"genre_id": eqFilter,
 	})
-	if conf.Server.PreferSortTags {
-		r.sortMappings = map[string]string{
-			"title":      "COALESCE(NULLIF(sort_title,''),order_title)",
-			"artist":     "COALESCE(NULLIF(sort_artist_name,''),order_artist_name) asc, COALESCE(NULLIF(sort_album_name,''),order_album_name) asc, release_date asc, disc_number asc, track_number asc",
-			"album":      "COALESCE(NULLIF(sort_album_name,''),order_album_name) asc, release_date asc, disc_number asc, track_number asc, COALESCE(NULLIF(sort_artist_name,''),order_artist_name) asc, COALESCE(NULLIF(sort_title,''),title) asc",
-			"random":     "random",
-			"created_at": "media_file.created_at",
-			"starred_at": "starred, starred_at",
-		}
-	} else {
-		r.sortMappings = map[string]string{
-			"title":      "order_title",
-			"artist":     "order_artist_name asc, order_album_name asc, release_date asc, disc_number asc, track_number asc",
-			"album":      "order_album_name asc, release_date asc, disc_number asc, track_number asc, order_artist_name asc, title asc",
-			"random":     "random",
-			"created_at": "media_file.created_at",
-			"starred_at": "starred, starred_at",
-		}
-	}
+	r.setSortMappings(map[string]string{
+		"title":      "order_title",
+		"artist":     "order_artist_name, order_album_name, release_date, disc_number, track_number",
+		"album":      "order_album_name, release_date, disc_number, track_number, order_artist_name, title",
+		"random":     "random",
+		"created_at": "media_file.created_at",
+		"starred_at": "starred, starred_at",
+	})
 	return r
 }
 
@@ -115,18 +103,6 @@ func (r *mediaFileRepository) GetAll(options ...model.QueryOptions) (model.Media
 	return res, err
 }
 
-func (r *mediaFileRepository) FindByPath(path string) (*model.MediaFile, error) {
-	sel := r.newSelect().Columns("*").Where(Like{"path": path})
-	var res model.MediaFiles
-	if err := r.queryAll(sel, &res); err != nil {
-		return nil, err
-	}
-	if len(res) == 0 {
-		return nil, model.ErrNotFound
-	}
-	return &res[0], nil
-}
-
 func (r *mediaFileRepository) FindByPaths(paths []string) (model.MediaFiles, error) {
 	sel := r.newSelect().Columns("*").Where(Eq{"path collate nocase": paths})
 	var res model.MediaFiles

persistence/player_repository.go

@@ -21,9 +21,9 @@ func NewPlayerRepository(ctx context.Context, db dbx.Builder) model.PlayerReposi
 	r.registerModel(&model.Player{}, map[string]filterFunc{
 		"name": containsFilter("player.name"),
 	})
-	r.sortMappings = map[string]string{
+	r.setSortMappings(map[string]string{
 		"user_name": "username", //TODO rename all user_name and userName to username
-	}
+	})
 	return r
 }
 

persistence/playlist_repository.go

@@ -55,9 +55,9 @@ func NewPlaylistRepository(ctx context.Context, db dbx.Builder) model.PlaylistRe
 		"q":     playlistFilter,
 		"smart": smartPlaylistFilter,
 	})
-	r.sortMappings = map[string]string{
+	r.setSortMappings(map[string]string{
 		"owner_name": "owner_name",
-	}
+	})
 	return r
 }
 

persistence/playlist_track_repository.go

@@ -5,7 +5,6 @@ import (
 
 	. "github.com/Masterminds/squirrel"
 	"github.com/deluan/rest"
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils/slice"
@@ -26,18 +25,13 @@ func (r *playlistRepository) Tracks(playlistId string, refreshSmartPlaylist bool
 	p.db = r.db
 	p.tableName = "playlist_tracks"
 	p.registerModel(&model.PlaylistTrack{}, nil)
-	p.sortMappings = map[string]string{
+	p.setSortMappings(map[string]string{
 		"id":       "playlist_tracks.id",
-		"artist":   "order_artist_name asc",
-		"album":    "order_album_name asc, order_album_artist_name asc",
+		"artist":   "order_artist_name",
+		"album":    "order_album_name, order_album_artist_name",
 		"title":    "order_title",
 		"duration": "duration", // To make sure the field will be whitelisted
-	}
-	if conf.Server.PreferSortTags {
-		p.sortMappings["artist"] = "COALESCE(NULLIF(sort_artist_name,''),order_artist_name) asc"
-		p.sortMappings["album"] = "COALESCE(NULLIF(sort_album_name,''),order_album_name)"
-		p.sortMappings["title"] = "COALESCE(NULLIF(sort_title,''),title)"
-	}
+	})
 
 	pls, err := r.Get(playlistId)
 	if err != nil {

persistence/radio_repository.go

@@ -24,9 +24,6 @@ func NewRadioRepository(ctx context.Context, db dbx.Builder) model.RadioReposito
 	r.registerModel(&model.Radio{}, map[string]filterFunc{
 		"name": containsFilter("name"),
 	})
-	r.sortMappings = map[string]string{
-		"name": "(name collate nocase), name",
-	}
 	return r
 }
 

persistence/share_repository.go

@@ -23,10 +23,10 @@ func NewShareRepository(ctx context.Context, db dbx.Builder) model.ShareReposito
 	r := &shareRepository{}
 	r.ctx = ctx
 	r.db = db
-	r.registerModel(&model.Share{}, map[string]filterFunc{})
-	r.sortMappings = map[string]string{
+	r.registerModel(&model.Share{}, nil)
+	r.setSortMappings(map[string]string{
 		"username": "username",
-	}
+	})
 	return r
 }
 

persistence/sql_base_repository.go

@@ -27,17 +27,20 @@ import (
 //   - Call registerModel with the model instance and any possible filters.
 //   - If the model has a different table name than the default (lowercase of the model name), it should be set manually
 //     using the tableName field.
-//   - Sort mappings should be set in the sortMappings field. If the sort field is not in the map, it will be used as is.
+//   - Sort mappings must be set with setSortMappings method. If a sort field is not in the map, it will be used as the name of the column.
 //
 // All fields in filters and sortMappings must be in snake_case. Only sorts and filters based on real field names or
 // defined in the mappings will be allowed.
 type sqlRepository struct {
-	ctx                context.Context
-	tableName          string
-	db                 dbx.Builder
-	sortMappings       map[string]string
+	ctx       context.Context
+	tableName string
+	db        dbx.Builder
+
+	// Do not set these fields manually, they are set by the registerModel method
 	filterMappings     map[string]filterFunc
 	isFieldWhiteListed fieldWhiteListedFunc
+	// Do not set this field manually, it is set by the setSortMappings method
+	sortMappings map[string]string
 }
 
 const invalidUserId = "-1"
@@ -68,6 +71,22 @@ func (r *sqlRepository) registerModel(instance any, filters map[string]filterFun
 	r.filterMappings = filters
 }
 
+// setSortMappings sets the mappings for the sort fields. If the sort field is not in the map, it will be used as is.
+//
+// If PreferSortTags is enabled, it will map the order fields to the corresponding sort expression,
+// which gives precedence to sort tags.
+// Ex: order_title => (coalesce(nullif(sort_title,”),order_title) collate nocase)
+// To avoid performance issues, indexes should be created for these sort expressions
+func (r *sqlRepository) setSortMappings(mappings map[string]string) {
+	if conf.Server.PreferSortTags {
+		for k, v := range mappings {
+			v = mapSortOrder(v)
+			mappings[k] = v
+		}
+	}
+	r.sortMappings = mappings
+}
+
 func (r sqlRepository) getTableName() string {
 	return r.tableName
 }