[banshee] Banshee.Services: Refactoring, BansheeQuery.GetSort to receive QueryField



commit 9528a741e628096a18444ccd9098796bbc404bca
Author: AndrÃs G. Aragoneses <knocte gmail com>
Date:   Mon Sep 19 22:19:13 2011 +0100

    Banshee.Services: Refactoring, BansheeQuery.GetSort to receive QueryField
    
    BansheeQuery.GetSort() method now receives a QueryField object
    instead of a string with the key to be sorted. This way we
    stop hardcoding some columns that were already defined in the
    corresponding QueryField instances, and we replace the big
    string-swtich statement with object-reference comparisons,
    which is faster, although still not perfect (I guess this can
    still be improved with a bit of polymorphism, maybe moving
    the method to QueryField class, and overriding in the special
    cases).
    
    This commit also removes a TODO and a FIXME. Win.

 .../DatabaseTrackListModel.cs                      |    4 +-
 .../Banshee.Services/Banshee.Query/BansheeQuery.cs |  239 +++++++-------
 .../Banshee.Query/Tests/BansheeQueryTests.cs       |  335 ++++++++++----------
 .../Banshee.Audiobook/AudiobookLibrarySource.cs    |    2 +-
 .../PodcastTrackListModel.cs                       |    9 +-
 5 files changed, 297 insertions(+), 292 deletions(-)
---
diff --git a/src/Core/Banshee.Services/Banshee.Collection.Database/DatabaseTrackListModel.cs b/src/Core/Banshee.Services/Banshee.Collection.Database/DatabaseTrackListModel.cs
index ad9b45d..f8d2a50 100644
--- a/src/Core/Banshee.Services/Banshee.Collection.Database/DatabaseTrackListModel.cs
+++ b/src/Core/Banshee.Services/Banshee.Collection.Database/DatabaseTrackListModel.cs
@@ -142,8 +142,8 @@ namespace Banshee.Collection.Database
             SortQuery = (SortColumn == null || SortColumn.SortType == SortType.None)
                 ? (SortColumn != null && source is Banshee.Playlist.PlaylistSource)
                     ? "CorePlaylistEntries.ViewOrder ASC, CorePlaylistEntries.EntryID ASC"
-                    : BansheeQuery.GetSort ("Artist", true)
-                : BansheeQuery.GetSort (SortColumn.SortKey, SortColumn.SortType == SortType.Ascending);
+                    : BansheeQuery.GetSort (BansheeQuery.ArtistField, true)
+                : BansheeQuery.GetSort (SortColumn.Field, SortColumn.SortType == SortType.Ascending);
         }
 
         private SortType last_sort_type = SortType.None;
diff --git a/src/Core/Banshee.Services/Banshee.Query/BansheeQuery.cs b/src/Core/Banshee.Services/Banshee.Query/BansheeQuery.cs
index ec8fbb2..bb295e4 100644
--- a/src/Core/Banshee.Services/Banshee.Query/BansheeQuery.cs
+++ b/src/Core/Banshee.Services/Banshee.Query/BansheeQuery.cs
@@ -4,8 +4,10 @@
 // Author:
 //   Aaron Bockover <abockover novell com>
 //   Gabriel Burt <gburt novell com>
+//   AndrÃs G. Aragoneses <knocte gmail com>
 //
 // Copyright (C) 2007-2008 Novell, Inc.
+// Copyright (C) 2011 AndrÃs G. Aragoneses
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -353,7 +355,7 @@ namespace Banshee.Query
             default_sort = String.Format (default_sort_template, "");
             default_sort_by_year = String.Format (default_sort_template, "CoreTracks.Year ASC, ");
 
-            RandomOrder = CreateQueryOrder ("Random", asc, Catalog.GetString ("Random"), null);
+            RandomOrder = CreateRandomQueryOrder ();
 
             Orders = new QueryOrder [] {
                 RandomOrder,
@@ -384,138 +386,143 @@ namespace Banshee.Query
         private static readonly string default_sort;
         private static readonly string default_sort_by_year;
 
-        public static string GetSort (string key)
+        public static string GetSort (QueryField key)
         {
             return GetSort (key, false);
         }
 
-        public static string GetSort (string key, bool asc)
+        public static string GetRandomSort ()
         {
+            return "RANDOM ()";
+        }
+
+        public static string GetSort (QueryField field, bool asc)
+        {
+            if (field == null) {
+                throw new ArgumentNullException ("key");
+            }
+
             bool sort_by_year = Banshee.Configuration.Schema.LibrarySchema.SortByAlbumYear.Get ();
             string sort_by_year_part = sort_by_year ? "CoreTracks.Year ASC," : "";
             string sort = sort_by_year ? default_sort_by_year : default_sort;
 
             string ascDesc = asc ? "ASC" : "DESC";
             string sort_query = null;
-            // TODO use the QueryFields here instead of matching on a string key
-            string column = null;
-            switch (key.ToLower ()) {
-                case "track":
-                case "grouping":
-                    sort_query = String.Format (@"
-                        CoreAlbums.ArtistNameSortKey ASC,
-                        {1}
-                        CoreAlbums.TitleSortKey ASC,
-                        CoreTracks.Disc ASC,
-                        CoreTracks.TrackNumber {0}", ascDesc, sort_by_year_part);
-                    break;
-
-                case "albumartist":
-                    sort_query = String.Format (@"
-                        CoreAlbums.ArtistNameSortKey {0},
-                        {1}
-                        CoreAlbums.TitleSortKey ASC,
-                        CoreTracks.Disc ASC,
-                        CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
-                    break;
-
-                case "artist":
-                    sort_query = String.Format (@"
-                        CoreArtists.NameSortKey {0},
-                        {1}
-                        CoreAlbums.TitleSortKey ASC,
-                        CoreTracks.Disc ASC,
-                        CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
-                    break;
-
-                case "album":
-                    sort_query = String.Format (@"
-                        CoreAlbums.TitleSortKey {0},
-                        {1}
-                        CoreTracks.Disc ASC,
-                        CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
-                    break;
-
-                case "title":
-                    sort_query = String.Format (@"
-                        CoreTracks.TitleSortKey {0},
-                        CoreAlbums.ArtistNameSortKey ASC,
-                        {1}
-                        CoreAlbums.TitleSortKey ASC", ascDesc, sort_by_year_part);
-                    break;
-
-                case "random":
-                    sort_query = "RANDOM ()";
-                    break;
-
-                case "disc":
-                    sort_query = String.Format (@"
-                        CoreAlbums.ArtistNameSortKey ASC,
-                        {1}
-                        CoreAlbums.TitleSortKey ASC,
-                        CoreTracks.Disc {0},
-                        CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
-                    break;
-
-                // FIXME hacks to aid in migration of these sort keys to actually
-                // using the QueryField (or at least their .Names)
-                case "lastplayed":
-                case "lastskipped":
-                    column = String.Format ("{0}stamp", key);
-                    goto case "year";
-                case "added":
-                    column = "dateaddedstamp";
-                    goto case "year";
-
-                case "conductor":
-                case "genre":
-                case "composer":
-                case "comment":
-                    sort_query = String.Format (
-                        "HYENA_COLLATION_KEY(CoreTracks.{0}) {1}, {2}",
-                        column ?? key, ascDesc, sort
-                    );
-                    break;
-
-                case "score":
-                    sort_query = String.Format (@"
-                        CoreTracks.Score {0},
-                        CoreTracks.Playcount {0}, {1}", ascDesc, sort);
-                    break;
-
-                case "year":
-                case "bitrate":
-                case "samplerate":
-                case "bitspersample":
-                case "bpm":
-                case "trackcount":
-                case "disccount":
-                case "duration":
-                case "rating":
-                case "playcount":
-                case "skipcount":
-                case "filesize":
-                case "lastplayedstamp":
-                case "lastskippedstamp":
-                case "dateaddedstamp":
-                case "uri":
-                case "mimetype":
-                case "licenseuri":
-                    sort_query = String.Format (
-                        "CoreTracks.{0} {1}, {2}",
-                        column ?? key, ascDesc, sort
-                    );
-                    break;
-                default:
-                    Hyena.Log.ErrorFormat ("Unknown sort key passed in! {0} not recognized", key);
-                    break;
+
+            if (field.Equals (GroupingField) ||
+                field.Equals (TrackNumberField)) {
+                sort_query = String.Format (@"
+                    CoreAlbums.ArtistNameSortKey ASC,
+                    {0}
+                    CoreAlbums.TitleSortKey ASC,
+                    CoreTracks.Disc ASC,
+                    {1} {2}",
+                    sort_by_year_part, TrackNumberField.Column, ascDesc);
+            }
+
+            else if (field.Equals (AlbumArtistField)) {
+
+                sort_query = String.Format (@"
+                    CoreAlbums.ArtistNameSortKey {0},
+                    {1}
+                    CoreAlbums.TitleSortKey ASC,
+                    CoreTracks.Disc ASC,
+                    CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
+            }
+
+            else if (field.Equals (ArtistField)) {
+
+                sort_query = String.Format (@"
+                    CoreArtists.NameSortKey {0},
+                    {1}
+                    CoreAlbums.TitleSortKey ASC,
+                    CoreTracks.Disc ASC,
+                    CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
+            }
+
+            else if (field.Equals (AlbumField)) {
+                sort_query = String.Format (@"
+                    CoreAlbums.TitleSortKey {0},
+                    {1}
+                    CoreTracks.Disc ASC,
+                    CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
+            }
+
+            else if (field.Equals (TitleField)) {
+                sort_query = String.Format (@"
+                    CoreTracks.TitleSortKey {0},
+                    CoreAlbums.ArtistNameSortKey ASC,
+                    {1}
+                    CoreAlbums.TitleSortKey ASC", ascDesc, sort_by_year_part);
             }
+
+            else if (field.Equals (DiscNumberField)) {
+                sort_query = String.Format (@"
+                    CoreAlbums.ArtistNameSortKey ASC,
+                    {1}
+                    CoreAlbums.TitleSortKey ASC,
+                    CoreTracks.Disc {0},
+                    CoreTracks.TrackNumber ASC", ascDesc, sort_by_year_part);
+            }
+
+            else if (field.Equals (ScoreField)) {
+                sort_query = String.Format (@"
+                    {0} {1},
+                    {2} {1}, {3}",
+                    field.Column, ascDesc, PlayCountField.Column, sort);
+            }
+
+            else if (field.Equals (ComposerField) ||
+                     field.Equals (GenreField)    ||
+                     field.Equals (ComposerField) ||
+                     field.Equals (ConductorField) ||
+                     field.Equals (CommentField)) {
+
+                sort_query = String.Format (
+                    "HYENA_COLLATION_KEY({0}) {1}, {2}",
+                    field.Column, ascDesc, sort
+                );
+            }
+
+            else if (field.Equals (LastPlayedField)    ||
+                     field.Equals (LastSkippedField)   ||
+                     field.Equals (DateAddedField)     ||
+                     field.Equals (YearField)          ||
+                     field.Equals (BitRateField)       ||
+                     field.Equals (SampleRateField)    ||
+                     field.Equals (BitsPerSampleField) ||
+                     field.Equals (BpmField)           ||
+                     field.Equals (TrackCountField)    ||
+                     field.Equals (DiscCountField)     ||
+                     field.Equals (DurationField)      ||
+                     field.Equals (RatingField)        ||
+                     field.Equals (PlayCountField)     ||
+                     field.Equals (SkipCountField)     ||
+                     field.Equals (FileSizeField)      ||
+                     field.Equals (UriField)           ||
+                     field.Equals (MimeTypeField)      ||
+                     field.Equals (LicenseUriField)) {
+                sort_query = String.Format (
+                    "{0} {1}, {2}",
+                    field.Column, ascDesc, sort
+                );
+            }
+
+            else {
+                Hyena.Log.ErrorFormat ("Unknown query field passed in! {0} not recognized", field.Name);
+            }
+
             return sort_query;
         }
 
         private static QueryOrder CreateQueryOrder (string name, bool asc, string label, QueryField field)
         {
-            return new QueryOrder (CreateOrderName (name, asc), label, GetSort (name, asc), field, asc);
+            return new QueryOrder (CreateOrderName (name, asc), label, GetSort (field, asc), field, asc);
+        }
+
+        private static QueryOrder CreateRandomQueryOrder ()
+        {
+            return new QueryOrder (CreateOrderName ("Random", true), Catalog.GetString ("Random"), GetRandomSort (), null, true);
         }
 
         public static QueryLimit FindLimit (string name)
diff --git a/src/Core/Banshee.Services/Banshee.Query/Tests/BansheeQueryTests.cs b/src/Core/Banshee.Services/Banshee.Query/Tests/BansheeQueryTests.cs
index 5346db5..f1e44e1 100644
--- a/src/Core/Banshee.Services/Banshee.Query/Tests/BansheeQueryTests.cs
+++ b/src/Core/Banshee.Services/Banshee.Query/Tests/BansheeQueryTests.cs
@@ -69,8 +69,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAddedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Added", true);
-            AssertAreEquivalent (@"CoreTracks.dateaddedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, true);
+            AssertAreEquivalent (@"CoreTracks.DateAddedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -81,8 +81,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAddedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Added", false);
-            AssertAreEquivalent (@"CoreTracks.dateaddedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, false);
+            AssertAreEquivalent (@"CoreTracks.DateAddedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -93,7 +93,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumArtistAsc ()
         {
-            string sort = BansheeQuery.GetSort ("AlbumArtist", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumArtistField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -104,7 +104,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumArtistDesc ()
         {
-            string sort = BansheeQuery.GetSort ("AlbumArtist", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumArtistField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey DESC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -115,7 +115,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Album", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumField, true);
             AssertAreEquivalent (@"CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
                                    CoreTracks.TrackNumber ASC",
@@ -125,7 +125,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Album", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumField, false);
             AssertAreEquivalent (@"CoreAlbums.TitleSortKey DESC,
                                    CoreTracks.Disc ASC,
                                    CoreTracks.TrackNumber ASC",
@@ -136,7 +136,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForArtistAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Artist", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ArtistField, true);
             AssertAreEquivalent (@"CoreArtists.NameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -147,7 +147,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForArtistDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Artist", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ArtistField, false);
             AssertAreEquivalent (@"CoreArtists.NameSortKey DESC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -158,8 +158,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBpmAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Bpm", true);
-            AssertAreEquivalent (@"CoreTracks.Bpm ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.BpmField, true);
+            AssertAreEquivalent (@"CoreTracks.BPM ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -170,8 +170,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBpmDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Bpm", false);
-            AssertAreEquivalent (@"CoreTracks.Bpm DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.BpmField, false);
+            AssertAreEquivalent (@"CoreTracks.BPM DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -182,7 +182,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitRateAsc ()
         {
-            string sort = BansheeQuery.GetSort ("BitRate", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitRateField, true);
             AssertAreEquivalent (@"CoreTracks.BitRate ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -194,7 +194,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitRateDesc ()
         {
-            string sort = BansheeQuery.GetSort ("BitRate", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitRateField, false);
             AssertAreEquivalent (@"CoreTracks.BitRate DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -206,7 +206,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitsPerSampleAsc ()
         {
-            string sort = BansheeQuery.GetSort ("BitsPerSample", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitsPerSampleField, true);
             AssertAreEquivalent (@"CoreTracks.BitsPerSample ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -218,7 +218,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitsPerSampleDesc ()
         {
-            string sort = BansheeQuery.GetSort ("BitsPerSample", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitsPerSampleField, false);
             AssertAreEquivalent (@"CoreTracks.BitsPerSample DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -230,7 +230,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForCommentAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Comment", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.CommentField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Comment) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -242,7 +242,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForCommentDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Comment", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.CommentField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Comment) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -254,7 +254,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForComposerAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Composer", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ComposerField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Composer) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -266,7 +266,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForComposerDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Composer", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ComposerField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Composer) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -278,7 +278,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForConductorAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Conductor", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ConductorField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Conductor) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -290,7 +290,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForConductorDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Conductor", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ConductorField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Conductor) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -302,7 +302,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDateAddedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("DateAddedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, true);
             AssertAreEquivalent (@"CoreTracks.DateAddedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -314,7 +314,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDateAddedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("DateAddedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, false);
             AssertAreEquivalent (@"CoreTracks.DateAddedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -326,7 +326,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Disc", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscNumberField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -337,7 +337,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Disc", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscNumberField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc DESC,
@@ -348,7 +348,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("DiscCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscCountField, true);
             AssertAreEquivalent (@"CoreTracks.DiscCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -360,7 +360,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("DiscCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscCountField, false);
             AssertAreEquivalent (@"CoreTracks.DiscCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -372,7 +372,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDurationAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Duration", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DurationField, true);
             AssertAreEquivalent (@"CoreTracks.Duration ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -384,7 +384,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDurationDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Duration", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DurationField, false);
             AssertAreEquivalent (@"CoreTracks.Duration DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -396,7 +396,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForFileSizeAsc ()
         {
-            string sort = BansheeQuery.GetSort ("FileSize", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.FileSizeField, true);
             AssertAreEquivalent (@"CoreTracks.FileSize ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -408,7 +408,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForFileSizeDesc ()
         {
-            string sort = BansheeQuery.GetSort ("FileSize", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.FileSizeField, false);
             AssertAreEquivalent (@"CoreTracks.FileSize DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -420,7 +420,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGenreAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Genre", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GenreField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Genre) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -432,7 +432,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGenreDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Genre", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GenreField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Genre) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -444,7 +444,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGroupingAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Grouping", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GroupingField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -455,7 +455,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGroupingDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Grouping", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GroupingField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -466,8 +466,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayed", true);
-            AssertAreEquivalent (@"CoreTracks.LastPlayedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, true);
+            AssertAreEquivalent (@"CoreTracks.LastPlayedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -478,8 +478,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayed", false);
-            AssertAreEquivalent (@"CoreTracks.LastPlayedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, false);
+            AssertAreEquivalent (@"CoreTracks.LastPlayedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -490,7 +490,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, true);
             AssertAreEquivalent (@"CoreTracks.LastPlayedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -502,7 +502,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, false);
             AssertAreEquivalent (@"CoreTracks.LastPlayedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -514,8 +514,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkipped", true);
-            AssertAreEquivalent (@"CoreTracks.LastSkippedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, true);
+            AssertAreEquivalent (@"CoreTracks.LastSkippedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -526,8 +526,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkipped", false);
-            AssertAreEquivalent (@"CoreTracks.LastSkippedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, false);
+            AssertAreEquivalent (@"CoreTracks.LastSkippedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -538,7 +538,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkippedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, true);
             AssertAreEquivalent (@"CoreTracks.LastSkippedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -550,7 +550,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkippedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, false);
             AssertAreEquivalent (@"CoreTracks.LastSkippedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -562,7 +562,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLicenseUriAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LicenseUri", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LicenseUriField, true);
             AssertAreEquivalent (@"CoreTracks.LicenseUri ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -574,7 +574,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLicenseUriDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LicenseUri", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LicenseUriField, false);
             AssertAreEquivalent (@"CoreTracks.LicenseUri DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -586,7 +586,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForMimeTypeAsc ()
         {
-            string sort = BansheeQuery.GetSort ("MimeType", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.MimeTypeField, true);
             AssertAreEquivalent (@"CoreTracks.MimeType ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -598,7 +598,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForMimeTypeDesc ()
         {
-            string sort = BansheeQuery.GetSort ("MimeType", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.MimeTypeField, false);
             AssertAreEquivalent (@"CoreTracks.MimeType DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -610,7 +610,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForPlayCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("PlayCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.PlayCountField, true);
             AssertAreEquivalent (@"CoreTracks.PlayCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -622,7 +622,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForPlayCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("PlayCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.PlayCountField, false);
             AssertAreEquivalent (@"CoreTracks.PlayCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -632,23 +632,16 @@ namespace Banshee.Query.Tests
         }
 
         [Test]
-        public void GetSortForRandomAsc ()
-        {
-            string sort = FullTrim (BansheeQuery.GetSort ("Random", true));
-            AssertAreEquivalent ("RANDOM ()", sort);
-        }
-
-        [Test]
-        public void GetSortForRandomDesc ()
+        public void GetSortForRandom ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Random", false));
+            string sort = FullTrim (BansheeQuery.GetRandomSort ());
             AssertAreEquivalent ("RANDOM ()", sort);
         }
 
         [Test]
         public void GetSortForRatingAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Rating", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.RatingField, true);
             AssertAreEquivalent (@"CoreTracks.Rating ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -660,7 +653,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForRatingDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Rating", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.RatingField, false);
             AssertAreEquivalent (@"CoreTracks.Rating DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -672,7 +665,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSampleRateAsc ()
         {
-            string sort = BansheeQuery.GetSort ("SampleRate", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SampleRateField, true);
             AssertAreEquivalent (@"CoreTracks.SampleRate ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -684,7 +677,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSampleRateDesc ()
         {
-            string sort = BansheeQuery.GetSort ("SampleRate", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SampleRateField, false);
             AssertAreEquivalent (@"CoreTracks.SampleRate DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -697,9 +690,9 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForScoreAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Score", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ScoreField, true);
             AssertAreEquivalent (@"CoreTracks.Score ASC,
-                                   CoreTracks.Playcount ASC,
+                                   CoreTracks.PlayCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -710,9 +703,9 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForScoreDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Score", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ScoreField, false);
             AssertAreEquivalent (@"CoreTracks.Score DESC,
-                                   CoreTracks.Playcount DESC,
+                                   CoreTracks.PlayCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -723,7 +716,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSkipCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("SkipCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SkipCountField, true);
             AssertAreEquivalent (@"CoreTracks.SkipCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -735,7 +728,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSkipCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("SkipCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SkipCountField, false);
             AssertAreEquivalent (@"CoreTracks.SkipCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -747,7 +740,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTitleAsc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Title", true));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TitleField, true));
             AssertAreEquivalent (@"CoreTracks.TitleSortKey ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC",
@@ -757,7 +750,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTitleDesc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Title", false));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TitleField, false));
             AssertAreEquivalent (@"CoreTracks.TitleSortKey DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC",
@@ -767,7 +760,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackAsc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Track", true));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TrackNumberField, true));
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -778,7 +771,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackDesc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Track", false));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TrackNumberField, false));
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Disc ASC,
@@ -789,7 +782,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("TrackCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.TrackCountField, true);
             AssertAreEquivalent (@"CoreTracks.TrackCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -801,7 +794,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("TrackCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.TrackCountField, false);
             AssertAreEquivalent (@"CoreTracks.TrackCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -813,7 +806,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForUriAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Uri", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.UriField, true);
             AssertAreEquivalent (@"CoreTracks.Uri ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -825,7 +818,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForUriDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Uri", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.UriField, false);
             AssertAreEquivalent (@"CoreTracks.Uri DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -837,7 +830,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForYearAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Year", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.YearField, true);
             AssertAreEquivalent (@"CoreTracks.Year ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -849,7 +842,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForYearDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Year", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.YearField, false);
             AssertAreEquivalent (@"CoreTracks.Year DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -861,7 +854,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDefault ()
         {
-            string sort = BansheeQuery.GetSort ("UnknownField", false);
+            string sort = BansheeQuery.GetSort (new UnknownQueryField (), false);
             Assert.IsNull (sort);
         }
 
@@ -890,8 +883,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAddedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Added", true);
-            AssertAreEquivalent (@"CoreTracks.dateaddedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, true);
+            AssertAreEquivalent (@"CoreTracks.DateAddedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -903,8 +896,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAddedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Added", false);
-            AssertAreEquivalent (@"CoreTracks.dateaddedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, false);
+            AssertAreEquivalent (@"CoreTracks.DateAddedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -916,7 +909,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumArtistAsc ()
         {
-            string sort = BansheeQuery.GetSort ("AlbumArtist", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumArtistField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -928,7 +921,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumArtistDesc ()
         {
-            string sort = BansheeQuery.GetSort ("AlbumArtist", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumArtistField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey DESC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -940,7 +933,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Album", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumField, true);
             AssertAreEquivalent (@"CoreAlbums.TitleSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreTracks.Disc ASC,
@@ -951,7 +944,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForAlbumDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Album", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.AlbumField, false);
             AssertAreEquivalent (@"CoreAlbums.TitleSortKey DESC,
                                    CoreTracks.Year ASC,
                                    CoreTracks.Disc ASC,
@@ -963,7 +956,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForArtistAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Artist", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ArtistField, true);
             AssertAreEquivalent (@"CoreArtists.NameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -975,7 +968,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForArtistDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Artist", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ArtistField, false);
             AssertAreEquivalent (@"CoreArtists.NameSortKey DESC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -987,8 +980,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBpmAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Bpm", true);
-            AssertAreEquivalent (@"CoreTracks.Bpm ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.BpmField, true);
+            AssertAreEquivalent (@"CoreTracks.BPM ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1000,8 +993,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBpmDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Bpm", false);
-            AssertAreEquivalent (@"CoreTracks.Bpm DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.BpmField, false);
+            AssertAreEquivalent (@"CoreTracks.BPM DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1013,7 +1006,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitRateAsc ()
         {
-            string sort = BansheeQuery.GetSort ("BitRate", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitRateField, true);
             AssertAreEquivalent (@"CoreTracks.BitRate ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1026,7 +1019,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitRateDesc ()
         {
-            string sort = BansheeQuery.GetSort ("BitRate", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitRateField, false);
             AssertAreEquivalent (@"CoreTracks.BitRate DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1039,7 +1032,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitsPerSampleAsc ()
         {
-            string sort = BansheeQuery.GetSort ("BitsPerSample", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitsPerSampleField, true);
             AssertAreEquivalent (@"CoreTracks.BitsPerSample ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1052,7 +1045,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForBitsPerSampleDesc ()
         {
-            string sort = BansheeQuery.GetSort ("BitsPerSample", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.BitsPerSampleField, false);
             AssertAreEquivalent (@"CoreTracks.BitsPerSample DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1065,7 +1058,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForCommentAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Comment", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.CommentField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Comment) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1078,7 +1071,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForCommentDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Comment", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.CommentField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Comment) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1091,7 +1084,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForComposerAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Composer", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ComposerField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Composer) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1104,7 +1097,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForComposerDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Composer", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ComposerField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Composer) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1117,7 +1110,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForConductorAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Conductor", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ConductorField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Conductor) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1130,7 +1123,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForConductorDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Conductor", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ConductorField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Conductor) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1143,7 +1136,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDateAddedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("DateAddedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, true);
             AssertAreEquivalent (@"CoreTracks.DateAddedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1156,7 +1149,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDateAddedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("DateAddedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DateAddedField, false);
             AssertAreEquivalent (@"CoreTracks.DateAddedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1169,7 +1162,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Disc", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscNumberField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1181,7 +1174,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Disc", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscNumberField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1193,7 +1186,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("DiscCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscCountField, true);
             AssertAreEquivalent (@"CoreTracks.DiscCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1206,7 +1199,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDiscCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("DiscCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DiscCountField, false);
             AssertAreEquivalent (@"CoreTracks.DiscCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1219,7 +1212,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDurationAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Duration", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DurationField, true);
             AssertAreEquivalent (@"CoreTracks.Duration ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1232,7 +1225,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDurationDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Duration", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.DurationField, false);
             AssertAreEquivalent (@"CoreTracks.Duration DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1245,7 +1238,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForFileSizeAsc ()
         {
-            string sort = BansheeQuery.GetSort ("FileSize", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.FileSizeField, true);
             AssertAreEquivalent (@"CoreTracks.FileSize ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1258,7 +1251,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForFileSizeDesc ()
         {
-            string sort = BansheeQuery.GetSort ("FileSize", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.FileSizeField, false);
             AssertAreEquivalent (@"CoreTracks.FileSize DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1271,7 +1264,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGenreAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Genre", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GenreField, true);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Genre) ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1284,7 +1277,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGenreDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Genre", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GenreField, false);
             AssertAreEquivalent (@"HYENA_COLLATION_KEY(CoreTracks.Genre) DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1297,7 +1290,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGroupingAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Grouping", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GroupingField, true);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1309,7 +1302,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForGroupingDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Grouping", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.GroupingField, false);
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1321,8 +1314,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayed", true);
-            AssertAreEquivalent (@"CoreTracks.LastPlayedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, true);
+            AssertAreEquivalent (@"CoreTracks.LastPlayedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1334,8 +1327,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayed", false);
-            AssertAreEquivalent (@"CoreTracks.LastPlayedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, false);
+            AssertAreEquivalent (@"CoreTracks.LastPlayedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1347,7 +1340,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, true);
             AssertAreEquivalent (@"CoreTracks.LastPlayedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1360,7 +1353,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastPlayedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastPlayedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastPlayedField, false);
             AssertAreEquivalent (@"CoreTracks.LastPlayedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1373,8 +1366,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkipped", true);
-            AssertAreEquivalent (@"CoreTracks.LastSkippedstamp ASC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, true);
+            AssertAreEquivalent (@"CoreTracks.LastSkippedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1386,8 +1379,8 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkipped", false);
-            AssertAreEquivalent (@"CoreTracks.LastSkippedstamp DESC,
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, false);
+            AssertAreEquivalent (@"CoreTracks.LastSkippedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1399,7 +1392,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedStampAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkippedStamp", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, true);
             AssertAreEquivalent (@"CoreTracks.LastSkippedStamp ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1412,7 +1405,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLastSkippedStampDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LastSkippedStamp", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LastSkippedField, false);
             AssertAreEquivalent (@"CoreTracks.LastSkippedStamp DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1425,7 +1418,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLicenseUriAsc ()
         {
-            string sort = BansheeQuery.GetSort ("LicenseUri", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LicenseUriField, true);
             AssertAreEquivalent (@"CoreTracks.LicenseUri ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1438,7 +1431,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForLicenseUriDesc ()
         {
-            string sort = BansheeQuery.GetSort ("LicenseUri", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.LicenseUriField, false);
             AssertAreEquivalent (@"CoreTracks.LicenseUri DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1451,7 +1444,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForMimeTypeAsc ()
         {
-            string sort = BansheeQuery.GetSort ("MimeType", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.MimeTypeField, true);
             AssertAreEquivalent (@"CoreTracks.MimeType ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1464,7 +1457,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForMimeTypeDesc ()
         {
-            string sort = BansheeQuery.GetSort ("MimeType", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.MimeTypeField, false);
             AssertAreEquivalent (@"CoreTracks.MimeType DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1477,7 +1470,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForPlayCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("PlayCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.PlayCountField, true);
             AssertAreEquivalent (@"CoreTracks.PlayCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1490,7 +1483,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForPlayCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("PlayCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.PlayCountField, false);
             AssertAreEquivalent (@"CoreTracks.PlayCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1503,21 +1496,14 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForRandomAsc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Random", true));
-            AssertAreEquivalent ("RANDOM ()", sort);
-        }
-
-        [Test]
-        public void GetSortForRandomDesc ()
-        {
-            string sort = FullTrim (BansheeQuery.GetSort ("Random", false));
+            string sort = FullTrim (BansheeQuery.GetRandomSort ());
             AssertAreEquivalent ("RANDOM ()", sort);
         }
 
         [Test]
         public void GetSortForRatingAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Rating", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.RatingField, true);
             AssertAreEquivalent (@"CoreTracks.Rating ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1530,7 +1516,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForRatingDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Rating", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.RatingField, false);
             AssertAreEquivalent (@"CoreTracks.Rating DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1543,7 +1529,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSampleRateAsc ()
         {
-            string sort = BansheeQuery.GetSort ("SampleRate", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SampleRateField, true);
             AssertAreEquivalent (@"CoreTracks.SampleRate ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1556,7 +1542,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSampleRateDesc ()
         {
-            string sort = BansheeQuery.GetSort ("SampleRate", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SampleRateField, false);
             AssertAreEquivalent (@"CoreTracks.SampleRate DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1569,9 +1555,9 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForScoreAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Score", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ScoreField, true);
             AssertAreEquivalent (@"CoreTracks.Score ASC,
-                                   CoreTracks.Playcount ASC,
+                                   CoreTracks.PlayCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1583,9 +1569,9 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForScoreDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Score", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.ScoreField, false);
             AssertAreEquivalent (@"CoreTracks.Score DESC,
-                                   CoreTracks.Playcount DESC,
+                                   CoreTracks.PlayCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1597,7 +1583,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSkipCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("SkipCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SkipCountField, true);
             AssertAreEquivalent (@"CoreTracks.SkipCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1610,7 +1596,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForSkipCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("SkipCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.SkipCountField, false);
             AssertAreEquivalent (@"CoreTracks.SkipCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1623,7 +1609,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTitleAsc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Title", true));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TitleField, true));
             AssertAreEquivalent (@"CoreTracks.TitleSortKey ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1634,7 +1620,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTitleDesc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Title", false));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TitleField, false));
             AssertAreEquivalent (@"CoreTracks.TitleSortKey DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1645,7 +1631,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackAsc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Track", true));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TrackNumberField, true));
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1657,7 +1643,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackDesc ()
         {
-            string sort = FullTrim (BansheeQuery.GetSort ("Track", false));
+            string sort = FullTrim (BansheeQuery.GetSort (BansheeQuery.TrackNumberField, false));
             AssertAreEquivalent (@"CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
                                    CoreAlbums.TitleSortKey ASC,
@@ -1669,7 +1655,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackCountAsc ()
         {
-            string sort = BansheeQuery.GetSort ("TrackCount", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.TrackCountField, true);
             AssertAreEquivalent (@"CoreTracks.TrackCount ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1682,7 +1668,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForTrackCountDesc ()
         {
-            string sort = BansheeQuery.GetSort ("TrackCount", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.TrackCountField, false);
             AssertAreEquivalent (@"CoreTracks.TrackCount DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1695,7 +1681,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForUriAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Uri", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.UriField, true);
             AssertAreEquivalent (@"CoreTracks.Uri ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1708,7 +1694,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForUriDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Uri", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.UriField, false);
             AssertAreEquivalent (@"CoreTracks.Uri DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1721,7 +1707,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForYearAsc ()
         {
-            string sort = BansheeQuery.GetSort ("Year", true);
+            string sort = BansheeQuery.GetSort (BansheeQuery.YearField, true);
             AssertAreEquivalent (@"CoreTracks.Year ASC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1734,7 +1720,7 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForYearDesc ()
         {
-            string sort = BansheeQuery.GetSort ("Year", false);
+            string sort = BansheeQuery.GetSort (BansheeQuery.YearField, false);
             AssertAreEquivalent (@"CoreTracks.Year DESC,
                                    CoreAlbums.ArtistNameSortKey ASC,
                                    CoreTracks.Year ASC,
@@ -1747,12 +1733,19 @@ namespace Banshee.Query.Tests
         [Test]
         public void GetSortForDefault ()
         {
-            string sort = BansheeQuery.GetSort ("UnknownField", false);
+            string sort = BansheeQuery.GetSort (new UnknownQueryField (), false);
             Assert.IsNull (sort);
         }
 
     }
 
+    internal class UnknownQueryField : Hyena.Query.QueryField
+    {
+        internal UnknownQueryField () : base ("UnknownFieldName", null, null, String.Empty)
+        {
+        }
+    }
+
 }
 
 #endif
diff --git a/src/Extensions/Banshee.Audiobook/Banshee.Audiobook/AudiobookLibrarySource.cs b/src/Extensions/Banshee.Audiobook/Banshee.Audiobook/AudiobookLibrarySource.cs
index 0868504..6fae03e 100644
--- a/src/Extensions/Banshee.Audiobook/Banshee.Audiobook/AudiobookLibrarySource.cs
+++ b/src/Extensions/Banshee.Audiobook/Banshee.Audiobook/AudiobookLibrarySource.cs
@@ -131,7 +131,7 @@ namespace Banshee.Audiobook
             TrackIsPlayingHandler = ServiceManager.PlayerEngine.IsPlaying;
 
             PlaybackSource = new BookPlaylist ("audiobook-playback-source", this);
-            PlaybackSource.DatabaseTrackModel.ForcedSortQuery = BansheeQuery.GetSort ("track", true);
+            PlaybackSource.DatabaseTrackModel.ForcedSortQuery = BansheeQuery.GetSort (BansheeQuery.TrackNumberField, true);
 
             ServiceManager.PlaybackController.SourceChanged += OnPlaybackSourceChanged;
 
diff --git a/src/Extensions/Banshee.Podcasting/Banshee.Podcasting.Data/PodcastTrackListModel.cs b/src/Extensions/Banshee.Podcasting/Banshee.Podcasting.Data/PodcastTrackListModel.cs
index ba57431..6af6890 100644
--- a/src/Extensions/Banshee.Podcasting/Banshee.Podcasting.Data/PodcastTrackListModel.cs
+++ b/src/Extensions/Banshee.Podcasting/Banshee.Podcasting.Data/PodcastTrackListModel.cs
@@ -80,9 +80,14 @@ namespace Banshee.Podcasting.Gui
 
         protected override void GenerateSortQueryPart ()
         {
+            bool asc = SortColumn.SortType == Hyena.Data.SortType.Ascending;
             SortQuery = (SortColumn == null)
                 ? GetSort ("PublishedDate", false)
-                : GetSort (SortColumn.SortKey, SortColumn.SortType == Hyena.Data.SortType.Ascending);
+                : GetSort (SortColumn.SortKey, asc);
+
+            if (SortQuery == null) {
+                SortQuery =  Banshee.Query.BansheeQuery.GetSort (SortColumn.Field, asc);
+            }
         }
 
         public override void UpdateUnfilteredAggregates ()
@@ -124,7 +129,7 @@ namespace Banshee.Podcasting.Gui
                     break;
             }
 
-            return sort_query ?? Banshee.Query.BansheeQuery.GetSort (key, asc);
+            return sort_query;
         }
     }
 }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]