diff --git a/model/criteria/criteria.go b/model/criteria/criteria.go
index 278acf34c..1e161c9f2 100644
--- a/model/criteria/criteria.go
+++ b/model/criteria/criteria.go
@@ -1,17 +1,16 @@
-// Package criteria implements a Criteria API based on Masterminds/squirrel
+// Package criteria implements the smart playlist criteria DSL.
 package criteria
 
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
-	"strings"
 
-	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/log"
 )
 
-type Expression = squirrel.Sqlizer
+type Expression interface {
+	criteriaExpression()
+}
 
 type Criteria struct {
 	Expression
@@ -49,115 +48,12 @@ func (c Criteria) IsPercentageLimit() bool {
 	return c.Limit == 0 && c.LimitPercent > 0 && c.LimitPercent <= 100
 }
 
-func (c Criteria) OrderBy() string {
-	if c.Sort == "" {
-		c.Sort = "title"
-	}
-
-	order := strings.ToLower(strings.TrimSpace(c.Order))
-	if order != "" && order != "asc" && order != "desc" {
-		log.Error("Invalid value in 'order' field. Valid values: 'asc', 'desc'", "order", c.Order)
-		order = ""
-	}
-
-	parts := strings.Split(c.Sort, ",")
-	fields := make([]string, 0, len(parts))
-
-	for _, p := range parts {
-		p = strings.TrimSpace(p)
-		if p == "" {
-			continue
-		}
-
-		dir := "asc"
-		if strings.HasPrefix(p, "+") || strings.HasPrefix(p, "-") {
-			if strings.HasPrefix(p, "-") {
-				dir = "desc"
-			}
-			p = strings.TrimSpace(p[1:])
-		}
-
-		sortField := strings.ToLower(p)
-		f := fieldMap[sortField]
-		if f == nil {
-			log.Error("Invalid field in 'sort' field", "sort", sortField)
-			continue
-		}
-
-		var mapped string
-
-		if f.order != "" {
-			mapped = f.order
-		} else if f.isTag {
-			// Use the actual field name (handles aliases like albumtype -> releasetype)
-			tagName := sortField
-			if f.field != "" {
-				tagName = f.field
-			}
-			mapped = "COALESCE(json_extract(media_file.tags, '$." + tagName + "[0].value'), '')"
-		} else if f.isRole {
-			mapped = "COALESCE(json_extract(media_file.participants, '$." + sortField + "[0].name'), '')"
-		} else {
-			mapped = f.field
-		}
-		if f.numeric {
-			mapped = fmt.Sprintf("CAST(%s AS REAL)", mapped)
-		}
-		// If the global 'order' field is set to 'desc', reverse the default or field-specific sort direction.
-		// This ensures that the global order applies consistently across all fields.
-		if order == "desc" {
-			if dir == "asc" {
-				dir = "desc"
-			} else {
-				dir = "asc"
-			}
-		}
-
-		fields = append(fields, mapped+" "+dir)
-	}
-
-	return strings.Join(fields, ", ")
-}
-
-func (c Criteria) ToSql() (sql string, args []any, err error) {
-	return c.Expression.ToSql()
-}
-
-// ExpressionJoins returns only the JOINs needed by the WHERE-clause expression,
-// excluding any JOINs required solely for sorting. This is useful for COUNT
-// queries where sort order is irrelevant.
-func (c Criteria) ExpressionJoins() JoinType {
-	if c.Expression == nil {
-		return JoinNone
-	}
-	return extractJoinTypes(c.Expression)
-}
-
-// RequiredJoins inspects the expression tree and Sort field to determine which
-// additional JOINs are needed when evaluating this criteria.
-func (c Criteria) RequiredJoins() JoinType {
-	result := JoinNone
-	if c.Expression != nil {
-		result |= extractJoinTypes(c.Expression)
-	}
-	// Also check Sort fields
-	if c.Sort != "" {
-		for _, p := range strings.Split(c.Sort, ",") {
-			p = strings.TrimSpace(p)
-			p = strings.TrimLeft(p, "+-")
-			p = strings.TrimSpace(p)
-			result |= fieldJoinType(p)
-		}
-	}
-	return result
-}
-
 func (c Criteria) ChildPlaylistIds() []string {
 	if c.Expression == nil {
 		return nil
 	}
 
-	if parent := c.Expression.(interface{ ChildPlaylistIds() (ids []string) }); parent != nil {
+	if parent, ok := c.Expression.(interface{ ChildPlaylistIds() (ids []string) }); ok {
 		return parent.ChildPlaylistIds()
 	}
 
diff --git a/model/criteria/criteria_test.go b/model/criteria/criteria_test.go
index a76b3fc1f..e0940a509 100644
--- a/model/criteria/criteria_test.go
+++ b/model/criteria/criteria_test.go
@@ -65,16 +65,6 @@ var _ = Describe("Criteria", func() {
 			}
 			jsonObj = b.String()
 		})
-		It("generates valid SQL", func() {
-			sql, args, err := goObj.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal(
-				`(media_file.title LIKE ? AND media_file.title NOT LIKE ? ` +
-					`AND (not exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value = ?) ` +
-					`OR media_file.album = ?) AND (media_file.comment LIKE ? AND (media_file.year >= ? AND media_file.year <= ?) ` +
-					`AND not exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value = ?) AND COALESCE(album_annotation.rating, 0) > ?))`))
-			gomega.Expect(args).To(gomega.HaveExactElements("%love%", "%hate%", "u2", "best of", "this%", 1980, 1990, "Rock", 3))
-		})
 		It("marshals to JSON", func() {
 			j, err := json.Marshal(goObj)
 			gomega.Expect(err).ToNot(gomega.HaveOccurred())
@@ -88,201 +78,6 @@ var _ = Describe("Criteria", func() {
 			gomega.Expect(err).ToNot(gomega.HaveOccurred())
 			gomega.Expect(string(j)).To(gomega.Equal(jsonObj))
 		})
-		Describe("OrderBy", func() {
-			It("sorts by regular fields", func() {
-				gomega.Expect(goObj.OrderBy()).To(gomega.Equal("media_file.title asc"))
-			})
-
-			It("sorts by tag fields", func() {
-				goObj.Sort = "genre"
-				gomega.Expect(goObj.OrderBy()).To(
-					gomega.Equal(
-						"COALESCE(json_extract(media_file.tags, '$.genre[0].value'), '') asc",
-					),
-				)
-			})
-
-			It("sorts by role fields", func() {
-				goObj.Sort = "artist"
-				gomega.Expect(goObj.OrderBy()).To(
-					gomega.Equal(
-						"COALESCE(json_extract(media_file.participants, '$.artist[0].name'), '') asc",
-					),
-				)
-			})
-
-			It("casts numeric tags when sorting", func() {
-				AddTagNames([]string{"rate"})
-				AddNumericTags([]string{"rate"})
-				goObj.Sort = "rate"
-				gomega.Expect(goObj.OrderBy()).To(
-					gomega.Equal("CAST(COALESCE(json_extract(media_file.tags, '$.rate[0].value'), '') AS REAL) asc"),
-				)
-			})
-
-			It("sorts by albumtype alias (resolves to releasetype)", func() {
-				AddTagNames([]string{"releasetype"})
-				goObj.Sort = "albumtype"
-				gomega.Expect(goObj.OrderBy()).To(
-					gomega.Equal(
-						"COALESCE(json_extract(media_file.tags, '$.releasetype[0].value'), '') asc",
-					),
-				)
-			})
-
-			It("sorts by random", func() {
-				newObj := goObj
-				newObj.Sort = "random"
-				gomega.Expect(newObj.OrderBy()).To(gomega.Equal("random() asc"))
-			})
-
-			It("sorts by multiple fields", func() {
-				goObj.Sort = "title,-rating"
-				gomega.Expect(goObj.OrderBy()).To(gomega.Equal(
-					"media_file.title asc, COALESCE(annotation.rating, 0) desc",
-				))
-			})
-
-			It("reverts order when order is desc", func() {
-				goObj.Sort = "-date,artist"
-				goObj.Order = "desc"
-				gomega.Expect(goObj.OrderBy()).To(gomega.Equal(
-					"media_file.date asc, COALESCE(json_extract(media_file.participants, '$.artist[0].name'), '') desc",
-				))
-			})
-
-			It("ignores invalid sort fields", func() {
-				goObj.Sort = "bogus,title"
-				gomega.Expect(goObj.OrderBy()).To(gomega.Equal(
-					"media_file.title asc",
-				))
-			})
-		})
-	})
-
-	Context("with artist roles", func() {
-		BeforeEach(func() {
-			goObj = Criteria{
-				Expression: All{
-					Is{"artist": "The Beatles"},
-					Contains{"composer": "Lennon"},
-				},
-			}
-		})
-
-		It("generates valid SQL", func() {
-			sql, args, err := goObj.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal(
-				`(exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value = ?) AND ` +
-					`exists (select 1 from json_tree(media_file.participants, '$.composer') where key='name' and value LIKE ?))`,
-			))
-			gomega.Expect(args).To(gomega.HaveExactElements("The Beatles", "%Lennon%"))
-		})
-	})
-
-	Describe("ExpressionJoins", func() {
-		It("excludes sort-only joins", func() {
-			c := Criteria{
-				Expression: All{
-					Contains{"title": "love"},
-				},
-				Sort: "albumRating",
-			}
-			gomega.Expect(c.ExpressionJoins()).To(gomega.Equal(JoinNone))
-			gomega.Expect(c.RequiredJoins().Has(JoinAlbumAnnotation)).To(gomega.BeTrue())
-		})
-
-		It("includes expression-based joins", func() {
-			c := Criteria{
-				Expression: All{
-					Gt{"albumRating": 3},
-				},
-			}
-			gomega.Expect(c.ExpressionJoins().Has(JoinAlbumAnnotation)).To(gomega.BeTrue())
-		})
-	})
-
-	Describe("RequiredJoins", func() {
-		It("returns JoinNone when no annotation fields are used", func() {
-			c := Criteria{
-				Expression: All{
-					Contains{"title": "love"},
-				},
-			}
-			gomega.Expect(c.RequiredJoins()).To(gomega.Equal(JoinNone))
-		})
-		It("returns JoinNone for media_file annotation fields", func() {
-			c := Criteria{
-				Expression: All{
-					Is{"loved": true},
-					Gt{"playCount": 5},
-				},
-			}
-			gomega.Expect(c.RequiredJoins()).To(gomega.Equal(JoinNone))
-		})
-		It("returns JoinAlbumAnnotation for album annotation fields", func() {
-			c := Criteria{
-				Expression: All{
-					Gt{"albumRating": 3},
-				},
-			}
-			gomega.Expect(c.RequiredJoins()).To(gomega.Equal(JoinAlbumAnnotation))
-		})
-		It("returns JoinArtistAnnotation for artist annotation fields", func() {
-			c := Criteria{
-				Expression: All{
-					Is{"artistLoved": true},
-				},
-			}
-			gomega.Expect(c.RequiredJoins()).To(gomega.Equal(JoinArtistAnnotation))
-		})
-		It("returns both join types when both are used", func() {
-			c := Criteria{
-				Expression: All{
-					Gt{"albumRating": 3},
-					Is{"artistLoved": true},
-				},
-			}
-			j := c.RequiredJoins()
-			gomega.Expect(j.Has(JoinAlbumAnnotation)).To(gomega.BeTrue())
-			gomega.Expect(j.Has(JoinArtistAnnotation)).To(gomega.BeTrue())
-		})
-		It("detects join types in nested expressions", func() {
-			c := Criteria{
-				Expression: All{
-					Any{
-						All{
-							Is{"albumLoved": true},
-						},
-					},
-					Any{
-						Gt{"artistPlayCount": 10},
-					},
-				},
-			}
-			j := c.RequiredJoins()
-			gomega.Expect(j.Has(JoinAlbumAnnotation)).To(gomega.BeTrue())
-			gomega.Expect(j.Has(JoinArtistAnnotation)).To(gomega.BeTrue())
-		})
-		It("detects join types from Sort field", func() {
-			c := Criteria{
-				Expression: All{
-					Contains{"title": "love"},
-				},
-				Sort: "albumRating",
-			}
-			gomega.Expect(c.RequiredJoins().Has(JoinAlbumAnnotation)).To(gomega.BeTrue())
-		})
-		It("detects join types from Sort field with direction prefix", func() {
-			c := Criteria{
-				Expression: All{
-					Contains{"title": "love"},
-				},
-				Sort: "-artistRating",
-			}
-			gomega.Expect(c.RequiredJoins().Has(JoinArtistAnnotation)).To(gomega.BeTrue())
-		})
 	})
 
 	Describe("LimitPercent", func() {
@@ -470,5 +265,9 @@ var _ = Describe("Criteria", func() {
 			ids := Criteria{}.ChildPlaylistIds()
 			gomega.Expect(ids).To(gomega.BeEmpty())
 		})
+		It("returns empty list for leaf expressions", func() {
+			ids := Criteria{Expression: Is{"title": "Low Rider"}}.ChildPlaylistIds()
+			gomega.Expect(ids).To(gomega.BeEmpty())
+		})
 	})
 })
diff --git a/model/criteria/fields.go b/model/criteria/fields.go
index bc3c7a3d3..30541a945 100644
--- a/model/criteria/fields.go
+++ b/model/criteria/fields.go
@@ -1,280 +1,133 @@
 package criteria
 
-import (
-	"fmt"
-	"reflect"
-	"strings"
+import "strings"
 
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/log"
-)
-
-// JoinType is a bitmask indicating which additional JOINs are needed by a smart playlist expression.
-type JoinType int
-
-const (
-	JoinNone            JoinType = 0
-	JoinAlbumAnnotation JoinType = 1 << iota
-	JoinArtistAnnotation
-)
-
-// Has returns true if j contains all bits in other.
-func (j JoinType) Has(other JoinType) bool { return j&other != 0 }
-
-var fieldMap = map[string]*mappedField{
-	"title":           {field: "media_file.title"},
-	"album":           {field: "media_file.album"},
-	"hascoverart":     {field: "media_file.has_cover_art"},
-	"tracknumber":     {field: "media_file.track_number"},
-	"discnumber":      {field: "media_file.disc_number"},
-	"year":            {field: "media_file.year"},
-	"date":            {field: "media_file.date", alias: "recordingdate"},
-	"originalyear":    {field: "media_file.original_year"},
-	"originaldate":    {field: "media_file.original_date"},
-	"releaseyear":     {field: "media_file.release_year"},
-	"releasedate":     {field: "media_file.release_date"},
-	"size":            {field: "media_file.size"},
-	"compilation":     {field: "media_file.compilation"},
-	"missing":         {field: "media_file.missing"},
-	"explicitstatus":  {field: "media_file.explicit_status"},
-	"dateadded":       {field: "media_file.created_at"},
-	"datemodified":    {field: "media_file.updated_at"},
-	"discsubtitle":    {field: "media_file.disc_subtitle"},
-	"comment":         {field: "media_file.comment"},
-	"lyrics":          {field: "media_file.lyrics"},
-	"sorttitle":       {field: "media_file.sort_title"},
-	"sortalbum":       {field: "media_file.sort_album_name"},
-	"sortartist":      {field: "media_file.sort_artist_name"},
-	"sortalbumartist": {field: "media_file.sort_album_artist_name"},
-	"albumcomment":    {field: "media_file.mbz_album_comment"},
-	"catalognumber":   {field: "media_file.catalog_num"},
-	"filepath":        {field: "media_file.path"},
-	"filetype":        {field: "media_file.suffix"},
-	"codec":           {field: "media_file.codec"},
-	"duration":        {field: "media_file.duration"},
-	"bitrate":         {field: "media_file.bit_rate"},
-	"bitdepth":        {field: "media_file.bit_depth"},
-	"samplerate":      {field: "media_file.sample_rate"},
-	"bpm":             {field: "media_file.bpm"},
-	"channels":        {field: "media_file.channels"},
-	"loved":           {field: "COALESCE(annotation.starred, false)"},
-	"dateloved":       {field: "annotation.starred_at"},
-	"lastplayed":      {field: "annotation.play_date"},
-	"daterated":       {field: "annotation.rated_at"},
-	"playcount":       {field: "COALESCE(annotation.play_count, 0)"},
-	"rating":          {field: "COALESCE(annotation.rating, 0)"},
-	"averagerating":   {field: "media_file.average_rating", numeric: true},
-	"albumrating":     {field: "COALESCE(album_annotation.rating, 0)", joinType: JoinAlbumAnnotation},
-	"albumloved":      {field: "COALESCE(album_annotation.starred, false)", joinType: JoinAlbumAnnotation},
-	"albumplaycount":  {field: "COALESCE(album_annotation.play_count, 0)", joinType: JoinAlbumAnnotation},
-	"albumlastplayed": {field: "album_annotation.play_date", joinType: JoinAlbumAnnotation},
-	"albumdateloved":  {field: "album_annotation.starred_at", joinType: JoinAlbumAnnotation},
-	"albumdaterated":  {field: "album_annotation.rated_at", joinType: JoinAlbumAnnotation},
-
-	"artistrating":     {field: "COALESCE(artist_annotation.rating, 0)", joinType: JoinArtistAnnotation},
-	"artistloved":      {field: "COALESCE(artist_annotation.starred, false)", joinType: JoinArtistAnnotation},
-	"artistplaycount":  {field: "COALESCE(artist_annotation.play_count, 0)", joinType: JoinArtistAnnotation},
-	"artistlastplayed": {field: "artist_annotation.play_date", joinType: JoinArtistAnnotation},
-	"artistdateloved":  {field: "artist_annotation.starred_at", joinType: JoinArtistAnnotation},
-	"artistdaterated":  {field: "artist_annotation.rated_at", joinType: JoinArtistAnnotation},
-
-	"mbz_album_id":         {field: "media_file.mbz_album_id"},
-	"mbz_album_artist_id":  {field: "media_file.mbz_album_artist_id"},
-	"mbz_artist_id":        {field: "media_file.mbz_artist_id"},
-	"mbz_recording_id":     {field: "media_file.mbz_recording_id"},
-	"mbz_release_track_id": {field: "media_file.mbz_release_track_id"},
-	"mbz_release_group_id": {field: "media_file.mbz_release_group_id"},
-	"library_id":           {field: "media_file.library_id", numeric: true},
-
-	// Backward compatibility: albumtype is an alias for releasetype tag
-	"albumtype": {field: "releasetype", isTag: true},
-
-	// special fields
-	"random": {field: "", order: "random()"}, // pseudo-field for random sorting
-	"value":  {field: "value"},               // pseudo-field for tag and roles values
+// FieldInfo describes a criteria field without tying it to persistence details.
+type FieldInfo struct {
+	Name    string
+	IsTag   bool
+	IsRole  bool
+	Numeric bool
 }
 
-type mappedField struct {
-	field    string
-	order    string
-	isRole   bool     // true if the field is a role (e.g. "artist", "composer", "conductor", etc.)
-	isTag    bool     // true if the field is a tag imported from the file metadata
-	alias    string   // name from `mappings.yml` that may differ from the name used in the smart playlist
-	numeric  bool     // true if the field/tag should be treated as numeric
-	joinType JoinType // which additional JOINs this field requires
+var fieldMap = map[string]*fieldMetadata{
+	"title":                {name: "title"},
+	"album":                {name: "album"},
+	"hascoverart":          {name: "hascoverart"},
+	"tracknumber":          {name: "tracknumber"},
+	"discnumber":           {name: "discnumber"},
+	"year":                 {name: "year"},
+	"date":                 {name: "date", alias: "recordingdate"},
+	"originalyear":         {name: "originalyear"},
+	"originaldate":         {name: "originaldate"},
+	"releaseyear":          {name: "releaseyear"},
+	"releasedate":          {name: "releasedate"},
+	"size":                 {name: "size"},
+	"compilation":          {name: "compilation"},
+	"missing":              {name: "missing"},
+	"explicitstatus":       {name: "explicitstatus"},
+	"dateadded":            {name: "dateadded"},
+	"datemodified":         {name: "datemodified"},
+	"discsubtitle":         {name: "discsubtitle"},
+	"comment":              {name: "comment"},
+	"lyrics":               {name: "lyrics"},
+	"sorttitle":            {name: "sorttitle"},
+	"sortalbum":            {name: "sortalbum"},
+	"sortartist":           {name: "sortartist"},
+	"sortalbumartist":      {name: "sortalbumartist"},
+	"albumcomment":         {name: "albumcomment"},
+	"catalognumber":        {name: "catalognumber"},
+	"filepath":             {name: "filepath"},
+	"filetype":             {name: "filetype"},
+	"codec":                {name: "codec"},
+	"duration":             {name: "duration"},
+	"bitrate":              {name: "bitrate"},
+	"bitdepth":             {name: "bitdepth"},
+	"samplerate":           {name: "samplerate"},
+	"bpm":                  {name: "bpm"},
+	"channels":             {name: "channels"},
+	"loved":                {name: "loved"},
+	"dateloved":            {name: "dateloved"},
+	"lastplayed":           {name: "lastplayed"},
+	"daterated":            {name: "daterated"},
+	"playcount":            {name: "playcount"},
+	"rating":               {name: "rating"},
+	"averagerating":        {name: "averagerating", numeric: true},
+	"albumrating":          {name: "albumrating"},
+	"albumloved":           {name: "albumloved"},
+	"albumplaycount":       {name: "albumplaycount"},
+	"albumlastplayed":      {name: "albumlastplayed"},
+	"albumdateloved":       {name: "albumdateloved"},
+	"albumdaterated":       {name: "albumdaterated"},
+	"artistrating":         {name: "artistrating"},
+	"artistloved":          {name: "artistloved"},
+	"artistplaycount":      {name: "artistplaycount"},
+	"artistlastplayed":     {name: "artistlastplayed"},
+	"artistdateloved":      {name: "artistdateloved"},
+	"artistdaterated":      {name: "artistdaterated"},
+	"mbz_album_id":         {name: "mbz_album_id"},
+	"mbz_album_artist_id":  {name: "mbz_album_artist_id"},
+	"mbz_artist_id":        {name: "mbz_artist_id"},
+	"mbz_recording_id":     {name: "mbz_recording_id"},
+	"mbz_release_track_id": {name: "mbz_release_track_id"},
+	"mbz_release_group_id": {name: "mbz_release_group_id"},
+	"library_id":           {name: "library_id", numeric: true},
+
+	// Backward compatibility: albumtype is an alias for the releasetype tag.
+	"albumtype": {name: "releasetype", isTag: true},
+
+	"random": {name: "random"},
+	"value":  {name: "value"},
 }
 
-func mapFields(expr map[string]any) map[string]any {
-	m := make(map[string]any)
-	for f, v := range expr {
-		if dbf := fieldMap[strings.ToLower(f)]; dbf != nil && dbf.field != "" {
-			m[dbf.field] = v
-		} else {
-			log.Error("Invalid field in criteria", "field", f)
-		}
+type fieldMetadata struct {
+	name    string
+	isRole  bool
+	isTag   bool
+	alias   string
+	numeric bool
+}
+
+// AllFieldNames returns the names of all registered criteria fields.
+func AllFieldNames() []string {
+	names := make([]string, 0, len(fieldMap))
+	for name := range fieldMap {
+		names = append(names, name)
 	}
-	return m
+	return names
 }
 
-// mapExpr maps a normal field expression to a specific type of expression (tag or role).
-// This is required because tags are handled differently than other fields,
-// as they are stored as a JSON column in the database.
-func mapExpr(expr squirrel.Sqlizer, negate bool, exprFunc func(string, squirrel.Sqlizer, bool) squirrel.Sqlizer) squirrel.Sqlizer {
-	rv := reflect.ValueOf(expr)
-	if rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String {
-		log.Fatal(fmt.Sprintf("expr is not a map-based operator: %T", expr))
+// LookupField returns semantic metadata for a criteria field name.
+func LookupField(name string) (FieldInfo, bool) {
+	f, ok := fieldMap[strings.ToLower(name)]
+	if !ok {
+		return FieldInfo{}, false
 	}
-
-	// Extract the field name and value, then build a new map keyed by "value"
-	// for the inner condition. The original map is left untouched so that
-	// ToSql can be called multiple times without corruption.
-	var k string
-	var v any
-	for _, key := range rv.MapKeys() {
-		k = key.String()
-		v = rv.MapIndex(key).Interface()
-		break // only one key is expected (and supported)
-	}
-
-	// Create a new map-based expression with "value" as the key, matching the
-	// column name inside json_tree subqueries.
-	newMap := reflect.MakeMap(rv.Type())
-	newMap.SetMapIndex(reflect.ValueOf("value"), reflect.ValueOf(v))
-	newExpr := newMap.Interface().(squirrel.Sqlizer)
-
-	return exprFunc(k, newExpr, negate)
-}
-
-// mapTagExpr maps a normal field expression to a tag expression.
-func mapTagExpr(expr squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
-	return mapExpr(expr, negate, tagExpr)
-}
-
-// mapRoleExpr maps a normal field expression to an artist role expression.
-func mapRoleExpr(expr squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
-	return mapExpr(expr, negate, roleExpr)
-}
-
-func isTagExpr(expr map[string]any) bool {
-	for f := range expr {
-		if f2, ok := fieldMap[strings.ToLower(f)]; ok && f2.isTag {
-			return true
-		}
-	}
-	return false
-}
-
-func isRoleExpr(expr map[string]any) bool {
-	for f := range expr {
-		if f2, ok := fieldMap[strings.ToLower(f)]; ok && f2.isRole {
-			return true
-		}
-	}
-	return false
-}
-
-func tagExpr(tag string, cond squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
-	return tagCond{tag: tag, cond: cond, not: negate}
-}
-
-type tagCond struct {
-	tag  string
-	cond squirrel.Sqlizer
-	not  bool
-}
-
-func (e tagCond) ToSql() (string, []any, error) {
-	cond, args, err := e.cond.ToSql()
-
-	// Resolve the actual tag name (handles aliases like albumtype -> releasetype)
-	tagName := e.tag
-	if fm, ok := fieldMap[e.tag]; ok {
-		if fm.field != "" {
-			tagName = fm.field
-		}
-		if fm.numeric {
-			cond = strings.ReplaceAll(cond, "value", "CAST(value AS REAL)")
-		}
-	}
-
-	cond = fmt.Sprintf("exists (select 1 from json_tree(media_file.tags, '$.%s') where key='value' and %s)",
-		tagName, cond)
-	if e.not {
-		cond = "not " + cond
-	}
-	return cond, args, err
-}
-
-func roleExpr(role string, cond squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
-	return roleCond{role: role, cond: cond, not: negate}
-}
-
-type roleCond struct {
-	role string
-	cond squirrel.Sqlizer
-	not  bool
-}
-
-func (e roleCond) ToSql() (string, []any, error) {
-	cond, args, err := e.cond.ToSql()
-	cond = fmt.Sprintf(`exists (select 1 from json_tree(media_file.participants, '$.%s') where key='name' and %s)`,
-		e.role, cond)
-	if e.not {
-		cond = "not " + cond
-	}
-	return cond, args, err
-}
-
-// fieldJoinType returns the JoinType for a given field name (case-insensitive).
-func fieldJoinType(name string) JoinType {
-	if f, ok := fieldMap[strings.ToLower(name)]; ok {
-		return f.joinType
-	}
-	return JoinNone
-}
-
-// extractJoinTypes walks an expression tree and collects all required JoinType flags.
-func extractJoinTypes(expr any) JoinType {
-	result := JoinNone
-	switch e := expr.(type) {
-	case All:
-		for _, sub := range e {
-			result |= extractJoinTypes(sub)
-		}
-	case Any:
-		for _, sub := range e {
-			result |= extractJoinTypes(sub)
-		}
-	default:
-		// Leaf expression: use reflection to check if it's a map with field names
-		rv := reflect.ValueOf(expr)
-		if rv.Kind() == reflect.Map && rv.Type().Key().Kind() == reflect.String {
-			for _, key := range rv.MapKeys() {
-				result |= fieldJoinType(key.String())
-			}
-		}
-	}
-	return result
+	return FieldInfo{
+		Name:    f.name,
+		IsTag:   f.isTag,
+		IsRole:  f.isRole,
+		Numeric: f.numeric,
+	}, true
 }
 
 // AddRoles adds roles to the field map. This is used to add all artist roles to the field map, so they can be used in
-// smart playlists. If a role already exists in the field map, it is ignored, so calls to this function are idempotent.
+// smart playlists.
 func AddRoles(roles []string) {
 	for _, role := range roles {
 		name := strings.ToLower(role)
 		if _, ok := fieldMap[name]; ok {
 			continue
 		}
-		fieldMap[name] = &mappedField{field: name, isRole: true}
+		fieldMap[name] = &fieldMetadata{name: name, isRole: true}
 	}
 }
 
 // AddTagNames adds tag names to the field map. This is used to add all tags mapped in the `mappings.yml`
-// file to the field map, so they can be used in smart playlists.
-// If a tag name already exists in the field map, it is ignored, so calls to this function are idempotent.
+// configuration file.
 func AddTagNames(tagNames []string) {
-	for _, name := range tagNames {
-		name := strings.ToLower(name)
+	for _, tagName := range tagNames {
+		name := strings.ToLower(tagName)
 		if _, ok := fieldMap[name]; ok {
 			continue
 		}
@@ -285,20 +138,19 @@ func AddTagNames(tagNames []string) {
 			}
 		}
 		if _, ok := fieldMap[name]; !ok {
-			fieldMap[name] = &mappedField{field: name, isTag: true}
+			fieldMap[name] = &fieldMetadata{name: name, isTag: true}
 		}
 	}
 }
 
-// AddNumericTags marks the given tag names as numeric so they can be cast
-// when used in comparisons or sorting.
+// AddNumericTags adds tags that should be treated as numbers.
 func AddNumericTags(tagNames []string) {
-	for _, name := range tagNames {
-		name := strings.ToLower(name)
+	for _, tagName := range tagNames {
+		name := strings.ToLower(tagName)
 		if fm, ok := fieldMap[name]; ok {
 			fm.numeric = true
 		} else {
-			fieldMap[name] = &mappedField{field: name, isTag: true, numeric: true}
+			fieldMap[name] = &fieldMetadata{name: name, isTag: true, numeric: true}
 		}
 	}
 }
diff --git a/model/criteria/fields_test.go b/model/criteria/fields_test.go
index accdebd3d..ecbeb5857 100644
--- a/model/criteria/fields_test.go
+++ b/model/criteria/fields_test.go
@@ -6,11 +6,58 @@ import (
 )
 
 var _ = Describe("fields", func() {
-	Describe("mapFields", func() {
-		It("ignores random fields", func() {
-			m := map[string]any{"random": "123"}
-			m = mapFields(m)
-			gomega.Expect(m).To(gomega.BeEmpty())
+	Describe("LookupField", func() {
+		It("finds built-in fields case-insensitively", func() {
+			field, ok := LookupField("Title")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field).To(gomega.Equal(FieldInfo{Name: "title"}))
+		})
+
+		It("resolves aliases to their semantic field name", func() {
+			field, ok := LookupField("albumtype")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field.Name).To(gomega.Equal("releasetype"))
+			gomega.Expect(field.IsTag).To(gomega.BeTrue())
+		})
+
+		It("finds special fields", func() {
+			field, ok := LookupField("value")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field.Name).To(gomega.Equal("value"))
+		})
+
+		It("finds registered tag names", func() {
+			AddTagNames([]string{"task3_mood"})
+
+			field, ok := LookupField("task3_mood")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field.Name).To(gomega.Equal("task3_mood"))
+			gomega.Expect(field.IsTag).To(gomega.BeTrue())
+		})
+
+		It("marks registered numeric tags", func() {
+			AddTagNames([]string{"task3_score"})
+			AddNumericTags([]string{"task3_score"})
+
+			field, ok := LookupField("task3_score")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field.IsTag).To(gomega.BeTrue())
+			gomega.Expect(field.Numeric).To(gomega.BeTrue())
+		})
+
+		It("finds registered roles", func() {
+			AddRoles([]string{"task3_producer"})
+
+			field, ok := LookupField("task3_producer")
+
+			gomega.Expect(ok).To(gomega.BeTrue())
+			gomega.Expect(field.Name).To(gomega.Equal("task3_producer"))
+			gomega.Expect(field.IsRole).To(gomega.BeTrue())
 		})
 	})
 })
diff --git a/model/criteria/operators.go b/model/criteria/operators.go
index 336f914de..6f911b12f 100644
--- a/model/criteria/operators.go
+++ b/model/criteria/operators.go
@@ -1,23 +1,13 @@
 package criteria
 
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"time"
-
-	"github.com/Masterminds/squirrel"
-)
+import "time"
 
 type (
-	All squirrel.And
+	All []Expression
 	And = All
 )
 
-func (all All) ToSql() (sql string, args []any, err error) {
-	return squirrel.And(all).ToSql()
-}
+func (All) criteriaExpression() {}
 
 func (all All) MarshalJSON() ([]byte, error) {
 	return marshalConjunction("all", all)
@@ -28,13 +18,11 @@ func (all All) ChildPlaylistIds() (ids []string) {
 }
 
 type (
-	Any squirrel.Or
+	Any []Expression
 	Or  = Any
 )
 
-func (any Any) ToSql() (sql string, args []any, err error) {
-	return squirrel.Or(any).ToSql()
-}
+func (Any) criteriaExpression() {}
 
 func (any Any) MarshalJSON() ([]byte, error) {
 	return marshalConjunction("any", any)
@@ -44,70 +32,42 @@ func (any Any) ChildPlaylistIds() (ids []string) {
 	return extractPlaylistIds(any)
 }
 
-type Is squirrel.Eq
+type Is map[string]any
 type Eq = Is
 
-func (is Is) ToSql() (sql string, args []any, err error) {
-	if isRoleExpr(is) {
-		return mapRoleExpr(is, false).ToSql()
-	}
-	if isTagExpr(is) {
-		return mapTagExpr(is, false).ToSql()
-	}
-	return squirrel.Eq(mapFields(is)).ToSql()
-}
+func (Is) criteriaExpression() {}
 
 func (is Is) MarshalJSON() ([]byte, error) {
 	return marshalExpression("is", is)
 }
 
-type IsNot squirrel.NotEq
+type IsNot map[string]any
 
-func (in IsNot) ToSql() (sql string, args []any, err error) {
-	if isRoleExpr(in) {
-		return mapRoleExpr(squirrel.Eq(in), true).ToSql()
-	}
-	if isTagExpr(in) {
-		return mapTagExpr(squirrel.Eq(in), true).ToSql()
-	}
-	return squirrel.NotEq(mapFields(in)).ToSql()
-}
+func (IsNot) criteriaExpression() {}
 
 func (in IsNot) MarshalJSON() ([]byte, error) {
 	return marshalExpression("isNot", in)
 }
 
-type Gt squirrel.Gt
+type Gt map[string]any
 
-func (gt Gt) ToSql() (sql string, args []any, err error) {
-	if isTagExpr(gt) {
-		return mapTagExpr(gt, false).ToSql()
-	}
-	return squirrel.Gt(mapFields(gt)).ToSql()
-}
+func (Gt) criteriaExpression() {}
 
 func (gt Gt) MarshalJSON() ([]byte, error) {
 	return marshalExpression("gt", gt)
 }
 
-type Lt squirrel.Lt
+type Lt map[string]any
 
-func (lt Lt) ToSql() (sql string, args []any, err error) {
-	if isTagExpr(lt) {
-		return mapTagExpr(squirrel.Lt(lt), false).ToSql()
-	}
-	return squirrel.Lt(mapFields(lt)).ToSql()
-}
+func (Lt) criteriaExpression() {}
 
 func (lt Lt) MarshalJSON() ([]byte, error) {
 	return marshalExpression("lt", lt)
 }
 
-type Before squirrel.Lt
+type Before map[string]any
 
-func (bf Before) ToSql() (sql string, args []any, err error) {
-	return Lt(bf).ToSql()
-}
+func (Before) criteriaExpression() {}
 
 func (bf Before) MarshalJSON() ([]byte, error) {
 	return marshalExpression("before", bf)
@@ -115,9 +75,7 @@ func (bf Before) MarshalJSON() ([]byte, error) {
 
 type After Gt
 
-func (af After) ToSql() (sql string, args []any, err error) {
-	return Gt(af).ToSql()
-}
+func (After) criteriaExpression() {}
 
 func (af After) MarshalJSON() ([]byte, error) {
 	return marshalExpression("after", af)
@@ -125,19 +83,7 @@ func (af After) MarshalJSON() ([]byte, error) {
 
 type Contains map[string]any
 
-func (ct Contains) ToSql() (sql string, args []any, err error) {
-	lk := squirrel.Like{}
-	for f, v := range mapFields(ct) {
-		lk[f] = fmt.Sprintf("%%%s%%", v)
-	}
-	if isRoleExpr(ct) {
-		return mapRoleExpr(lk, false).ToSql()
-	}
-	if isTagExpr(ct) {
-		return mapTagExpr(lk, false).ToSql()
-	}
-	return lk.ToSql()
-}
+func (Contains) criteriaExpression() {}
 
 func (ct Contains) MarshalJSON() ([]byte, error) {
 	return marshalExpression("contains", ct)
@@ -145,19 +91,7 @@ func (ct Contains) MarshalJSON() ([]byte, error) {
 
 type NotContains map[string]any
 
-func (nct NotContains) ToSql() (sql string, args []any, err error) {
-	lk := squirrel.NotLike{}
-	for f, v := range mapFields(nct) {
-		lk[f] = fmt.Sprintf("%%%s%%", v)
-	}
-	if isRoleExpr(nct) {
-		return mapRoleExpr(squirrel.Like(lk), true).ToSql()
-	}
-	if isTagExpr(nct) {
-		return mapTagExpr(squirrel.Like(lk), true).ToSql()
-	}
-	return lk.ToSql()
-}
+func (NotContains) criteriaExpression() {}
 
 func (nct NotContains) MarshalJSON() ([]byte, error) {
 	return marshalExpression("notContains", nct)
@@ -165,19 +99,7 @@ func (nct NotContains) MarshalJSON() ([]byte, error) {
 
 type StartsWith map[string]any
 
-func (sw StartsWith) ToSql() (sql string, args []any, err error) {
-	lk := squirrel.Like{}
-	for f, v := range mapFields(sw) {
-		lk[f] = fmt.Sprintf("%s%%", v)
-	}
-	if isRoleExpr(sw) {
-		return mapRoleExpr(lk, false).ToSql()
-	}
-	if isTagExpr(sw) {
-		return mapTagExpr(lk, false).ToSql()
-	}
-	return lk.ToSql()
-}
+func (StartsWith) criteriaExpression() {}
 
 func (sw StartsWith) MarshalJSON() ([]byte, error) {
 	return marshalExpression("startsWith", sw)
@@ -185,19 +107,7 @@ func (sw StartsWith) MarshalJSON() ([]byte, error) {
 
 type EndsWith map[string]any
 
-func (sw EndsWith) ToSql() (sql string, args []any, err error) {
-	lk := squirrel.Like{}
-	for f, v := range mapFields(sw) {
-		lk[f] = fmt.Sprintf("%%%s", v)
-	}
-	if isRoleExpr(sw) {
-		return mapRoleExpr(lk, false).ToSql()
-	}
-	if isTagExpr(sw) {
-		return mapTagExpr(lk, false).ToSql()
-	}
-	return lk.ToSql()
-}
+func (EndsWith) criteriaExpression() {}
 
 func (sw EndsWith) MarshalJSON() ([]byte, error) {
 	return marshalExpression("endsWith", sw)
@@ -205,20 +115,7 @@ func (sw EndsWith) MarshalJSON() ([]byte, error) {
 
 type InTheRange map[string]any
 
-func (itr InTheRange) ToSql() (sql string, args []any, err error) {
-	and := squirrel.And{}
-	for f, v := range mapFields(itr) {
-		s := reflect.ValueOf(v)
-		if s.Kind() != reflect.Slice || s.Len() != 2 {
-			return "", nil, fmt.Errorf("invalid range for 'in' operator: %s", v)
-		}
-		and = append(and,
-			squirrel.GtOrEq{f: s.Index(0).Interface()},
-			squirrel.LtOrEq{f: s.Index(1).Interface()},
-		)
-	}
-	return and.ToSql()
-}
+func (InTheRange) criteriaExpression() {}
 
 func (itr InTheRange) MarshalJSON() ([]byte, error) {
 	return marshalExpression("inTheRange", itr)
@@ -226,13 +123,7 @@ func (itr InTheRange) MarshalJSON() ([]byte, error) {
 
 type InTheLast map[string]any
 
-func (itl InTheLast) ToSql() (sql string, args []any, err error) {
-	exp, err := inPeriod(itl, false)
-	if err != nil {
-		return "", nil, err
-	}
-	return exp.ToSql()
-}
+func (InTheLast) criteriaExpression() {}
 
 func (itl InTheLast) MarshalJSON() ([]byte, error) {
 	return marshalExpression("inTheLast", itl)
@@ -240,50 +131,19 @@ func (itl InTheLast) MarshalJSON() ([]byte, error) {
 
 type NotInTheLast map[string]any
 
-func (nitl NotInTheLast) ToSql() (sql string, args []any, err error) {
-	exp, err := inPeriod(nitl, true)
-	if err != nil {
-		return "", nil, err
-	}
-	return exp.ToSql()
-}
+func (NotInTheLast) criteriaExpression() {}
 
 func (nitl NotInTheLast) MarshalJSON() ([]byte, error) {
 	return marshalExpression("notInTheLast", nitl)
 }
 
-func inPeriod(m map[string]any, negate bool) (Expression, error) {
-	var field string
-	var value any
-	for f, v := range mapFields(m) {
-		field, value = f, v
-		break
-	}
-	str := fmt.Sprintf("%v", value)
-	v, err := strconv.ParseInt(str, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	firstDate := startOfPeriod(v, time.Now())
-
-	if negate {
-		return Or{
-			squirrel.Lt{field: firstDate},
-			squirrel.Eq{field: nil},
-		}, nil
-	}
-	return squirrel.Gt{field: firstDate}, nil
-}
-
 func startOfPeriod(numDays int64, from time.Time) string {
 	return from.Add(time.Duration(-24*numDays) * time.Hour).Format("2006-01-02")
 }
 
 type InPlaylist map[string]any
 
-func (ipl InPlaylist) ToSql() (sql string, args []any, err error) {
-	return inList(ipl, false)
-}
+func (InPlaylist) criteriaExpression() {}
 
 func (ipl InPlaylist) MarshalJSON() ([]byte, error) {
 	return marshalExpression("inPlaylist", ipl)
@@ -291,41 +151,12 @@ func (ipl InPlaylist) MarshalJSON() ([]byte, error) {
 
 type NotInPlaylist map[string]any
 
-func (ipl NotInPlaylist) ToSql() (sql string, args []any, err error) {
-	return inList(ipl, true)
-}
+func (NotInPlaylist) criteriaExpression() {}
 
 func (ipl NotInPlaylist) MarshalJSON() ([]byte, error) {
 	return marshalExpression("notInPlaylist", ipl)
 }
 
-func inList(m map[string]any, negate bool) (sql string, args []any, err error) {
-	var playlistid string
-	var ok bool
-	if playlistid, ok = m["id"].(string); !ok {
-		return "", nil, errors.New("playlist id not given")
-	}
-
-	// Subquery to fetch all media files that are contained in given playlist
-	// Only evaluate playlist if it is public
-	subQuery := squirrel.Select("media_file_id").
-		From("playlist_tracks pl").
-		LeftJoin("playlist on pl.playlist_id = playlist.id").
-		Where(squirrel.And{
-			squirrel.Eq{"pl.playlist_id": playlistid},
-			squirrel.Eq{"playlist.public": 1}})
-	subQText, subQArgs, err := subQuery.PlaceholderFormat(squirrel.Question).ToSql()
-
-	if err != nil {
-		return "", nil, err
-	}
-	if negate {
-		return "media_file.id NOT IN (" + subQText + ")", subQArgs, nil
-	} else {
-		return "media_file.id IN (" + subQText + ")", subQArgs, nil
-	}
-}
-
 func extractPlaylistIds(inputRule any) (ids []string) {
 	var id string
 	var ok bool
diff --git a/model/criteria/operators_test.go b/model/criteria/operators_test.go
index 5f756f97d..c93e8f2b2 100644
--- a/model/criteria/operators_test.go
+++ b/model/criteria/operators_test.go
@@ -3,7 +3,6 @@ package criteria_test
 import (
 	"encoding/json"
 	"fmt"
-	"time"
 
 	. "github.com/navidrome/navidrome/model/criteria"
 	. "github.com/onsi/ginkgo/v2"
@@ -17,182 +16,6 @@ var _ = BeforeSuite(func() {
 })
 
 var _ = Describe("Operators", func() {
-	rangeStart := time.Date(2021, 10, 01, 0, 0, 0, 0, time.Local)
-	rangeEnd := time.Date(2021, 11, 01, 0, 0, 0, 0, time.Local)
-
-	DescribeTable("ToSQL",
-		func(op Expression, expectedSql string, expectedArgs ...any) {
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal(expectedSql))
-			gomega.Expect(args).To(gomega.HaveExactElements(expectedArgs...))
-		},
-		Entry("is [string]", Is{"title": "Low Rider"}, "media_file.title = ?", "Low Rider"),
-		Entry("is [bool]", Is{"loved": true}, "COALESCE(annotation.starred, false) = ?", true),
-		Entry("is [numeric]", Is{"library_id": 1}, "media_file.library_id = ?", 1),
-		Entry("is [numeric list]", Is{"library_id": []int{1, 2}}, "media_file.library_id IN (?,?)", 1, 2),
-		Entry("isNot", IsNot{"title": "Low Rider"}, "media_file.title <> ?", "Low Rider"),
-		Entry("isNot [numeric]", IsNot{"library_id": 1}, "media_file.library_id <> ?", 1),
-		Entry("isNot [numeric list]", IsNot{"library_id": []int{1, 2}}, "media_file.library_id NOT IN (?,?)", 1, 2),
-		Entry("gt", Gt{"playCount": 10}, "COALESCE(annotation.play_count, 0) > ?", 10),
-		Entry("lt", Lt{"playCount": 10}, "COALESCE(annotation.play_count, 0) < ?", 10),
-		Entry("contains", Contains{"title": "Low Rider"}, "media_file.title LIKE ?", "%Low Rider%"),
-		Entry("notContains", NotContains{"title": "Low Rider"}, "media_file.title NOT LIKE ?", "%Low Rider%"),
-		Entry("startsWith", StartsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "Low Rider%"),
-		Entry("endsWith", EndsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "%Low Rider"),
-		Entry("inTheRange [number]", InTheRange{"year": []int{1980, 1990}}, "(media_file.year >= ? AND media_file.year <= ?)", 1980, 1990),
-		Entry("inTheRange [date]", InTheRange{"lastPlayed": []time.Time{rangeStart, rangeEnd}}, "(annotation.play_date >= ? AND annotation.play_date <= ?)", rangeStart, rangeEnd),
-		Entry("before", Before{"lastPlayed": rangeStart}, "annotation.play_date < ?", rangeStart),
-		Entry("after", After{"lastPlayed": rangeStart}, "annotation.play_date > ?", rangeStart),
-
-		// InPlaylist and NotInPlaylist are special cases
-		Entry("inPlaylist", InPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id IN "+
-			"(SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
-		Entry("notInPlaylist", NotInPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id NOT IN "+
-			"(SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
-
-		Entry("inTheLast", InTheLast{"lastPlayed": 30}, "annotation.play_date > ?", StartOfPeriod(30, time.Now())),
-		Entry("notInTheLast", NotInTheLast{"lastPlayed": 30}, "(annotation.play_date < ? OR annotation.play_date IS NULL)", StartOfPeriod(30, time.Now())),
-
-		// Album annotation fields
-		Entry("albumRating", Gt{"albumRating": 3}, "COALESCE(album_annotation.rating, 0) > ?", 3),
-		Entry("albumLoved", Is{"albumLoved": true}, "COALESCE(album_annotation.starred, false) = ?", true),
-		Entry("albumPlayCount", Gt{"albumPlayCount": 5}, "COALESCE(album_annotation.play_count, 0) > ?", 5),
-		Entry("albumLastPlayed", After{"albumLastPlayed": rangeStart}, "album_annotation.play_date > ?", rangeStart),
-		Entry("albumDateLoved", Before{"albumDateLoved": rangeStart}, "album_annotation.starred_at < ?", rangeStart),
-		Entry("albumDateRated", After{"albumDateRated": rangeStart}, "album_annotation.rated_at > ?", rangeStart),
-		Entry("albumLastPlayed inTheLast", InTheLast{"albumLastPlayed": 30}, "album_annotation.play_date > ?", StartOfPeriod(30, time.Now())),
-		Entry("albumLastPlayed notInTheLast", NotInTheLast{"albumLastPlayed": 30}, "(album_annotation.play_date < ? OR album_annotation.play_date IS NULL)", StartOfPeriod(30, time.Now())),
-
-		// Artist annotation fields
-		Entry("artistRating", Gt{"artistRating": 3}, "COALESCE(artist_annotation.rating, 0) > ?", 3),
-		Entry("artistLoved", Is{"artistLoved": true}, "COALESCE(artist_annotation.starred, false) = ?", true),
-		Entry("artistPlayCount", Gt{"artistPlayCount": 5}, "COALESCE(artist_annotation.play_count, 0) > ?", 5),
-		Entry("artistLastPlayed", After{"artistLastPlayed": rangeStart}, "artist_annotation.play_date > ?", rangeStart),
-		Entry("artistDateLoved", Before{"artistDateLoved": rangeStart}, "artist_annotation.starred_at < ?", rangeStart),
-		Entry("artistDateRated", After{"artistDateRated": rangeStart}, "artist_annotation.rated_at > ?", rangeStart),
-		Entry("artistLastPlayed inTheLast", InTheLast{"artistLastPlayed": 30}, "artist_annotation.play_date > ?", StartOfPeriod(30, time.Now())),
-		Entry("artistLastPlayed notInTheLast", NotInTheLast{"artistLastPlayed": 30}, "(artist_annotation.play_date < ? OR artist_annotation.play_date IS NULL)", StartOfPeriod(30, time.Now())),
-
-		// Tag tests
-		Entry("tag is [string]", Is{"genre": "Rock"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value = ?)", "Rock"),
-		Entry("tag isNot [string]", IsNot{"genre": "Rock"}, "not exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value = ?)", "Rock"),
-		Entry("tag gt", Gt{"genre": "A"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value > ?)", "A"),
-		Entry("tag lt", Lt{"genre": "Z"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value < ?)", "Z"),
-		Entry("tag contains", Contains{"genre": "Rock"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
-		Entry("tag not contains", NotContains{"genre": "Rock"}, "not exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
-		Entry("tag startsWith", StartsWith{"genre": "Soft"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "Soft%"),
-		Entry("tag endsWith", EndsWith{"genre": "Rock"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "%Rock"),
-
-		// Artist roles tests
-		Entry("role is [string]", Is{"artist": "u2"}, "exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value = ?)", "u2"),
-		Entry("role isNot [string]", IsNot{"artist": "u2"}, "not exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value = ?)", "u2"),
-		Entry("role contains [string]", Contains{"artist": "u2"}, "exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value LIKE ?)", "%u2%"),
-		Entry("role not contains [string]", NotContains{"artist": "u2"}, "not exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value LIKE ?)", "%u2%"),
-		Entry("role startsWith [string]", StartsWith{"composer": "John"}, "exists (select 1 from json_tree(media_file.participants, '$.composer') where key='name' and value LIKE ?)", "John%"),
-		Entry("role endsWith [string]", EndsWith{"composer": "Lennon"}, "exists (select 1 from json_tree(media_file.participants, '$.composer') where key='name' and value LIKE ?)", "%Lennon"),
-	)
-
-	// TODO Validate operators that are not valid for each field type.
-	XDescribeTable("ToSQL - Invalid Operators",
-		func(op Expression, expectedError string) {
-			_, _, err := op.ToSql()
-			gomega.Expect(err).To(gomega.MatchError(expectedError))
-		},
-		Entry("numeric tag contains", Contains{"rate": 5}, "numeric tag 'rate' cannot be used with Contains operator"),
-	)
-
-	Describe("Custom Tags", func() {
-		It("generates valid SQL", func() {
-			AddTagNames([]string{"mood"})
-			op := EndsWith{"mood": "Soft"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.tags, '$.mood') where key='value' and value LIKE ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("%Soft"))
-		})
-		It("casts numeric comparisons", func() {
-			AddNumericTags([]string{"rate"})
-			op := Lt{"rate": 6}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.tags, '$.rate') where key='value' and CAST(value AS REAL) < ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements(6))
-		})
-		It("skips unknown tag names", func() {
-			op := EndsWith{"unknown": "value"}
-			sql, args, _ := op.ToSql()
-			gomega.Expect(sql).To(gomega.BeEmpty())
-			gomega.Expect(args).To(gomega.BeEmpty())
-		})
-		It("supports releasetype as multi-valued tag", func() {
-			AddTagNames([]string{"releasetype"})
-			op := Contains{"releasetype": "soundtrack"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.tags, '$.releasetype') where key='value' and value LIKE ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("%soundtrack%"))
-		})
-		It("supports albumtype as alias for releasetype", func() {
-			AddTagNames([]string{"releasetype"})
-			op := Contains{"albumtype": "live"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.tags, '$.releasetype') where key='value' and value LIKE ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("%live%"))
-		})
-		It("supports albumtype alias with Is operator", func() {
-			AddTagNames([]string{"releasetype"})
-			op := Is{"albumtype": "album"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			// Should query $.releasetype, not $.albumtype
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.tags, '$.releasetype') where key='value' and value = ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("album"))
-		})
-		It("supports albumtype alias with IsNot operator", func() {
-			AddTagNames([]string{"releasetype"})
-			op := IsNot{"albumtype": "compilation"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			// Should query $.releasetype, not $.albumtype
-			gomega.Expect(sql).To(gomega.Equal("not exists (select 1 from json_tree(media_file.tags, '$.releasetype') where key='value' and value = ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("compilation"))
-		})
-	})
-
-	Describe("Custom Roles", func() {
-		It("generates valid SQL", func() {
-			AddRoles([]string{"producer"})
-			op := EndsWith{"producer": "Eno"}
-			sql, args, err := op.ToSql()
-			gomega.Expect(err).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(media_file.participants, '$.producer') where key='name' and value LIKE ?)"))
-			gomega.Expect(args).To(gomega.HaveExactElements("%Eno"))
-		})
-		It("skips unknown roles", func() {
-			op := Contains{"groupie": "Penny Lane"}
-			sql, args, _ := op.ToSql()
-			gomega.Expect(sql).To(gomega.BeEmpty())
-			gomega.Expect(args).To(gomega.BeEmpty())
-		})
-	})
-
-	DescribeTable("ToSql idempotency",
-		func(expr Expression) {
-			sql1, args1, err1 := expr.ToSql()
-			sql2, args2, err2 := expr.ToSql()
-
-			gomega.Expect(err1).ToNot(gomega.HaveOccurred())
-			gomega.Expect(err2).ToNot(gomega.HaveOccurred())
-			gomega.Expect(sql2).To(gomega.Equal(sql1))
-			gomega.Expect(args2).To(gomega.Equal(args1))
-		},
-		Entry("tag expression", Is{"genre": "Rock"}),
-		Entry("role expression", Contains{"artist": "Beatles"}),
-		Entry("nested criteria", Criteria{Expression: All{Is{"genre": "Rock"}, Contains{"artist": "Beatles"}}}),
-	)
-
 	DescribeTable("JSON Marshaling",
 		func(op Expression, jsonString string) {
 			obj := And{op}
diff --git a/model/criteria/walk.go b/model/criteria/walk.go
new file mode 100644
index 000000000..62aaf97f8
--- /dev/null
+++ b/model/criteria/walk.go
@@ -0,0 +1,72 @@
+package criteria
+
+import "fmt"
+
+type Visitor func(Expression) error
+
+func Walk(expr Expression, visit Visitor) error {
+	if expr == nil {
+		return nil
+	}
+	if err := visit(expr); err != nil {
+		return err
+	}
+	switch e := expr.(type) {
+	case All:
+		for _, child := range e {
+			if err := Walk(child, visit); err != nil {
+				return err
+			}
+		}
+	case Any:
+		for _, child := range e {
+			if err := Walk(child, visit); err != nil {
+				return err
+			}
+		}
+	case Is, IsNot, Gt, Lt, Before, After, Contains, NotContains, StartsWith, EndsWith, InTheRange, InTheLast, NotInTheLast, InPlaylist, NotInPlaylist:
+		return nil
+	default:
+		return fmt.Errorf("unknown criteria expression type %T", expr)
+	}
+	return nil
+}
+
+// Fields returns field values for leaf expressions only.
+// Use Walk to traverse All and Any expressions before calling Fields.
+func Fields(expr Expression) map[string]any {
+	switch e := expr.(type) {
+	case Is:
+		return map[string]any(e)
+	case IsNot:
+		return map[string]any(e)
+	case Gt:
+		return map[string]any(e)
+	case Lt:
+		return map[string]any(e)
+	case Before:
+		return map[string]any(e)
+	case After:
+		return map[string]any(Gt(e))
+	case Contains:
+		return map[string]any(e)
+	case NotContains:
+		return map[string]any(e)
+	case StartsWith:
+		return map[string]any(e)
+	case EndsWith:
+		return map[string]any(e)
+	case InTheRange:
+		return map[string]any(e)
+	case InTheLast:
+		return map[string]any(e)
+	case NotInTheLast:
+		return map[string]any(e)
+	case InPlaylist:
+		return map[string]any(e)
+	case NotInPlaylist:
+		return map[string]any(e)
+	default:
+		return nil
+	}
+}
diff --git a/model/criteria/walk_test.go b/model/criteria/walk_test.go
new file mode 100644
index 000000000..91438f095
--- /dev/null
+++ b/model/criteria/walk_test.go
@@ -0,0 +1,64 @@
+package criteria
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo/v2"
+	"github.com/onsi/gomega"
+)
+
+type unknownExpression struct{}
+
+func (unknownExpression) criteriaExpression() {}
+
+var _ = Describe("Walk", func() {
+	It("visits the expression tree depth-first", func() {
+		expr := All{
+			Contains{"title": "love"},
+			Any{
+				Is{"album": "best of"},
+				Gt{"rating": 3},
+			},
+		}
+
+		var visited []string
+		err := Walk(expr, func(expr Expression) error {
+			visited = append(visited, fmt.Sprintf("%T", expr))
+			return nil
+		})
+
+		gomega.Expect(err).ToNot(gomega.HaveOccurred())
+		gomega.Expect(visited).To(gomega.Equal([]string{
+			"criteria.All",
+			"criteria.Contains",
+			"criteria.Any",
+			"criteria.Is",
+			"criteria.Gt",
+		}))
+	})
+
+	It("stops when the visitor returns an error", func() {
+		expectedErr := fmt.Errorf("stop")
+
+		err := Walk(All{Contains{"title": "love"}}, func(Expression) error {
+			return expectedErr
+		})
+
+		gomega.Expect(err).To(gomega.MatchError(expectedErr))
+	})
+
+	It("returns fields for leaf expressions", func() {
+		gomega.Expect(Fields(Contains{"title": "love"})).To(gomega.Equal(map[string]any{"title": "love"}))
+		gomega.Expect(Fields(After{"date": "2020-01-01"})).To(gomega.Equal(map[string]any{"date": "2020-01-01"}))
+	})
+
+	It("returns nil fields for group expressions", func() {
+		gomega.Expect(Fields(All{Contains{"title": "love"}})).To(gomega.BeNil())
+	})
+
+	It("returns an error for unknown expression types", func() {
+		err := Walk(unknownExpression{}, func(Expression) error { return nil })
+
+		gomega.Expect(err).To(gomega.MatchError("unknown criteria expression type criteria.unknownExpression"))
+	})
+})
diff --git a/persistence/criteria_sql.go b/persistence/criteria_sql.go
new file mode 100644
index 000000000..2f7b73885
--- /dev/null
+++ b/persistence/criteria_sql.go
@@ -0,0 +1,487 @@
+package persistence
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	squirrel "github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model/criteria"
+)
+
+type smartPlaylistJoinType int
+
+const (
+	smartPlaylistJoinNone            smartPlaylistJoinType = 0
+	smartPlaylistJoinAlbumAnnotation smartPlaylistJoinType = 1 << iota
+	smartPlaylistJoinArtistAnnotation
+)
+
+func (j smartPlaylistJoinType) has(other smartPlaylistJoinType) bool {
+	return j&other != 0
+}
+
+type smartPlaylistField struct {
+	expr     string
+	order    string
+	joinType smartPlaylistJoinType
+}
+
+type smartPlaylistCriteria struct {
+	criteria criteria.Criteria
+}
+
+func newSmartPlaylistCriteria(c criteria.Criteria) smartPlaylistCriteria {
+	return smartPlaylistCriteria{criteria: c}
+}
+
+var smartPlaylistFields = map[string]smartPlaylistField{
+	"title":                {expr: "media_file.title"},
+	"album":                {expr: "media_file.album"},
+	"hascoverart":          {expr: "media_file.has_cover_art"},
+	"tracknumber":          {expr: "media_file.track_number"},
+	"discnumber":           {expr: "media_file.disc_number"},
+	"year":                 {expr: "media_file.year"},
+	"date":                 {expr: "media_file.date"},
+	"originalyear":         {expr: "media_file.original_year"},
+	"originaldate":         {expr: "media_file.original_date"},
+	"releaseyear":          {expr: "media_file.release_year"},
+	"releasedate":          {expr: "media_file.release_date"},
+	"size":                 {expr: "media_file.size"},
+	"compilation":          {expr: "media_file.compilation"},
+	"missing":              {expr: "media_file.missing"},
+	"explicitstatus":       {expr: "media_file.explicit_status"},
+	"dateadded":            {expr: "media_file.created_at"},
+	"datemodified":         {expr: "media_file.updated_at"},
+	"discsubtitle":         {expr: "media_file.disc_subtitle"},
+	"comment":              {expr: "media_file.comment"},
+	"lyrics":               {expr: "media_file.lyrics"},
+	"sorttitle":            {expr: "media_file.sort_title"},
+	"sortalbum":            {expr: "media_file.sort_album_name"},
+	"sortartist":           {expr: "media_file.sort_artist_name"},
+	"sortalbumartist":      {expr: "media_file.sort_album_artist_name"},
+	"albumcomment":         {expr: "media_file.mbz_album_comment"},
+	"catalognumber":        {expr: "media_file.catalog_num"},
+	"filepath":             {expr: "media_file.path"},
+	"filetype":             {expr: "media_file.suffix"},
+	"codec":                {expr: "media_file.codec"},
+	"duration":             {expr: "media_file.duration"},
+	"bitrate":              {expr: "media_file.bit_rate"},
+	"bitdepth":             {expr: "media_file.bit_depth"},
+	"samplerate":           {expr: "media_file.sample_rate"},
+	"bpm":                  {expr: "media_file.bpm"},
+	"channels":             {expr: "media_file.channels"},
+	"loved":                {expr: "COALESCE(annotation.starred, false)"},
+	"dateloved":            {expr: "annotation.starred_at"},
+	"lastplayed":           {expr: "annotation.play_date"},
+	"daterated":            {expr: "annotation.rated_at"},
+	"playcount":            {expr: "COALESCE(annotation.play_count, 0)"},
+	"rating":               {expr: "COALESCE(annotation.rating, 0)"},
+	"averagerating":        {expr: "media_file.average_rating"},
+	"albumrating":          {expr: "COALESCE(album_annotation.rating, 0)", joinType: smartPlaylistJoinAlbumAnnotation},
+	"albumloved":           {expr: "COALESCE(album_annotation.starred, false)", joinType: smartPlaylistJoinAlbumAnnotation},
+	"albumplaycount":       {expr: "COALESCE(album_annotation.play_count, 0)", joinType: smartPlaylistJoinAlbumAnnotation},
+	"albumlastplayed":      {expr: "album_annotation.play_date", joinType: smartPlaylistJoinAlbumAnnotation},
+	"albumdateloved":       {expr: "album_annotation.starred_at", joinType: smartPlaylistJoinAlbumAnnotation},
+	"albumdaterated":       {expr: "album_annotation.rated_at", joinType: smartPlaylistJoinAlbumAnnotation},
+	"artistrating":         {expr: "COALESCE(artist_annotation.rating, 0)", joinType: smartPlaylistJoinArtistAnnotation},
+	"artistloved":          {expr: "COALESCE(artist_annotation.starred, false)", joinType: smartPlaylistJoinArtistAnnotation},
+	"artistplaycount":      {expr: "COALESCE(artist_annotation.play_count, 0)", joinType: smartPlaylistJoinArtistAnnotation},
+	"artistlastplayed":     {expr: "artist_annotation.play_date", joinType: smartPlaylistJoinArtistAnnotation},
+	"artistdateloved":      {expr: "artist_annotation.starred_at", joinType: smartPlaylistJoinArtistAnnotation},
+	"artistdaterated":      {expr: "artist_annotation.rated_at", joinType: smartPlaylistJoinArtistAnnotation},
+	"mbz_album_id":         {expr: "media_file.mbz_album_id"},
+	"mbz_album_artist_id":  {expr: "media_file.mbz_album_artist_id"},
+	"mbz_artist_id":        {expr: "media_file.mbz_artist_id"},
+	"mbz_recording_id":     {expr: "media_file.mbz_recording_id"},
+	"mbz_release_track_id": {expr: "media_file.mbz_release_track_id"},
+	"mbz_release_group_id": {expr: "media_file.mbz_release_group_id"},
+	"library_id":           {expr: "media_file.library_id"},
+	"random":               {order: "random()"},
+	"value":                {expr: "value"},
+}
+
+func (c smartPlaylistCriteria) Where() (squirrel.Sqlizer, error) {
+	if c.criteria.Expression == nil {
+		return squirrel.Expr("1 = 1"), nil
+	}
+	return exprSQL(c.criteria.Expression)
+}
+
+func exprSQL(expr criteria.Expression) (squirrel.Sqlizer, error) {
+	switch e := expr.(type) {
+	case criteria.All:
+		and := squirrel.And{}
+		for _, child := range e {
+			cond, err := exprSQL(child)
+			if err != nil {
+				return nil, err
+			}
+			and = append(and, cond)
+		}
+		return and, nil
+	case criteria.Any:
+		or := squirrel.Or{}
+		for _, child := range e {
+			cond, err := exprSQL(child)
+			if err != nil {
+				return nil, err
+			}
+			or = append(or, cond)
+		}
+		return or, nil
+	case criteria.Is:
+		return mapExpr(e, func(fields map[string]any) squirrel.Sqlizer {
+			return squirrel.Eq(fields)
+		}, false)
+	case criteria.IsNot:
+		return isNotExpr(e)
+	case criteria.Gt:
+		return mapExpr(e, func(fields map[string]any) squirrel.Sqlizer {
+			return squirrel.Gt(fields)
+		}, false)
+	case criteria.Lt:
+		return mapExpr(e, func(fields map[string]any) squirrel.Sqlizer {
+			return squirrel.Lt(fields)
+		}, false)
+	case criteria.Before:
+		return mapExpr(e, func(fields map[string]any) squirrel.Sqlizer {
+			return squirrel.Lt(fields)
+		}, false)
+	case criteria.After:
+		return mapExpr(e, func(fields map[string]any) squirrel.Sqlizer {
+			return squirrel.Gt(fields)
+		}, false)
+	case criteria.Contains:
+		return likeExpr(e, "%%%v%%", false)
+	case criteria.NotContains:
+		return likeExpr(e, "%%%v%%", true)
+	case criteria.StartsWith:
+		return likeExpr(e, "%v%%", false)
+	case criteria.EndsWith:
+		return likeExpr(e, "%%%v", false)
+	case criteria.InTheRange:
+		return rangeExpr(e)
+	case criteria.InTheLast:
+		return periodExpr(e, false)
+	case criteria.NotInTheLast:
+		return periodExpr(e, true)
+	case criteria.InPlaylist:
+		return inList(e, false)
+	case criteria.NotInPlaylist:
+		return inList(e, true)
+	default:
+		return nil, fmt.Errorf("unknown criteria expression type %T", expr)
+	}
+}
+
+func isNotExpr[T ~map[string]any](values T) (squirrel.Sqlizer, error) {
+	if _, value, info, ok := singleField(values); ok && (info.IsTag || info.IsRole) {
+		return jsonExpr(info, squirrel.Eq{"value": value}, true), nil
+	}
+	fields, err := sqlFields(values)
+	if err != nil {
+		return nil, err
+	}
+	return squirrel.NotEq(fields), nil
+}
+
+func mapExpr[T ~map[string]any](values T, makeCond func(map[string]any) squirrel.Sqlizer, negateJSON bool) (squirrel.Sqlizer, error) {
+	if _, value, info, ok := singleField(values); ok && (info.IsTag || info.IsRole) {
+		return jsonExpr(info, makeCond(map[string]any{"value": value}), negateJSON), nil
+	}
+	fields, err := sqlFields(values)
+	if err != nil {
+		return nil, err
+	}
+	return makeCond(fields), nil
+}
+
+func likeExpr[T ~map[string]any](values T, pattern string, negate bool) (squirrel.Sqlizer, error) {
+	if _, value, info, ok := singleField(values); ok && (info.IsTag || info.IsRole) {
+		return jsonExpr(info, squirrel.Like{"value": fmt.Sprintf(pattern, value)}, negate), nil
+	}
+	fields, err := sqlFields(values)
+	if err != nil {
+		return nil, err
+	}
+	if negate {
+		lk := squirrel.NotLike{}
+		for field, value := range fields {
+			lk[field] = fmt.Sprintf(pattern, value)
+		}
+		return lk, nil
+	}
+	lk := squirrel.Like{}
+	for field, value := range fields {
+		lk[field] = fmt.Sprintf(pattern, value)
+	}
+	return lk, nil
+}
+
+func rangeExpr[T ~map[string]any](values T) (squirrel.Sqlizer, error) {
+	fields, err := sqlFields(values)
+	if err != nil {
+		return nil, err
+	}
+	and := squirrel.And{}
+	for field, value := range fields {
+		s := reflect.ValueOf(value)
+		if s.Kind() != reflect.Slice || s.Len() != 2 {
+			return nil, fmt.Errorf("invalid range for 'in' operator: %s", value)
+		}
+		and = append(and,
+			squirrel.GtOrEq{field: s.Index(0).Interface()},
+			squirrel.LtOrEq{field: s.Index(1).Interface()},
+		)
+	}
+	return and, nil
+}
+
+func periodExpr[T ~map[string]any](values T, negate bool) (squirrel.Sqlizer, error) {
+	fields, err := sqlFields(values)
+	if err != nil {
+		return nil, err
+	}
+	var field string
+	var value any
+	for f, v := range fields {
+		field, value = f, v
+		break
+	}
+	days, err := strconv.ParseInt(fmt.Sprintf("%v", value), 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	firstDate := startOfPeriod(days, time.Now())
+	if negate {
+		return squirrel.Or{
+			squirrel.Lt{field: firstDate},
+			squirrel.Eq{field: nil},
+		}, nil
+	}
+	return squirrel.Gt{field: firstDate}, nil
+}
+
+func startOfPeriod(numDays int64, from time.Time) string {
+	return from.Add(time.Duration(-24*numDays) * time.Hour).Format("2006-01-02")
+}
+
+func inList[T ~map[string]any](values T, negate bool) (squirrel.Sqlizer, error) {
+	playlistID, ok := values["id"].(string)
+	if !ok {
+		return nil, errors.New("playlist id not given")
+	}
+	subQuery := squirrel.Select("media_file_id").
+		From("playlist_tracks pl").
+		LeftJoin("playlist on pl.playlist_id = playlist.id").
+		Where(squirrel.And{
+			squirrel.Eq{"pl.playlist_id": playlistID},
+			squirrel.Eq{"playlist.public": 1},
+		})
+	subSQL, subArgs, err := subQuery.PlaceholderFormat(squirrel.Question).ToSql()
+	if err != nil {
+		return nil, err
+	}
+	if negate {
+		return squirrel.Expr("media_file.id NOT IN ("+subSQL+")", subArgs...), nil
+	}
+	return squirrel.Expr("media_file.id IN ("+subSQL+")", subArgs...), nil
+}
+
+func jsonExpr(info criteria.FieldInfo, cond squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
+	if info.IsRole {
+		return roleCond{role: info.Name, cond: cond, not: negate}
+	}
+	return tagCond{tag: info.Name, numeric: info.Numeric, cond: cond, not: negate}
+}
+
+type tagCond struct {
+	tag     string
+	numeric bool
+	cond    squirrel.Sqlizer
+	not     bool
+}
+
+func (e tagCond) ToSql() (string, []any, error) {
+	cond, args, err := e.cond.ToSql()
+	if e.numeric {
+		cond = strings.ReplaceAll(cond, "value", "CAST(value AS REAL)")
+	}
+	cond = fmt.Sprintf("exists (select 1 from json_tree(media_file.tags, '$.%s') where key='value' and %s)", e.tag, cond)
+	if e.not {
+		cond = "not " + cond
+	}
+	return cond, args, err
+}
+
+type roleCond struct {
+	role string
+	cond squirrel.Sqlizer
+	not  bool
+}
+
+func (e roleCond) ToSql() (string, []any, error) {
+	cond, args, err := e.cond.ToSql()
+	cond = fmt.Sprintf("exists (select 1 from json_tree(media_file.participants, '$.%s') where key='name' and %s)", e.role, cond)
+	if e.not {
+		cond = "not " + cond
+	}
+	return cond, args, err
+}
+
+func singleField[T ~map[string]any](values T) (string, any, criteria.FieldInfo, bool) {
+	if len(values) != 1 {
+		return "", nil, criteria.FieldInfo{}, false
+	}
+	for field, value := range values {
+		info, ok := criteria.LookupField(field)
+		return field, value, info, ok
+	}
+	return "", nil, criteria.FieldInfo{}, false
+}
+
+func sqlFields[T ~map[string]any](values T) (map[string]any, error) {
+	fields := make(map[string]any, len(values))
+	for field, value := range values {
+		info, ok := criteria.LookupField(field)
+		if !ok {
+			return nil, fmt.Errorf("invalid field in criteria: %s", field)
+		}
+		if info.IsTag || info.IsRole {
+			return nil, fmt.Errorf("tag and role criteria must contain exactly one field: %s", field)
+		}
+		sqlField, ok := fieldExpr(info.Name)
+		if !ok || sqlField == "" {
+			return nil, fmt.Errorf("invalid field in criteria: %s", field)
+		}
+		fields[sqlField] = value
+	}
+	return fields, nil
+}
+
+func fieldExpr(name string) (string, bool) {
+	field, ok := smartPlaylistFields[strings.ToLower(name)]
+	return field.expr, ok
+}
+
+func fieldJoinType(name string) smartPlaylistJoinType {
+	info, ok := criteria.LookupField(name)
+	if !ok {
+		return smartPlaylistJoinNone
+	}
+	field, ok := smartPlaylistFields[info.Name]
+	if !ok {
+		return smartPlaylistJoinNone
+	}
+	return field.joinType
+}
+
+func (c smartPlaylistCriteria) ExpressionJoins() smartPlaylistJoinType {
+	var joins smartPlaylistJoinType
+	_ = criteria.Walk(c.criteria.Expression, func(expr criteria.Expression) error {
+		for field := range criteria.Fields(expr) {
+			joins |= fieldJoinType(field)
+		}
+		return nil
+	})
+	return joins
+}
+
+func (c smartPlaylistCriteria) RequiredJoins() smartPlaylistJoinType {
+	joins := c.ExpressionJoins()
+	for _, sortField := range sortFields(c.criteria.Sort) {
+		joins |= fieldJoinType(sortField)
+	}
+	return joins
+}
+
+func (c smartPlaylistCriteria) OrderBy() string {
+	sortValue := c.criteria.Sort
+	if sortValue == "" {
+		sortValue = "title"
+	}
+
+	order := strings.ToLower(strings.TrimSpace(c.criteria.Order))
+	if order != "" && order != "asc" && order != "desc" {
+		log.Error("Invalid value in 'order' field. Valid values: 'asc', 'desc'", "order", c.criteria.Order)
+		order = ""
+	}
+
+	parts := strings.Split(sortValue, ",")
+	fields := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		dir := "asc"
+		if strings.HasPrefix(part, "+") || strings.HasPrefix(part, "-") {
+			if strings.HasPrefix(part, "-") {
+				dir = "desc"
+			}
+			part = strings.TrimSpace(part[1:])
+		}
+		sortField := strings.ToLower(part)
+		mapped, ok := sortExpr(sortField)
+		if !ok {
+			log.Error("Invalid field in 'sort' field", "sort", sortField)
+			continue
+		}
+		if order == "desc" {
+			if dir == "asc" {
+				dir = "desc"
+			} else {
+				dir = "asc"
+			}
+		}
+		fields = append(fields, mapped+" "+dir)
+	}
+	return strings.Join(fields, ", ")
+}
+
+func sortFields(sortValue string) []string {
+	if sortValue == "" {
+		sortValue = "title"
+	}
+	parts := strings.Split(sortValue, ",")
+	fields := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(part), "+-"))
+		if part != "" {
+			fields = append(fields, part)
+		}
+	}
+	return fields
+}
+
+func sortExpr(sortField string) (string, bool) {
+	info, ok := criteria.LookupField(sortField)
+	if !ok {
+		return "", false
+	}
+	if field, ok := smartPlaylistFields[info.Name]; ok && field.order != "" {
+		return field.order, true
+	}
+	var mapped string
+	switch {
+	case info.IsTag:
+		mapped = "COALESCE(json_extract(media_file.tags, '$." + info.Name + "[0].value'), '')"
+	case info.IsRole:
+		mapped = "COALESCE(json_extract(media_file.participants, '$." + info.Name + "[0].name'), '')"
+	default:
+		field, ok := smartPlaylistFields[info.Name]
+		if !ok || field.expr == "" {
+			return "", false
+		}
+		mapped = field.expr
+	}
+	if info.Numeric {
+		mapped = fmt.Sprintf("CAST(%s AS REAL)", mapped)
+	}
+	return mapped, true
+}
diff --git a/persistence/criteria_sql_test.go b/persistence/criteria_sql_test.go
new file mode 100644
index 000000000..9fa5ff104
--- /dev/null
+++ b/persistence/criteria_sql_test.go
@@ -0,0 +1,170 @@
+package persistence
+
+import (
+	"time"
+
+	"github.com/navidrome/navidrome/model/criteria"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Smart playlist criteria SQL", func() {
+	BeforeEach(func() {
+		criteria.AddRoles([]string{"artist", "composer", "producer"})
+		criteria.AddTagNames([]string{"genre", "mood", "releasetype"})
+		criteria.AddNumericTags([]string{"rate"})
+	})
+
+	DescribeTable("expressions",
+		func(expr criteria.Expression, expectedSQL string, expectedArgs ...any) {
+			sqlizer, err := newSmartPlaylistCriteria(criteria.Criteria{Expression: expr}).Where()
+			Expect(err).ToNot(HaveOccurred())
+
+			sql, args, err := sqlizer.ToSql()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(sql).To(Equal(expectedSQL))
+			Expect(args).To(HaveExactElements(expectedArgs...))
+		},
+		Entry("all group",
+			criteria.All{criteria.Contains{"title": "love"}, criteria.Gt{"rating": 3}},
+			"(media_file.title LIKE ? AND COALESCE(annotation.rating, 0) > ?)", "%love%", 3),
+		Entry("any group",
+			criteria.Any{criteria.Is{"title": "Low Rider"}, criteria.Is{"album": "Best Of"}},
+			"(media_file.title = ? OR media_file.album = ?)", "Low Rider", "Best Of"),
+		Entry("is string", criteria.Is{"title": "Low Rider"}, "media_file.title = ?", "Low Rider"),
+		Entry("is bool", criteria.Is{"loved": true}, "COALESCE(annotation.starred, false) = ?", true),
+		Entry("is numeric list", criteria.Is{"library_id": []int{1, 2}}, "media_file.library_id IN (?,?)", 1, 2),
+		Entry("is not", criteria.IsNot{"title": "Low Rider"}, "media_file.title <> ?", "Low Rider"),
+		Entry("gt", criteria.Gt{"playCount": 10}, "COALESCE(annotation.play_count, 0) > ?", 10),
+		Entry("lt", criteria.Lt{"playCount": 10}, "COALESCE(annotation.play_count, 0) < ?", 10),
+		Entry("contains", criteria.Contains{"title": "Low Rider"}, "media_file.title LIKE ?", "%Low Rider%"),
+		Entry("not contains", criteria.NotContains{"title": "Low Rider"}, "media_file.title NOT LIKE ?", "%Low Rider%"),
+		Entry("starts with", criteria.StartsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "Low Rider%"),
+		Entry("ends with", criteria.EndsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "%Low Rider"),
+		Entry("in range", criteria.InTheRange{"year": []int{1980, 1990}}, "(media_file.year >= ? AND media_file.year <= ?)", 1980, 1990),
+		Entry("before", criteria.Before{"lastPlayed": time.Date(2021, 10, 1, 0, 0, 0, 0, time.Local)}, "annotation.play_date < ?", time.Date(2021, 10, 1, 0, 0, 0, 0, time.Local)),
+		Entry("after", criteria.After{"lastPlayed": time.Date(2021, 10, 1, 0, 0, 0, 0, time.Local)}, "annotation.play_date > ?", time.Date(2021, 10, 1, 0, 0, 0, 0, time.Local)),
+		Entry("in playlist", criteria.InPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id IN (SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
+		Entry("not in playlist", criteria.NotInPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id NOT IN (SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
+		Entry("album annotation", criteria.Gt{"albumRating": 3}, "COALESCE(album_annotation.rating, 0) > ?", 3),
+		Entry("artist annotation", criteria.Is{"artistLoved": true}, "COALESCE(artist_annotation.starred, false) = ?", true),
+		Entry("tag is", criteria.Is{"genre": "Rock"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value = ?)", "Rock"),
+		Entry("tag is not", criteria.IsNot{"genre": "Rock"}, "not exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value = ?)", "Rock"),
+		Entry("tag contains", criteria.Contains{"genre": "Rock"}, "exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
+		Entry("tag not contains", criteria.NotContains{"genre": "Rock"}, "not exists (select 1 from json_tree(media_file.tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
+		Entry("numeric tag", criteria.Lt{"rate": 6}, "exists (select 1 from json_tree(media_file.tags, '$.rate') where key='value' and CAST(value AS REAL) < ?)", 6),
+		Entry("tag alias", criteria.Is{"albumtype": "album"}, "exists (select 1 from json_tree(media_file.tags, '$.releasetype') where key='value' and value = ?)", "album"),
+		Entry("role is", criteria.Is{"artist": "u2"}, "exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value = ?)", "u2"),
+		Entry("role contains", criteria.Contains{"composer": "Lennon"}, "exists (select 1 from json_tree(media_file.participants, '$.composer') where key='name' and value LIKE ?)", "%Lennon%"),
+		Entry("role not contains", criteria.NotContains{"artist": "u2"}, "not exists (select 1 from json_tree(media_file.participants, '$.artist') where key='name' and value LIKE ?)", "%u2%"),
+	)
+
+	It("builds relative date expressions", func() {
+		sqlizer, err := newSmartPlaylistCriteria(criteria.Criteria{Expression: criteria.InTheLast{"lastPlayed": 30}}).Where()
+		Expect(err).ToNot(HaveOccurred())
+
+		sql, args, err := sqlizer.ToSql()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(sql).To(Equal("annotation.play_date > ?"))
+		Expect(args).To(HaveExactElements(startOfPeriod(30, time.Now())))
+	})
+
+	It("builds negated relative date expressions", func() {
+		sqlizer, err := newSmartPlaylistCriteria(criteria.Criteria{Expression: criteria.NotInTheLast{"lastPlayed": 30}}).Where()
+		Expect(err).ToNot(HaveOccurred())
+
+		sql, args, err := sqlizer.ToSql()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(sql).To(Equal("(annotation.play_date < ? OR annotation.play_date IS NULL)"))
+		Expect(args).To(HaveExactElements(startOfPeriod(30, time.Now())))
+	})
+
+	It("returns an error for unknown fields", func() {
+		_, err := newSmartPlaylistCriteria(criteria.Criteria{Expression: criteria.EndsWith{"unknown": "value"}}).Where()
+
+		Expect(err).To(MatchError("invalid field in criteria: unknown"))
+	})
+
+	Describe("sort", func() {
+		It("sorts by regular fields", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "title"}).OrderBy()).To(Equal("media_file.title asc"))
+		})
+
+		It("sorts by tag fields", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "genre"}).OrderBy()).To(Equal("COALESCE(json_extract(media_file.tags, '$.genre[0].value'), '') asc"))
+		})
+
+		It("sorts by role fields", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "artist"}).OrderBy()).To(Equal("COALESCE(json_extract(media_file.participants, '$.artist[0].name'), '') asc"))
+		})
+
+		It("casts numeric tags when sorting", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "rate"}).OrderBy()).To(Equal("CAST(COALESCE(json_extract(media_file.tags, '$.rate[0].value'), '') AS REAL) asc"))
+		})
+
+		It("sorts by albumtype alias", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "albumtype"}).OrderBy()).To(Equal("COALESCE(json_extract(media_file.tags, '$.releasetype[0].value'), '') asc"))
+		})
+
+		It("sorts by random", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "random"}).OrderBy()).To(Equal("random() asc"))
+		})
+
+		It("sorts by multiple fields", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "title,-rating"}).OrderBy()).To(Equal("media_file.title asc, COALESCE(annotation.rating, 0) desc"))
+		})
+
+		It("reverts order when order is desc", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "-date,artist", Order: "desc"}).OrderBy()).To(Equal("media_file.date asc, COALESCE(json_extract(media_file.participants, '$.artist[0].name'), '') desc"))
+		})
+
+		It("ignores invalid sort fields", func() {
+			Expect(newSmartPlaylistCriteria(criteria.Criteria{Sort: "bogus,title"}).OrderBy()).To(Equal("media_file.title asc"))
+		})
+	})
+
+	It("has SQL mappings for all non-tag/non-role criteria fields", func() {
+		for _, name := range criteria.AllFieldNames() {
+			info, ok := criteria.LookupField(name)
+			Expect(ok).To(BeTrue(), "field %q registered but LookupField fails", name)
+			if info.IsTag || info.IsRole {
+				continue
+			}
+			_, hasSQLField := smartPlaylistFields[info.Name]
+			Expect(hasSQLField).To(BeTrue(), "criteria field %q (name=%q) has no entry in smartPlaylistFields", name, info.Name)
+		}
+	})
+
+	Describe("joins", func() {
+		It("excludes sort-only joins from expression joins", func() {
+			c := criteria.Criteria{Expression: criteria.All{criteria.Contains{"title": "love"}}, Sort: "albumRating"}
+			cSQL := newSmartPlaylistCriteria(c)
+
+			Expect(cSQL.ExpressionJoins()).To(Equal(smartPlaylistJoinNone))
+			Expect(cSQL.RequiredJoins().has(smartPlaylistJoinAlbumAnnotation)).To(BeTrue())
+		})
+
+		It("includes expression-based joins", func() {
+			c := criteria.Criteria{Expression: criteria.All{criteria.Gt{"albumRating": 3}}}
+
+			Expect(newSmartPlaylistCriteria(c).ExpressionJoins().has(smartPlaylistJoinAlbumAnnotation)).To(BeTrue())
+		})
+
+		It("detects nested album and artist joins", func() {
+			c := criteria.Criteria{Expression: criteria.All{
+				criteria.Any{criteria.All{criteria.Is{"albumLoved": true}}},
+				criteria.Any{criteria.Gt{"artistPlayCount": 10}},
+			}}
+
+			joins := newSmartPlaylistCriteria(c).RequiredJoins()
+			Expect(joins.has(smartPlaylistJoinAlbumAnnotation)).To(BeTrue())
+			Expect(joins.has(smartPlaylistJoinArtistAnnotation)).To(BeTrue())
+		})
+
+		It("detects join types from sort fields with direction prefixes", func() {
+			c := criteria.Criteria{Expression: criteria.All{criteria.Contains{"title": "love"}}, Sort: "-artistRating"}
+
+			Expect(newSmartPlaylistCriteria(c).RequiredJoins().has(smartPlaylistJoinArtistAnnotation)).To(BeTrue())
+		})
+	})
+})
diff --git a/persistence/playlist_repository.go b/persistence/playlist_repository.go
index 8d1bbe0f8..6bf3ded30 100644
--- a/persistence/playlist_repository.go
+++ b/persistence/playlist_repository.go
@@ -228,6 +228,7 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 
 	// Re-populate playlist based on Smart Playlist criteria
 	rules := *pls.Rules
+	rulesSQL := newSmartPlaylistCriteria(rules)
 
 	// If the playlist depends on other playlists, recursively refresh them first
 	childPlaylistIds := rules.ChildPlaylistIds()
@@ -240,14 +241,15 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 		r.refreshSmartPlaylist(childPls)
 	}
 
-	sq := Select("row_number() over (order by "+rules.OrderBy()+") as id", "'"+pls.ID+"' as playlist_id", "media_file.id as media_file_id").
+	orderBy := rulesSQL.OrderBy()
+	sq := Select("row_number() over (order by "+orderBy+") as id", "'"+pls.ID+"' as playlist_id", "media_file.id as media_file_id").
 		From("media_file").LeftJoin("annotation on ("+
 		"annotation.item_id = media_file.id"+
 		" AND annotation.item_type = 'media_file'"+
 		" AND annotation.user_id = ?)", usr.ID)
 
 	// Conditionally join album/artist annotation tables only when referenced by criteria or sort
-	requiredJoins := rules.RequiredJoins()
+	requiredJoins := rulesSQL.RequiredJoins()
 	sq = r.addSmartPlaylistAnnotationJoins(sq, requiredJoins, usr.ID)
 
 	// Only include media files from libraries the user has access to
@@ -256,7 +258,7 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 	// Resolve percentage-based limit to an absolute number before applying criteria
 	if rules.IsPercentageLimit() {
 		// Use only expression-based joins for the COUNT query (sort joins are unnecessary)
-		exprJoins := rules.ExpressionJoins()
+		exprJoins := rulesSQL.ExpressionJoins()
 		countSq := Select("count(*) as count").From("media_file").
 			LeftJoin("annotation on ("+
 				"annotation.item_id = media_file.id"+
@@ -264,7 +266,12 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 				" AND annotation.user_id = ?)", usr.ID)
 		countSq = r.addSmartPlaylistAnnotationJoins(countSq, exprJoins, usr.ID)
 		countSq = r.applyLibraryFilter(countSq, "media_file")
-		countSq = countSq.Where(rules)
+		cond, err := rulesSQL.Where()
+		if err != nil {
+			log.Error(r.ctx, "Error building smart playlist criteria", "playlist", pls.Name, "id", pls.ID, err)
+			return false
+		}
+		countSq = countSq.Where(cond)
 
 		var res struct{ Count int64 }
 		err = r.queryOne(countSq, &res)
@@ -279,7 +286,11 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 	}
 
 	// Apply the criteria rules
-	sq = r.addCriteria(sq, rules)
+	sq, err = r.addCriteria(sq, rules)
+	if err != nil {
+		log.Error(r.ctx, "Error building smart playlist criteria", "playlist", pls.Name, "id", pls.ID, err)
+		return false
+	}
 	insSql := Insert("playlist_tracks").Columns("id", "playlist_id", "media_file_id").Select(sq)
 	_, err = r.executeSQL(insSql)
 	if err != nil {
@@ -310,14 +321,14 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 	return true
 }
 
-func (r *playlistRepository) addSmartPlaylistAnnotationJoins(sq SelectBuilder, joins criteria.JoinType, userID string) SelectBuilder {
-	if joins.Has(criteria.JoinAlbumAnnotation) {
+func (r *playlistRepository) addSmartPlaylistAnnotationJoins(sq SelectBuilder, joins smartPlaylistJoinType, userID string) SelectBuilder {
+	if joins.has(smartPlaylistJoinAlbumAnnotation) {
 		sq = sq.LeftJoin("annotation AS album_annotation ON ("+
 			"album_annotation.item_id = media_file.album_id"+
 			" AND album_annotation.item_type = 'album'"+
 			" AND album_annotation.user_id = ?)", userID)
 	}
-	if joins.Has(criteria.JoinArtistAnnotation) {
+	if joins.has(smartPlaylistJoinArtistAnnotation) {
 		sq = sq.LeftJoin("annotation AS artist_annotation ON ("+
 			"artist_annotation.item_id = media_file.artist_id"+
 			" AND artist_annotation.item_type = 'artist'"+
@@ -326,15 +337,20 @@ func (r *playlistRepository) addSmartPlaylistAnnotationJoins(sq SelectBuilder, j
 	return sq
 }
 
-func (r *playlistRepository) addCriteria(sql SelectBuilder, c criteria.Criteria) SelectBuilder {
-	sql = sql.Where(c)
+func (r *playlistRepository) addCriteria(sql SelectBuilder, c criteria.Criteria) (SelectBuilder, error) {
+	cSQL := newSmartPlaylistCriteria(c)
+	cond, err := cSQL.Where()
+	if err != nil {
+		return sql, err
+	}
+	sql = sql.Where(cond)
 	if c.Limit > 0 {
 		sql = sql.Limit(uint64(c.Limit)).Offset(uint64(c.Offset))
 	}
-	if order := c.OrderBy(); order != "" {
+	if order := cSQL.OrderBy(); order != "" {
 		sql = sql.OrderBy(order)
 	}
-	return sql
+	return sql, nil
 }
 
 func (r *playlistRepository) updateTracks(id string, tracks model.MediaFiles) error {