fix(sort): handle empty album_artist in artist sort order

COALESCE(album_artist, artist) treats empty string "" as non-null,
so tracks with empty album_artist tags sort by "" instead of falling
through to artist. Use NULLIF to convert empty strings to NULL in
the SQL, and normalize empty/whitespace-only tag strings to None
during metadata extraction to prevent bad data entering the database.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pythoninthegrass

crates/mt-tauri/src/db/models.rs

@@ -203,15 +203,13 @@ pub struct PaginatedResult<T> {
 }
 
 /// Sort order for queries
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum SortOrder {
     Asc,
     #[default]
     Desc,
 }
 
-
 impl SortOrder {
     pub fn as_sql(&self) -> &'static str {
         match self {
@@ -222,8 +220,7 @@ impl SortOrder {
 }
 
 /// Valid sort columns for library queries
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum LibrarySortColumn {
     Title,
     Artist,
@@ -240,9 +237,8 @@ pub enum LibrarySortColumn {
     TrackNumber,
 }
 
-
 /// Raw column expression for artist sort (no COLLATE).
-const ARTIST_SORT_EXPR: &str = "COALESCE(album_artist, artist)";
+const ARTIST_SORT_EXPR: &str = "COALESCE(NULLIF(album_artist, ''), artist)";
 
 impl LibrarySortColumn {
     /// Raw column expression without COLLATE or wrapping
@@ -279,7 +275,9 @@ impl LibrarySortColumn {
     pub fn as_sql(&self) -> &'static str {
         match self {
             LibrarySortColumn::Title => "title COLLATE NOCASE",
-            LibrarySortColumn::Artist => "COALESCE(album_artist, artist) COLLATE NOCASE",
+            LibrarySortColumn::Artist => {
+                "COALESCE(NULLIF(album_artist, ''), artist) COLLATE NOCASE"
+            }
             LibrarySortColumn::Album => "album COLLATE NOCASE",
             LibrarySortColumn::AddedDate => "added_date",
             LibrarySortColumn::PlayCount => "play_count",
@@ -321,11 +319,17 @@ impl LibrarySortColumn {
     /// Uses CAST(... AS INTEGER) because track_number and disc_number are TEXT columns.
     pub fn secondary_sort_sql(&self) -> &'static str {
         match self {
-            LibrarySortColumn::Artist => ", album COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC",
-            LibrarySortColumn::Album => ", COALESCE(album_artist, artist) COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC",
+            LibrarySortColumn::Artist => {
+                ", album COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC"
+            }
+            LibrarySortColumn::Album => {
+                ", COALESCE(NULLIF(album_artist, ''), artist) COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC"
+            }
             LibrarySortColumn::DiscNumber => ", CAST(track_number AS INTEGER) ASC",
             LibrarySortColumn::TrackNumber => ", CAST(disc_number AS INTEGER) ASC",
-            _ => ", COALESCE(album_artist, artist) COLLATE NOCASE ASC, album COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC",
+            _ => {
+                ", COALESCE(NULLIF(album_artist, ''), artist) COLLATE NOCASE ASC, album COLLATE NOCASE ASC, CAST(disc_number AS INTEGER) ASC, CAST(track_number AS INTEGER) ASC"
+            }
         }
     }
 
@@ -391,6 +395,34 @@ mod tests {
         assert_eq!(deserialized.title, Some("Test Song".to_string()));
     }
 
+    #[test]
+    fn test_artist_sort_expr_uses_nullif() {
+        // Empty album_artist should fall through to artist, not sort as ""
+        let expr = ARTIST_SORT_EXPR;
+        assert!(
+            expr.contains("NULLIF"),
+            "ARTIST_SORT_EXPR must use NULLIF to handle empty album_artist: {expr}"
+        );
+        assert!(
+            expr.contains("NULLIF(album_artist, '')"),
+            "ARTIST_SORT_EXPR must convert empty album_artist to NULL: {expr}"
+        );
+    }
+
+    #[test]
+    fn test_artist_order_by_with_ignore_words() {
+        let col = LibrarySortColumn::Artist;
+        let order_by = col.as_order_by(Some("the, a, an"));
+        assert!(
+            order_by.contains("NULLIF(album_artist, '')"),
+            "Artist ORDER BY must handle empty album_artist: {order_by}"
+        );
+        assert!(
+            order_by.contains("strip_sort_prefix"),
+            "Artist ORDER BY with ignore_words must use strip_sort_prefix: {order_by}"
+        );
+    }
+
     #[test]
     fn test_sort_column_from_str() {
         use std::str::FromStr;

crates/mt-tauri/src/metadata.rs

@@ -6,6 +6,16 @@ use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::path::Path;
 
+/// Convert empty or whitespace-only tag strings to None.
+fn non_empty(s: &str) -> Option<String> {
+    let trimmed = s.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct TrackMetadata {
     pub path: String,
@@ -57,7 +67,9 @@ pub fn get_track_metadata(path: String) -> Result<TrackMetadata, String> {
     };
 
     if let Some(tagged_file) = tagged_file {
-        let tag = tagged_file.primary_tag().or_else(|| tagged_file.first_tag());
+        let tag = tagged_file
+            .primary_tag()
+            .or_else(|| tagged_file.first_tag());
         let properties = tagged_file.properties();
 
         let format = match tagged_file.file_type() {
@@ -76,23 +88,33 @@ pub fn get_track_metadata(path: String) -> Result<TrackMetadata, String> {
             _ => "Unknown",
         };
 
-        let (title, artist, album, album_artist, track_number, track_total, disc_number, disc_total, year, genre) =
-            if let Some(tag) = tag {
-                (
-                    tag.title().map(|s| s.to_string()),
-                    tag.artist().map(|s| s.to_string()),
-                    tag.album().map(|s| s.to_string()),
-                    tag.get_string(&ItemKey::AlbumArtist).map(|s| s.to_string()),
-                    tag.track(),
-                    tag.track_total(),
-                    tag.disk(),
-                    tag.disk_total(),
-                    tag.year(),
-                    tag.genre().map(|s| s.to_string()),
-                )
-            } else {
-                (None, None, None, None, None, None, None, None, None, None)
-            };
+        let (
+            title,
+            artist,
+            album,
+            album_artist,
+            track_number,
+            track_total,
+            disc_number,
+            disc_total,
+            year,
+            genre,
+        ) = if let Some(tag) = tag {
+            (
+                tag.title().and_then(|s| non_empty(&s)),
+                tag.artist().and_then(|s| non_empty(&s)),
+                tag.album().and_then(|s| non_empty(&s)),
+                tag.get_string(&ItemKey::AlbumArtist).and_then(non_empty),
+                tag.track(),
+                tag.track_total(),
+                tag.disk(),
+                tag.disk_total(),
+                tag.year(),
+                tag.genre().and_then(|s| non_empty(&s)),
+            )
+        } else {
+            (None, None, None, None, None, None, None, None, None, None)
+        };
 
         Ok(TrackMetadata {
             path,
@@ -115,7 +137,10 @@ pub fn get_track_metadata(path: String) -> Result<TrackMetadata, String> {
     } else {
         // File exists but tags are unreadable — return empty metadata so the
         // editor can still open and the user can write new tags.
-        tracing::warn!("Could not parse tags for {:?}; returning empty metadata", path);
+        tracing::warn!(
+            "Could not parse tags for {:?}; returning empty metadata",
+            path
+        );
         Ok(TrackMetadata {
             path,
             title: None,
@@ -467,7 +492,20 @@ mod tests {
 
     #[test]
     fn test_supported_formats() {
-        let formats = ["AAC", "AIFF", "APE", "FLAC", "MP3", "M4A", "MPC", "Opus", "Ogg Vorbis", "Speex", "WAV", "WavPack"];
+        let formats = [
+            "AAC",
+            "AIFF",
+            "APE",
+            "FLAC",
+            "MP3",
+            "M4A",
+            "MPC",
+            "Opus",
+            "Ogg Vorbis",
+            "Speex",
+            "WAV",
+            "WavPack",
+        ];
 
         for format in formats {
             let metadata = TrackMetadata {
@@ -651,9 +689,7 @@ mod tests {
 
     #[test]
     fn test_batch_metadata_missing_file_returns_error() {
-        let result = get_tracks_metadata_batch(vec![
-            "/nonexistent/file1.mp3".to_string(),
-        ]);
+        let result = get_tracks_metadata_batch(vec!["/nonexistent/file1.mp3".to_string()]);
         assert!(result.is_err());
     }
 

crates/mt-tauri/src/scanner/metadata.rs

@@ -8,12 +8,22 @@ use lofty::prelude::*;
 use lofty::probe::Probe;
 use rayon::prelude::*;
 use std::path::Path;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use crate::scanner::fingerprint::FileFingerprint;
 use crate::scanner::{ExtractedMetadata, ScanResult};
 
+/// Convert empty or whitespace-only tag strings to None.
+fn non_empty(s: &str) -> Option<String> {
+    let trimmed = s.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
 /// Extract metadata from a single audio file
 pub fn extract_metadata(filepath: &str) -> ScanResult<ExtractedMetadata> {
     let path = Path::new(filepath);
@@ -78,10 +88,10 @@ pub fn extract_metadata(filepath: &str) -> ScanResult<ExtractedMetadata> {
         .primary_tag()
         .or_else(|| tagged_file.first_tag())
     {
-        metadata.title = tag.title().map(|s| s.to_string());
-        metadata.artist = tag.artist().map(|s| s.to_string());
-        metadata.album = tag.album().map(|s| s.to_string());
-        metadata.album_artist = tag.get_string(&ItemKey::AlbumArtist).map(|s| s.to_string());
+        metadata.title = tag.title().and_then(|s| non_empty(&s));
+        metadata.artist = tag.artist().and_then(|s| non_empty(&s));
+        metadata.album = tag.album().and_then(|s| non_empty(&s));
+        metadata.album_artist = tag.get_string(&ItemKey::AlbumArtist).and_then(non_empty);
 
         // Track number can be in format "1" or "1/10"
         metadata.track_number = tag.track().map(|n| n.to_string());
@@ -93,7 +103,7 @@ pub fn extract_metadata(filepath: &str) -> ScanResult<ExtractedMetadata> {
         // Year/date
         metadata.date = tag.year().map(|y| y.to_string());
 
-        metadata.genre = tag.genre().map(|s| s.to_string());
+        metadata.genre = tag.genre().and_then(|s| non_empty(&s));
     }
 
     // Use filename as title if no title found