diff --git a/include/medialibrary/IAlbum.h b/include/medialibrary/IAlbum.h
index 4196bd9fc40f068875bb4cf4188953d5d402ea1c..1a30e5760f5709de339bfd75de11fa4f689e4406 100644
--- a/include/medialibrary/IAlbum.h
+++ b/include/medialibrary/IAlbum.h
@@ -44,13 +44,13 @@ public:
     /**
      * @brief tracks fetches album tracks from the database
      */
-    virtual Query<IMedia> tracks( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+    virtual Query<IMedia> tracks( const QueryParameters* params = nullptr ) const = 0;
     /**
      * @brief tracks fetches album tracks, filtered by genre
      * @param genre A musical genre. Only tracks of this genre will be returned
      * @return
      */
-    virtual Query<IMedia> tracks( GenrePtr genre, SortingCriteria sort = SortingCriteria::Default, bool desc = false  ) const = 0;
+    virtual Query<IMedia> tracks( GenrePtr genre, const QueryParameters* params = nullptr ) const = 0;
     /**
      * @brief albumArtist Returns the album main artist (generally tagged as album-artist)
      */
diff --git a/include/medialibrary/IArtist.h b/include/medialibrary/IArtist.h
index b41c661fde73f4b846c8affb8dc01932434edf97..25e32ecc9d1bea11c9b99bf5ee68d157f9f79966 100644
--- a/include/medialibrary/IArtist.h
+++ b/include/medialibrary/IArtist.h
@@ -42,8 +42,8 @@ public:
      * This will return all albums by this artist, and all album the artist
      * appeared on, even if they are not the main artist (or AlbumArtist)
      */
-    virtual Query<IAlbum> albums( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
-    virtual Query<IMedia> media( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+    virtual Query<IAlbum> albums( const QueryParameters* params = nullptr ) const = 0;
+    virtual Query<IMedia> media( const QueryParameters* params = nullptr ) const = 0;
     virtual const std::string& artworkMrl() const = 0;
     virtual const std::string& musicBrainzId() const = 0;
     /**
diff --git a/include/medialibrary/IGenre.h b/include/medialibrary/IGenre.h
index 844f1eb3be214dd933fa56ee200af1a8606ba605..0227f2827cf93fa8c1c7cf45b710cec0b3af11e8 100644
--- a/include/medialibrary/IGenre.h
+++ b/include/medialibrary/IGenre.h
@@ -34,9 +34,9 @@ public:
     virtual int64_t id() const = 0;
     virtual const std::string& name() const = 0;
     virtual uint32_t nbTracks() const = 0;
-    virtual Query<IArtist> artists( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
-    virtual Query<IMedia> tracks( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
-    virtual Query<IAlbum> albums( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+    virtual Query<IArtist> artists( const QueryParameters* params = nullptr ) const = 0;
+    virtual Query<IMedia> tracks( const QueryParameters* params = nullptr ) const = 0;
+    virtual Query<IAlbum> albums( const QueryParameters* params = nullptr ) const = 0;
 };
 
 }
diff --git a/include/medialibrary/IMediaLibrary.h b/include/medialibrary/IMediaLibrary.h
index 06637a71c781e553f0f19863ab6b0bfc89724500..aafa51ee0a544279dbca8ac260d6a1d37fa45d51 100644
--- a/include/medialibrary/IMediaLibrary.h
+++ b/include/medialibrary/IMediaLibrary.h
@@ -74,6 +74,13 @@ enum class SortingCriteria
     TrackNumber,
 };
 
+
+struct QueryParameters
+{
+    SortingCriteria sort;
+    bool desc;
+};
+
 enum class InitializeResult
 {
     //< Everything worked out fine
@@ -252,10 +259,10 @@ class IMediaLibrary
         virtual MediaPtr media( int64_t mediaId ) const = 0;
         virtual MediaPtr media( const std::string& mrl ) const = 0;
         virtual MediaPtr addMedia( const std::string& mrl ) = 0;
-        virtual Query<IMedia> audioFiles( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
-        virtual Query<IMedia> videoFiles( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+        virtual Query<IMedia> audioFiles( const QueryParameters* params = nullptr ) const = 0;
+        virtual Query<IMedia> videoFiles( const QueryParameters* params = nullptr ) const = 0;
         virtual AlbumPtr album( int64_t id ) const = 0;
-        virtual Query<IAlbum> albums( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+        virtual Query<IAlbum> albums( const QueryParameters* params = nullptr ) const = 0;
         virtual ShowPtr show( const std::string& name ) const = 0;
         virtual MoviePtr movie( const std::string& title ) const = 0;
         virtual ArtistPtr artist( int64_t id ) const = 0;
@@ -270,20 +277,19 @@ class IMediaLibrary
          * @param desc If true, the provided sorting criteria will be reversed.
          */
         virtual Query<IArtist> artists( bool includeAll,
-                                SortingCriteria sort = SortingCriteria::Default,
-                                bool desc = false ) const = 0;
+                                        const QueryParameters* params = nullptr ) const = 0;
         /**
          * @brief genres Return the list of music genres
          * @param sort A sorting criteria. So far, this is ignored, and artists are sorted by lexial order
          * @param desc If true, the provided sorting criteria will be reversed.
          */
-        virtual Query<IGenre> genres( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+        virtual Query<IGenre> genres( const QueryParameters* params = nullptr ) const = 0;
         virtual GenrePtr genre( int64_t id ) const = 0;
         /***
          *  Playlists
          */
         virtual PlaylistPtr createPlaylist( const std::string& name ) = 0;
-        virtual Query<IPlaylist> playlists( SortingCriteria sort = SortingCriteria::Default, bool desc = false ) = 0;
+        virtual Query<IPlaylist> playlists( const QueryParameters* params = nullptr ) = 0;
         virtual PlaylistPtr playlist( int64_t id ) const = 0;
         virtual bool deletePlaylist( int64_t playlistId ) = 0;
 
@@ -307,21 +313,17 @@ class IMediaLibrary
          * Search
          */
         virtual MediaSearchAggregate searchMedia( const std::string& pattern,
-                                                  SortingCriteria sort = SortingCriteria::Default,
-                                                  bool desc = false ) const = 0;
+                                                   const QueryParameters* params = nullptr ) const = 0;
         virtual Query<IPlaylist> searchPlaylists( const std::string& name,
-                                                          SortingCriteria sort = SortingCriteria::Default,
-                                                          bool desc = false ) const = 0;
+                                                  const QueryParameters* params = nullptr ) const = 0;
         virtual Query<IAlbum> searchAlbums( const std::string& pattern,
-                                                    SortingCriteria sort = SortingCriteria::Default,
-                                                    bool desc = false ) const = 0;
-        virtual Query<IGenre> searchGenre( const std::string& genre, SortingCriteria sort = SortingCriteria::Default, bool desc = false ) const = 0;
+                                            const QueryParameters* params = nullptr ) const = 0;
+        virtual Query<IGenre> searchGenre( const std::string& genre,
+                                           const QueryParameters* params = nullptr ) const = 0;
         virtual Query<IArtist> searchArtists( const std::string& name,
-                                                      SortingCriteria sort = SortingCriteria::Default,
-                                                      bool desc = false ) const = 0;
+                                              const QueryParameters* params = nullptr  ) const = 0;
         virtual SearchAggregate search( const std::string& pattern,
-                                        SortingCriteria sort = SortingCriteria::Default,
-                                        bool desc = false ) const = 0;
+                                        const QueryParameters* params = nullptr ) const = 0;
 
         /**
          * @brief discover Launch a discovery on the provided entry point.
diff --git a/src/Album.cpp b/src/Album.cpp
index 5c16fab88604600c011cf75c8d852401ab29f400..fd5a871078ff0d50aa098f12d883dc09283b6453 100644
--- a/src/Album.cpp
+++ b/src/Album.cpp
@@ -190,9 +190,11 @@ bool Album::setArtworkMrl( const std::string& artworkMrl, Thumbnail::Origin orig
     return true;
 }
 
-std::string Album::orderTracksBy( SortingCriteria sort, bool desc )
+std::string Album::orderTracksBy( const QueryParameters* params = nullptr )
 {
     std::string req = " ORDER BY ";
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     switch ( sort )
     {
     case SortingCriteria::Alpha:
@@ -217,9 +219,11 @@ std::string Album::orderTracksBy( SortingCriteria sort, bool desc )
     return req;
 }
 
-std::string Album::orderBy( SortingCriteria sort, bool desc )
+std::string Album::orderBy( const QueryParameters* params )
 {
     std::string req = " ORDER BY ";
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     switch ( sort )
     {
     case SortingCriteria::ReleaseDate:
@@ -247,18 +251,18 @@ std::string Album::orderBy( SortingCriteria sort, bool desc )
     return req;
 }
 
-Query<IMedia> Album::tracks( SortingCriteria sort, bool desc ) const
+Query<IMedia> Album::tracks( const QueryParameters* params ) const
 {
     // This doesn't return the cached version, because it would be fairly complicated, if not impossible or
     // counter productive, to maintain a cache that respects all orderings.
     std::string req = "FROM " + policy::MediaTable::Name + " med "
         " INNER JOIN " + policy::AlbumTrackTable::Name + " att ON att.media_id = med.id_media "
         " WHERE att.album_id = ? AND med.is_present != 0";
-    req += orderTracksBy( sort, desc );
+    req += orderTracksBy( params );
     return make_query<Media, IMedia>( m_ml, "med.*", std::move( req ), m_id );
 }
 
-Query<IMedia> Album::tracks( GenrePtr genre, SortingCriteria sort, bool desc ) const
+Query<IMedia> Album::tracks( GenrePtr genre, const QueryParameters* params ) const
 {
     if ( genre == nullptr )
         return {};
@@ -266,7 +270,7 @@ Query<IMedia> Album::tracks( GenrePtr genre, SortingCriteria sort, bool desc ) c
             " INNER JOIN " + policy::AlbumTrackTable::Name + " att ON att.media_id = med.id_media "
             " WHERE att.album_id = ? AND med.is_present != 0"
             " AND genre_id = ?";
-    req += orderTracksBy( sort, desc );
+    req += orderTracksBy( params );
     return make_query<Media, IMedia>( m_ml, "med.*", std::move( req ), m_id, genre->id() );
 }
 
@@ -274,7 +278,7 @@ std::vector<MediaPtr> Album::cachedTracks() const
 {
     auto lock = m_tracks.lock();
     if ( m_tracks.isCached() == false )
-        m_tracks = tracks( SortingCriteria::Default, false )->all();
+        m_tracks = tracks( nullptr )->all();
     return m_tracks.get();
 }
 
@@ -493,18 +497,18 @@ std::shared_ptr<Album> Album::createUnknownAlbum( MediaLibraryPtr ml, const Arti
 }
 
 Query<IAlbum> Album::search( MediaLibraryPtr ml, const std::string& pattern,
-                                     SortingCriteria sort, bool desc )
+                             const QueryParameters* params )
 {
     std::string req = "FROM " + policy::AlbumTable::Name + " alb "
             "WHERE id_album IN "
             "(SELECT rowid FROM " + policy::AlbumTable::Name + "Fts WHERE " +
             policy::AlbumTable::Name + "Fts MATCH '*' || ? || '*')"
             "AND is_present != 0";
-    req += orderBy( sort, desc );
+    req += orderBy( params );
     return make_query<Album, IAlbum>( ml, "*", std::move( req ), pattern );
 }
 
-Query<IAlbum> Album::fromArtist( MediaLibraryPtr ml, int64_t artistId, SortingCriteria sort, bool desc )
+Query<IAlbum> Album::fromArtist( MediaLibraryPtr ml, int64_t artistId, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::AlbumTable::Name + " alb "
                     "INNER JOIN " + policy::AlbumTrackTable::Name + " att "
@@ -512,6 +516,8 @@ Query<IAlbum> Album::fromArtist( MediaLibraryPtr ml, int64_t artistId, SortingCr
                     "WHERE (att.artist_id = ? OR alb.artist_id = ?) "
                         "AND att.is_present != 0 "
                     "GROUP BY att.album_id ORDER BY ";
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     switch ( sort )
     {
     case SortingCriteria::Alpha:
@@ -533,17 +539,19 @@ Query<IAlbum> Album::fromArtist( MediaLibraryPtr ml, int64_t artistId, SortingCr
     return make_query<Album, IAlbum>( ml, "*", req, artistId, artistId );
 }
 
-Query<IAlbum> Album::fromGenre( MediaLibraryPtr ml, int64_t genreId, SortingCriteria sort, bool desc)
+Query<IAlbum> Album::fromGenre( MediaLibraryPtr ml, int64_t genreId, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::AlbumTable::Name + " alb "
             "INNER JOIN " + policy::AlbumTrackTable::Name + " att ON att.album_id = alb.id_album "
             "WHERE att.genre_id = ? GROUP BY att.album_id";
-    req += orderBy( sort, desc );
+    req += orderBy( params );
     return make_query<Album, IAlbum>( ml, "alb.*", std::move( req ), genreId );
 }
 
-Query<IAlbum> Album::listAll( MediaLibraryPtr ml, SortingCriteria sort, bool desc )
+Query<IAlbum> Album::listAll( MediaLibraryPtr ml, const QueryParameters* params )
 {
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     if ( sort == SortingCriteria::Artist )
     {
         std::string req = "FROM " + policy::AlbumTable::Name + " alb "
@@ -570,7 +578,7 @@ Query<IAlbum> Album::listAll( MediaLibraryPtr ml, SortingCriteria sort, bool des
     }
     std::string req = "FROM " + policy::AlbumTable::Name + " alb "
                     " WHERE is_present != 0";
-    req += orderBy( sort, desc );
+    req += orderBy( params );
     return make_query<Album, IAlbum>( ml, "*", std::move( req ) );
 }
 
diff --git a/src/Album.h b/src/Album.h
index cd113f2002c6e31fcd161f6a8818b54850866369..713808a4d469745e072b7316e388cea249374a20 100644
--- a/src/Album.h
+++ b/src/Album.h
@@ -76,8 +76,8 @@ class Album : public IAlbum, public DatabaseHelpers<Album, policy::AlbumTable>
         virtual const std::string& artworkMrl() const override;
         std::shared_ptr<Thumbnail> thumbnail();
         bool setArtworkMrl( const std::string& artworkMrl, Thumbnail::Origin origin );
-        virtual Query<IMedia> tracks( SortingCriteria sort, bool desc ) const override;
-        virtual Query<IMedia> tracks( GenrePtr genre, SortingCriteria sort, bool desc ) const override;
+        virtual Query<IMedia> tracks( const QueryParameters* params ) const override;
+        virtual Query<IMedia> tracks( GenrePtr genre, const QueryParameters* params ) const override;
         ///
         /// \brief cachedTracks Returns a cached list of tracks
         /// This has no warranty of ordering, validity, or anything else.
@@ -110,14 +110,14 @@ class Album : public IAlbum, public DatabaseHelpers<Album, policy::AlbumTable>
         /// \return
         ///
         static Query<IAlbum> search( MediaLibraryPtr ml, const std::string& pattern,
-                                             SortingCriteria sort, bool desc );
-        static Query<IAlbum> fromArtist( MediaLibraryPtr ml, int64_t artistId, SortingCriteria sort, bool desc );
-        static Query<IAlbum> fromGenre( MediaLibraryPtr ml, int64_t genreId, SortingCriteria sort, bool desc );
-        static Query<IAlbum> listAll( MediaLibraryPtr ml, SortingCriteria sort, bool desc );
+                                     const QueryParameters* params );
+        static Query<IAlbum> fromArtist( MediaLibraryPtr ml, int64_t artistId, const QueryParameters* params );
+        static Query<IAlbum> fromGenre( MediaLibraryPtr ml, int64_t genreId, const QueryParameters* params );
+        static Query<IAlbum> listAll( MediaLibraryPtr ml, const QueryParameters* params );
 
     private:
-        static std::string orderTracksBy( SortingCriteria sort, bool desc );
-        static std::string orderBy( SortingCriteria sort, bool desc );
+        static std::string orderTracksBy( const QueryParameters* params );
+        static std::string orderBy( const QueryParameters* params );
     protected:
         MediaLibraryPtr m_ml;
         int64_t m_id;
diff --git a/src/AlbumTrack.cpp b/src/AlbumTrack.cpp
index 9ba0f720298d51680835cb661095b1ff7374b56c..d9f5d39fb30d2ad861aa999b86f084dd09a51602 100644
--- a/src/AlbumTrack.cpp
+++ b/src/AlbumTrack.cpp
@@ -149,11 +149,13 @@ AlbumTrackPtr AlbumTrack::fromMedia( MediaLibraryPtr ml, int64_t mediaId )
     return fetch( ml, req, mediaId );
 }
 
-Query<IMedia> AlbumTrack::fromGenre( MediaLibraryPtr ml, int64_t genreId, SortingCriteria sort, bool desc )
+Query<IMedia> AlbumTrack::fromGenre( MediaLibraryPtr ml, int64_t genreId, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::MediaTable::Name + " m"
             " INNER JOIN " + policy::AlbumTrackTable::Name + " t ON m.id_media = t.media_id"
             " WHERE t.genre_id = ? AND m.is_present = 1 ORDER BY ";
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     switch ( sort )
     {
     case SortingCriteria::Duration:
diff --git a/src/AlbumTrack.h b/src/AlbumTrack.h
index 93fa150dadecb235b9a499909d1edba23d39208e..e6ea4dd8e2d6807a71751130f7e3b20ab778694a 100644
--- a/src/AlbumTrack.h
+++ b/src/AlbumTrack.h
@@ -74,7 +74,7 @@ class AlbumTrack : public IAlbumTrack, public DatabaseHelpers<AlbumTrack, policy
                                     unsigned int discNumber, int64_t artistId, int64_t genreId,
                                     int64_t duration );
         static AlbumTrackPtr fromMedia( MediaLibraryPtr ml, int64_t mediaId );
-        static Query<IMedia> fromGenre( MediaLibraryPtr ml, int64_t genreId, SortingCriteria sort, bool desc );
+        static Query<IMedia> fromGenre( MediaLibraryPtr ml, int64_t genreId, const QueryParameters* params );
 
     private:
         MediaLibraryPtr m_ml;
diff --git a/src/Artist.cpp b/src/Artist.cpp
index b731ca7a19708ee5ea56f8d538cfbc897e148499..c159db25f4eda4315119c8e9464224bd13691629 100644
--- a/src/Artist.cpp
+++ b/src/Artist.cpp
@@ -88,15 +88,17 @@ bool Artist::setShortBio(const std::string& shortBio)
     return true;
 }
 
-Query<IAlbum> Artist::albums( SortingCriteria sort, bool desc ) const
+Query<IAlbum> Artist::albums( const QueryParameters* params ) const
 {
-    return Album::fromArtist( m_ml, m_id, sort, desc );
+    return Album::fromArtist( m_ml, m_id, params );
 }
 
-Query<IMedia> Artist::media( SortingCriteria sort, bool desc ) const
+Query<IMedia> Artist::media( const QueryParameters* params ) const
 {
     std::string req = "FROM " + policy::MediaTable::Name + " med ";
 
+    SortingCriteria sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    bool desc = params != nullptr ? params->desc : false;
     // Various artist is a special artist that doesn't have tracks per-se.
     // Rather, it's a virtual artist for albums with many artist but no declared
     // album artist. When listing its tracks, we need to list those by albums
@@ -402,17 +404,17 @@ std::shared_ptr<Artist> Artist::create( MediaLibraryPtr ml, const std::string& n
 }
 
 Query<IArtist> Artist::search( MediaLibraryPtr ml, const std::string& name,
-                                       SortingCriteria sort, bool desc )
+                               const QueryParameters* params )
 {
     std::string req = "FROM " + policy::ArtistTable::Name + " WHERE id_artist IN "
             "(SELECT rowid FROM " + policy::ArtistTable::Name + "Fts WHERE name MATCH '*' || ? || '*')"
             "AND is_present != 0";
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Artist, IArtist>( ml, "*", std::move( req ), name );
 }
 
 Query<IArtist> Artist::listAll( MediaLibraryPtr ml, bool includeAll,
-                                        SortingCriteria sort, bool desc)
+                                const QueryParameters* params )
 {
     std::string req = "FROM " + policy::ArtistTable::Name + " WHERE ";
     if ( includeAll == true )
@@ -421,19 +423,14 @@ Query<IArtist> Artist::listAll( MediaLibraryPtr ml, bool includeAll,
         req += "nb_albums > 0";
 
     req += " AND is_present != 0";
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Artist, IArtist>( ml, "*", std::move( req ) );
 }
 
-std::string Artist::sortRequest( SortingCriteria sort, bool desc )
+std::string Artist::sortRequest( const QueryParameters* params )
 {
-    std::string req = " ORDER BY ";
-    switch ( sort )
-    {
-    default:
-        req += "name";
-    }
-    if ( desc == true )
+    std::string req = " ORDER BY name";
+    if ( params != nullptr && params->desc == true )
         req +=  " DESC";
     return req;
 }
diff --git a/src/Artist.h b/src/Artist.h
index 6f61e5f2ccdccdd3a4aac96cd21612a8d6bf042c..1fb24c5f41ab0d0962eefa090bb872399fff5024 100644
--- a/src/Artist.h
+++ b/src/Artist.h
@@ -55,8 +55,8 @@ public:
     virtual const std::string& name() const override;
     virtual const std::string& shortBio() const override;
     bool setShortBio( const std::string& shortBio );
-    virtual Query<IAlbum> albums( SortingCriteria sort, bool desc ) const override;
-    virtual Query<IMedia> media(SortingCriteria sort, bool desc) const override;
+    virtual Query<IAlbum> albums( const QueryParameters* params ) const override;
+    virtual Query<IMedia> media( const QueryParameters* params ) const override;
     bool addMedia( Media& media );
     virtual const std::string& artworkMrl() const override;
     std::shared_ptr<Thumbnail> thumbnail();
@@ -74,12 +74,12 @@ public:
     static bool createDefaultArtists( sqlite::Connection* dbConnection );
     static std::shared_ptr<Artist> create( MediaLibraryPtr ml, const std::string& name );
     static Query<IArtist> search( MediaLibraryPtr ml, const std::string& name,
-                                          SortingCriteria sort, bool desc );
+                                           const QueryParameters* params );
     static Query<IArtist> listAll( MediaLibraryPtr ml, bool includeAll,
-                                           SortingCriteria sort, bool desc );
+                                   const QueryParameters* params );
 
 private:
-    static std::string sortRequest( SortingCriteria sort, bool desc );
+    static std::string sortRequest( const QueryParameters* params );
 
 private:
     MediaLibraryPtr m_ml;
diff --git a/src/Genre.cpp b/src/Genre.cpp
index d5185d8fbb68cc0b9ea014a94e49754d07d3aa55..84861ac3445dda962037a432f1668c702eeb7513 100644
--- a/src/Genre.cpp
+++ b/src/Genre.cpp
@@ -77,25 +77,25 @@ void Genre::updateCachedNbTracks( int increment )
     m_nbTracks += increment;
 }
 
-Query<IArtist> Genre::artists( SortingCriteria, bool desc ) const
+Query<IArtist> Genre::artists( const QueryParameters* params ) const
 {
     std::string req = "FROM " + policy::ArtistTable::Name + " a "
             "INNER JOIN " + policy::AlbumTrackTable::Name + " att ON att.artist_id = a.id_artist "
             "WHERE att.genre_id = ? GROUP BY att.artist_id"
             " ORDER BY a.name";
-    if ( desc == true )
+    if ( params != nullptr && params->desc == true )
         req += " DESC";
     return make_query<Artist, IArtist>( m_ml, "a.*", std::move( req ), m_id );
 }
 
-Query<IMedia> Genre::tracks( SortingCriteria sort, bool desc ) const
+Query<IMedia> Genre::tracks( const QueryParameters* params ) const
 {
-    return AlbumTrack::fromGenre( m_ml, m_id, sort, desc );
+    return AlbumTrack::fromGenre( m_ml, m_id, params );
 }
 
-Query<IAlbum> Genre::albums( SortingCriteria sort, bool desc ) const
+Query<IAlbum> Genre::albums( const QueryParameters* params ) const
 {
-    return Album::fromGenre( m_ml, m_id, sort, desc );
+    return Album::fromGenre( m_ml, m_id, params );
 }
 
 void Genre::createTable( sqlite::Connection* dbConn )
@@ -171,19 +171,20 @@ std::shared_ptr<Genre> Genre::fromName( MediaLibraryPtr ml, const std::string& n
     return fetch( ml, req, name );
 }
 
-Query<IGenre> Genre::search( MediaLibraryPtr ml, const std::string& name, SortingCriteria sort, bool desc )
+Query<IGenre> Genre::search( MediaLibraryPtr ml, const std::string& name,
+                             const QueryParameters* params )
 {
     std::string req = "FROM " + policy::GenreTable::Name + " WHERE id_genre IN "
             "(SELECT rowid FROM " + policy::GenreTable::Name + "Fts WHERE name MATCH '*' || ? || '*') ORDER BY name";
-    if ( desc == true )
+    if ( params != nullptr && params->desc == true )
         req += " DESC";
     return make_query<Genre, IGenre>( ml, "*", req, name );
 }
 
-Query<IGenre> Genre::listAll( MediaLibraryPtr ml, SortingCriteria, bool desc )
+Query<IGenre> Genre::listAll( MediaLibraryPtr ml, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::GenreTable::Name + " ORDER BY name";
-    if ( desc == true )
+    if ( params != nullptr && params->desc == true )
         req += " DESC";
     return make_query<Genre, IGenre>( ml, "*", std::move( req ) );
 }
diff --git a/src/Genre.h b/src/Genre.h
index 2dfa3b813bc07dc72007b39b6777dd30144da573..a6d5c05bc7fc5f506a3e111b151bfe44693f7df2 100644
--- a/src/Genre.h
+++ b/src/Genre.h
@@ -50,16 +50,16 @@ public:
     virtual const std::string& name() const override;
     virtual uint32_t nbTracks() const override;
     void updateCachedNbTracks( int increment );
-    virtual Query<IArtist> artists( SortingCriteria sort, bool desc ) const override;
-    virtual Query<IMedia> tracks(SortingCriteria sort, bool desc) const override;
-    virtual Query<IAlbum> albums( SortingCriteria sort, bool desc ) const override;
+    virtual Query<IArtist> artists( const QueryParameters* params ) const override;
+    virtual Query<IMedia> tracks( const QueryParameters* params ) const override;
+    virtual Query<IAlbum> albums( const QueryParameters* params ) const override;
 
     static void createTable( sqlite::Connection* dbConn );
     static void createTriggers( sqlite::Connection* dbConn );
     static std::shared_ptr<Genre> create( MediaLibraryPtr ml, const std::string& name );
     static std::shared_ptr<Genre> fromName( MediaLibraryPtr ml, const std::string& name );
-    static Query<IGenre> search( MediaLibraryPtr ml, const std::string& name, SortingCriteria sort, bool desc );
-    static Query<IGenre> listAll( MediaLibraryPtr ml, SortingCriteria sort, bool desc );
+    static Query<IGenre> search( MediaLibraryPtr ml, const std::string& name, const QueryParameters* params );
+    static Query<IGenre> listAll( MediaLibraryPtr ml, const QueryParameters* params );
 
 private:
     MediaLibraryPtr m_ml;
diff --git a/src/Media.cpp b/src/Media.cpp
index a501689d573efd1acd72017c93d4e75d668b2fdc..683c9413c7a6885e40441df9bab6eb0aab107d0f 100644
--- a/src/Media.cpp
+++ b/src/Media.cpp
@@ -467,10 +467,12 @@ void Media::removeFile( File& file )
     }));
 }
 
-std::string Media::sortRequest( SortingCriteria sort, bool desc )
+std::string Media::sortRequest( const QueryParameters* params )
 {
     std::string req = " ORDER BY ";
 
+    auto sort = params != nullptr ? params->sort : SortingCriteria::Default;
+    auto desc = params != nullptr ? params->desc : false;
     switch ( sort )
     {
     case SortingCriteria::Duration:
@@ -505,7 +507,7 @@ std::string Media::sortRequest( SortingCriteria sort, bool desc )
 }
 
 Query<IMedia> Media::listAll( MediaLibraryPtr ml, IMedia::Type type,
-                                      SortingCriteria sort, bool desc )
+                              const QueryParameters* params )
 {
     std::string req = "FROM " + policy::MediaTable::Name + " m INNER JOIN "
             + policy::FileTable::Name + " f ON m.id_media = f.media_id"
@@ -513,7 +515,7 @@ Query<IMedia> Media::listAll( MediaLibraryPtr ml, IMedia::Type type,
             " AND f.type = ?"
             " AND f.is_present != 0";
 
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Media, IMedia>( ml, "m.*", std::move( req ),
                                       type, IFile::Type::Main );
 }
@@ -720,7 +722,7 @@ bool Media::removeLabel( LabelPtr label )
 }
 
 Query<IMedia> Media::search( MediaLibraryPtr ml, const std::string& title,
-                             Media::SubType subType, SortingCriteria sort, bool desc )
+                             Media::SubType subType, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::MediaTable::Name + " m "
             " INNER JOIN " + policy::FileTable::Name + " f ON m.id_media = f.media_id"
@@ -730,7 +732,7 @@ Query<IMedia> Media::search( MediaLibraryPtr ml, const std::string& title,
             " AND f.is_present = 1"
             " AND f.type = ?"
             " AND m.subtype = ?";
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Media, IMedia>( ml, "m.*", req, title, File::Type::Main, subType );
 }
 
diff --git a/src/Media.h b/src/Media.h
index 92bad275346745a235eb8441b6ea5692e73f7c9c..fb92f66c9eeedcb251cae4c85296ddd5ff730d50 100644
--- a/src/Media.h
+++ b/src/Media.h
@@ -143,17 +143,16 @@ class Media : public IMedia, public DatabaseHelpers<Media, policy::MediaTable>
         virtual FilePtr addExternalMrl( const std::string& mrl, IFile::Type type ) override;
         void removeFile( File& file );
 
-        static Query<IMedia> listAll(MediaLibraryPtr ml, Type type, SortingCriteria sort, bool desc);
+        static Query<IMedia> listAll(MediaLibraryPtr ml, Type type, const QueryParameters* params );
 
         static Query<IMedia> search( MediaLibraryPtr ml, const std::string& title,
-                                         Media::SubType subType, SortingCriteria sort,
-                                         bool desc );
+                                     Media::SubType subType, const QueryParameters* params );
         static Query<IMedia> fetchHistory( MediaLibraryPtr ml );
 
         static void clearHistory( MediaLibraryPtr ml );
 
 private:
-        static std::string sortRequest( SortingCriteria sort, bool desc );
+        static std::string sortRequest( const QueryParameters* params );
 
 private:
         MediaLibraryPtr m_ml;
diff --git a/src/MediaLibrary.cpp b/src/MediaLibrary.cpp
index d1608db330b0c426c3a4e483eba19ee198686905..a749158f600d1e1f615934d6d183032054d7608c 100644
--- a/src/MediaLibrary.cpp
+++ b/src/MediaLibrary.cpp
@@ -445,14 +445,14 @@ MediaPtr MediaLibrary::addMedia( const std::string& mrl )
     }
 }
 
-Query<IMedia> MediaLibrary::audioFiles( SortingCriteria sort, bool desc ) const
+Query<IMedia> MediaLibrary::audioFiles( const QueryParameters* params ) const
 {
-    return Media::listAll( this, IMedia::Type::Audio, sort, desc );
+    return Media::listAll( this, IMedia::Type::Audio, params );
 }
 
-Query<IMedia> MediaLibrary::videoFiles( SortingCriteria sort, bool desc ) const
+Query<IMedia> MediaLibrary::videoFiles( const QueryParameters* params ) const
 {
-    return Media::listAll( this, IMedia::Type::Video, sort, desc );
+    return Media::listAll( this, IMedia::Type::Video, params );
 }
 
 bool MediaLibrary::isExtensionSupported( const char* ext )
@@ -544,14 +544,14 @@ std::shared_ptr<Album> MediaLibrary::createAlbum( const std::string& title, int6
     return Album::create( this, title, thumbnailId );
 }
 
-Query<IAlbum> MediaLibrary::albums( SortingCriteria sort, bool desc ) const
+Query<IAlbum> MediaLibrary::albums( const QueryParameters* params ) const
 {
-    return Album::listAll( this, sort, desc );
+    return Album::listAll( this, params );
 }
 
-Query<IGenre> MediaLibrary::genres( SortingCriteria sort, bool desc ) const
+Query<IGenre> MediaLibrary::genres( const QueryParameters* params ) const
 {
-    return Genre::listAll( this, sort, desc );
+    return Genre::listAll( this, params );
 }
 
 GenrePtr MediaLibrary::genre( int64_t id ) const
@@ -611,10 +611,9 @@ std::shared_ptr<Artist> MediaLibrary::createArtist( const std::string& name )
     }
 }
 
-Query<IArtist> MediaLibrary::artists( bool includeAll, SortingCriteria sort,
-                                      bool desc ) const
+Query<IArtist> MediaLibrary::artists( bool includeAll, const QueryParameters* params ) const
 {
-    return Artist::listAll( this, includeAll, sort, desc );
+    return Artist::listAll( this, includeAll, params );
 }
 
 PlaylistPtr MediaLibrary::createPlaylist( const std::string& name )
@@ -630,9 +629,9 @@ PlaylistPtr MediaLibrary::createPlaylist( const std::string& name )
     }
 }
 
-Query<IPlaylist> MediaLibrary::playlists( SortingCriteria sort, bool desc )
+Query<IPlaylist> MediaLibrary::playlists( const QueryParameters* params )
 {
-    return Playlist::listAll( this, sort, desc );
+    return Playlist::listAll( this, params );
 }
 
 PlaylistPtr MediaLibrary::playlist( int64_t id ) const
@@ -696,64 +695,63 @@ bool MediaLibrary::clearHistory()
 }
 
 MediaSearchAggregate MediaLibrary::searchMedia( const std::string& title,
-                                                SortingCriteria sort, bool desc ) const
+                                                const QueryParameters* params ) const
 {
     if ( validateSearchPattern( title ) == false )
         return {};
     MediaSearchAggregate res;
     res.episodes = Media::search( this, title, IMedia::SubType::ShowEpisode,
-                                sort, desc );
+                                params );
     res.movies = Media::search( this, title, IMedia::SubType::Movie,
-                                sort, desc );
+                                params );
     res.others = Media::search( this, title, IMedia::SubType::Unknown,
-                                sort, desc );
+                                params );
     res.tracks = Media::search( this, title, IMedia::SubType::AlbumTrack,
-                                sort, desc );
+                                params );
     return res;
 }
 
 Query<IPlaylist> MediaLibrary::searchPlaylists( const std::string& name,
-                                                        SortingCriteria sort,
-                                                        bool desc ) const
+                                                const QueryParameters* params ) const
 {
     if ( validateSearchPattern( name ) == false )
         return {};
-    return Playlist::search( this, name, sort, desc );
+    return Playlist::search( this, name, params );
 }
 
 Query<IAlbum> MediaLibrary::searchAlbums( const std::string& pattern,
-                                                  SortingCriteria sort, bool desc ) const
+                                          const QueryParameters* params ) const
 {
     if ( validateSearchPattern( pattern ) == false )
         return {};
-    return Album::search( this, pattern, sort, desc );
+    return Album::search( this, pattern, params );
 }
 
-Query<IGenre> MediaLibrary::searchGenre( const std::string& genre, SortingCriteria sort, bool desc ) const
+Query<IGenre> MediaLibrary::searchGenre( const std::string& genre,
+                                         const QueryParameters* params ) const
 {
     if ( validateSearchPattern( genre ) == false )
         return {};
-    return Genre::search( this, genre, sort, desc );
+    return Genre::search( this, genre, params );
 }
 
 Query<IArtist> MediaLibrary::searchArtists( const std::string& name,
-                                                    SortingCriteria sort,
-                                                    bool desc ) const
+                                            const QueryParameters* params ) const
 {
     if ( validateSearchPattern( name ) == false )
         return {};
-    return Artist::search( this, name, sort, desc );
+    return Artist::search( this, name, params );
 }
 
 SearchAggregate MediaLibrary::search( const std::string& pattern,
-                                      SortingCriteria sort, bool desc ) const
+                                      const QueryParameters* params ) const
 {
     SearchAggregate res;
-    res.albums = searchAlbums( pattern, sort, desc );
-    res.artists = searchArtists( pattern, sort, desc );
-    res.genres = searchGenre( pattern, sort, desc );
-    res.media = searchMedia( pattern, sort, desc );
-    res.playlists = searchPlaylists( pattern, sort, desc );
+    res.albums = searchAlbums( pattern, params );
+    res.artists = searchArtists( pattern, params );
+    res.genres = searchGenre( pattern, params );
+    res.media = searchMedia( pattern, params );
+    res.playlists = searchPlaylists( pattern, params );
     return res;
 }
 
diff --git a/src/MediaLibrary.h b/src/MediaLibrary.h
index 03d9a0d7af0d42e01734e172df7d763207ab78b6..ae416fcefd2685d8c55a4ba75225d2005304ec4f 100644
--- a/src/MediaLibrary.h
+++ b/src/MediaLibrary.h
@@ -73,8 +73,8 @@ class MediaLibrary : public IMediaLibrary, public IDeviceListerCb
         virtual MediaPtr media( int64_t mediaId ) const override;
         virtual MediaPtr media( const std::string& path ) const override;
         virtual MediaPtr addMedia( const std::string& mrl ) override;
-        virtual Query<IMedia> audioFiles( SortingCriteria sort, bool desc) const override;
-        virtual Query<IMedia> videoFiles( SortingCriteria sort, bool desc) const override;
+        virtual Query<IMedia> audioFiles( const QueryParameters* params ) const override;
+        virtual Query<IMedia> videoFiles( const QueryParameters* params ) const override;
 
         virtual void addDiscoveredFile( std::shared_ptr<fs::IFile> fileFs,
                                         std::shared_ptr<Folder> parentFolder,
@@ -88,9 +88,9 @@ class MediaLibrary : public IMediaLibrary, public IDeviceListerCb
 
         virtual AlbumPtr album( int64_t id ) const override;
         std::shared_ptr<Album> createAlbum( const std::string& title, int64_t thumbnailId );
-        virtual Query<IAlbum> albums(SortingCriteria sort, bool desc) const override;
+        virtual Query<IAlbum> albums( const QueryParameters* params ) const override;
 
-        virtual Query<IGenre> genres( SortingCriteria sort, bool desc ) const override;
+        virtual Query<IGenre> genres( const QueryParameters* params ) const override;
         virtual GenrePtr genre( int64_t id ) const override;
 
         virtual ShowPtr show( const std::string& name ) const override;
@@ -103,11 +103,10 @@ class MediaLibrary : public IMediaLibrary, public IDeviceListerCb
         ArtistPtr artist( const std::string& name );
         std::shared_ptr<Artist> createArtist( const std::string& name );
         virtual Query<IArtist> artists( bool includeAll,
-                                                SortingCriteria sort,
-                                                bool desc ) const override;
+                                        const QueryParameters* params ) const override;
 
         virtual PlaylistPtr createPlaylist( const std::string& name ) override;
-        virtual Query<IPlaylist> playlists( SortingCriteria sort, bool desc ) override;
+        virtual Query<IPlaylist> playlists( const QueryParameters* params ) override;
         virtual PlaylistPtr playlist( int64_t id ) const override;
         virtual bool deletePlaylist( int64_t playlistId ) override;
 
@@ -117,21 +116,17 @@ class MediaLibrary : public IMediaLibrary, public IDeviceListerCb
         virtual bool clearHistory() override;
 
         virtual MediaSearchAggregate searchMedia( const std::string& title,
-                                                  SortingCriteria sort, bool desc ) const override;
+                                                  const QueryParameters* params ) const override;
         virtual Query<IPlaylist> searchPlaylists( const std::string& name,
-                                                          SortingCriteria sort,
-                                                          bool desc ) const override;
+                                                  const QueryParameters* params ) const override;
         virtual Query<IAlbum> searchAlbums( const std::string& pattern,
-                                                    SortingCriteria sort,
-                                                    bool desc ) const override;
+                                            const QueryParameters* params ) const override;
         virtual Query<IGenre> searchGenre( const std::string& genre,
-                                                    SortingCriteria sort,
-                                                    bool desc ) const override;
+                                           const QueryParameters* params ) const override;
         virtual Query<IArtist> searchArtists( const std::string& name,
-                                                      SortingCriteria sort,
-                                                      bool desc ) const override;
+                                              const QueryParameters* params ) const override;
         virtual SearchAggregate search( const std::string& pattern,
-                                        SortingCriteria sort, bool desc ) const override;
+                                        const QueryParameters* params ) const override;
 
         virtual void discover( const std::string& entryPoint ) override;
         virtual bool setDiscoverNetworkEnabled( bool enabled ) override;
diff --git a/src/Playlist.cpp b/src/Playlist.cpp
index 6b315b4e77cd9a2aa379ab110da71ea3ab7ee3b2..fb8b1d9a8fa0f590e3d2ec06d70f64d20f93ba46 100644
--- a/src/Playlist.cpp
+++ b/src/Playlist.cpp
@@ -253,18 +253,18 @@ void Playlist::createTriggers( sqlite::Connection* dbConn )
 }
 
 Query<IPlaylist> Playlist::search( MediaLibraryPtr ml, const std::string& name,
-                                           SortingCriteria sort, bool desc )
+                                   const QueryParameters* params )
 {
     std::string req = "FROM " + policy::PlaylistTable::Name + " WHERE id_playlist IN "
             "(SELECT rowid FROM " + policy::PlaylistTable::Name + "Fts WHERE name MATCH '*' || ? || '*')";
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Playlist, IPlaylist>( ml, "*", req, name );
 }
 
-Query<IPlaylist> Playlist::listAll( MediaLibraryPtr ml, SortingCriteria sort, bool desc )
+Query<IPlaylist> Playlist::listAll( MediaLibraryPtr ml, const QueryParameters* params )
 {
     std::string req = "FROM " + policy::PlaylistTable::Name;
-    req += sortRequest( sort, desc );
+    req += sortRequest( params );
     return make_query<Playlist, IPlaylist>( ml, "*", req );
 }
 
@@ -280,9 +280,10 @@ void Playlist::clearExternalPlaylistContent(MediaLibraryPtr ml)
     sqlite::Tools::executeDelete( ml->getConn(), req );
 }
 
-std::string Playlist::sortRequest( SortingCriteria sort, bool desc )
+std::string Playlist::sortRequest( const QueryParameters* params )
 {
     std::string req = " ORDER BY ";
+    SortingCriteria sort = params != nullptr ? params->sort : SortingCriteria::Default;
     switch ( sort )
     {
     case SortingCriteria::InsertionDate:
@@ -292,7 +293,7 @@ std::string Playlist::sortRequest( SortingCriteria sort, bool desc )
         req += "name";
         break;
     }
-    if ( desc == true )
+    if ( params != nullptr && params->desc == true )
         req += " DESC";
     return req;
 }
diff --git a/src/Playlist.h b/src/Playlist.h
index 976a7f0573929ca8aa722fca49aaeceed244f28e..0e39f91491c7aba6a780c3881cb696e43c51e3c6 100644
--- a/src/Playlist.h
+++ b/src/Playlist.h
@@ -68,8 +68,8 @@ public:
     static void createTable( sqlite::Connection* dbConn );
     static void createTriggers( sqlite::Connection* dbConn );
     static Query<IPlaylist> search( MediaLibraryPtr ml, const std::string& name,
-                                            SortingCriteria sort, bool desc );
-    static Query<IPlaylist> listAll( MediaLibraryPtr ml, SortingCriteria sort, bool desc );
+                                    const QueryParameters* params );
+    static Query<IPlaylist> listAll( MediaLibraryPtr ml, const QueryParameters* params );
 
     /**
      * @brief deleteAllExternal Delete all external playlists, ie. all playlist
@@ -79,7 +79,7 @@ public:
     static void clearExternalPlaylistContent( MediaLibraryPtr ml );
 
 private:
-    static std::string sortRequest( SortingCriteria sort, bool desc );
+    static std::string sortRequest( const QueryParameters* params );
 
 private:
     MediaLibraryPtr m_ml;
diff --git a/test/samples/Tester.cpp b/test/samples/Tester.cpp
index 56233c57fd35debb7b8b33c6e8e134f954b4c9c6..218cc81104cce776d6727e320307d1bf733bc313 100644
--- a/test/samples/Tester.cpp
+++ b/test/samples/Tester.cpp
@@ -182,32 +182,32 @@ void Tests::runChecks(const rapidjson::Document& doc)
 
     if ( expected.HasMember( "albums" ) == true )
     {
-        checkAlbums( expected["albums" ], m_ml->albums( SortingCriteria::Default, false )->all() );
+        checkAlbums( expected["albums" ], m_ml->albums( nullptr )->all() );
     }
     if ( expected.HasMember( "media" ) == true )
         checkMedias( expected["media"] );
     if ( expected.HasMember( "nbVideos" ) == true )
     {
-        const auto videos = m_ml->videoFiles( SortingCriteria::Default, false )->all();
+        const auto videos = m_ml->videoFiles( nullptr )->all();
         ASSERT_EQ( expected["nbVideos"].GetUint(), videos.size() );
     }
     if ( expected.HasMember( "nbAudios" ) == true )
     {
-        const auto audios = m_ml->audioFiles( SortingCriteria::Default, false )->all();
+        const auto audios = m_ml->audioFiles( nullptr )->all();
         ASSERT_EQ( expected["nbAudios"].GetUint(), audios.size() );
     }
     if ( expected.HasMember( "nbPlaylists" ) == true )
     {
-        const auto playlists = m_ml->playlists( SortingCriteria::Default, false )->all();
+        const auto playlists = m_ml->playlists( nullptr )->all();
         ASSERT_EQ( expected["nbPlaylists"].GetUint(), playlists.size() );
     }
     if ( expected.HasMember( "playlists" ) == true )
     {
-      checkPlaylists( expected["playlists"], m_ml->playlists( SortingCriteria::Default, false )->all() );
+      checkPlaylists( expected["playlists"], m_ml->playlists( nullptr )->all() );
     }
     if ( expected.HasMember( "artists" ) )
     {
-        checkArtists( expected["artists"], m_ml->artists( true, SortingCriteria::Default, false )->all() );
+        checkArtists( expected["artists"], m_ml->artists( true, nullptr )->all() );
     }
 }
 
@@ -272,8 +272,8 @@ void Tests::checkAudioTracks(const rapidjson::Value& expectedTracks, const std::
 void Tests::checkMedias(const rapidjson::Value& expectedMedias)
 {
     ASSERT_TRUE( expectedMedias.IsArray() );
-    auto medias = m_ml->audioFiles( SortingCriteria::Default, false )->all();
-    auto videos = m_ml->videoFiles( SortingCriteria::Default, false )->all();
+    auto medias = m_ml->audioFiles( nullptr )->all();
+    auto videos = m_ml->videoFiles( nullptr )->all();
     medias.insert( begin( medias ), begin( videos ), end( videos ) );
     for ( auto i = 0u; i < expectedMedias.Size(); ++i )
     {
@@ -402,7 +402,7 @@ void Tests::checkAlbums( const rapidjson::Value& expectedAlbums, std::vector<Alb
             }
             if ( expectedAlbum.HasMember( "nbTracks" ) || expectedAlbum.HasMember( "tracks" ) )
             {
-                const auto tracks = a->tracks( SortingCriteria::Default, false )->all();
+                const auto tracks = a->tracks( nullptr )->all();
                 if ( expectedAlbum.HasMember( "nbTracks" ) )
                 {
                     if ( expectedAlbum["nbTracks"].GetUint() != tracks.size() )
@@ -460,13 +460,13 @@ void Tests::checkArtists(const rapidjson::Value& expectedArtists, std::vector<Ar
             }
             if ( expectedArtist.HasMember( "albums" ) )
             {
-                auto albums = artist->albums( SortingCriteria::Default, false )->all();
+                auto albums = artist->albums( nullptr )->all();
                 checkAlbums( expectedArtist["albums"], albums );
             }
             if ( expectedArtist.HasMember( "nbTracks" ) )
             {
                 auto expectedNbTracks = expectedArtist["nbTracks"].GetUint();
-                auto tracks = artist->media( SortingCriteria::Default, false )->all();
+                auto tracks = artist->media( nullptr )->all();
                 if ( expectedNbTracks != tracks.size() )
                     return false;
                 if ( expectedNbTracks != artist->nbTracks() )
diff --git a/test/unittest/AlbumTests.cpp b/test/unittest/AlbumTests.cpp
index a5982239d33c42a28b4b673d4ac98d8018fd8536..92f04353cb5bdd162b3e44b0190765898aa0e55a 100644
--- a/test/unittest/AlbumTests.cpp
+++ b/test/unittest/AlbumTests.cpp
@@ -69,13 +69,13 @@ TEST_F( Albums, AddTrack )
     f->save();
     ASSERT_NE( track, nullptr );
 
-    auto tracks = a->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( tracks.size(), 1u );
 
     Reload();
 
     a = std::static_pointer_cast<Album>( ml->album( a->id() ) );
-    tracks = a->tracks( SortingCriteria::Default, false )->all();
+    tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( tracks.size(), 1u );
     ASSERT_EQ( tracks[0]->albumTrack()->trackNumber(), track->trackNumber() );
 }
@@ -90,13 +90,13 @@ TEST_F( Albums, NbTracks )
         f->save();
         ASSERT_NE( track, nullptr );
     }
-    auto tracks = a->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( tracks.size(), a->nbTracks() );
 
     Reload();
 
     a = std::static_pointer_cast<Album>( ml->album( a->id() ) );
-    tracks = a->tracks( SortingCriteria::Default, false )->all();
+    tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( tracks.size(), a->nbTracks() );
 }
 
@@ -114,13 +114,13 @@ TEST_F( Albums, TracksByGenre )
         if ( i <= 5 )
             track->setGenre( g );
     }
-    auto tracks = a->tracks( g, SortingCriteria::Default, false )->all();
+    auto tracks = a->tracks( g, nullptr )->all();
     ASSERT_EQ( 5u, tracks.size() );
 
     Reload();
 
     a = std::static_pointer_cast<Album>( ml->album( a->id() ) );
-    tracks = a->tracks( g, SortingCriteria::Default, false )->all();
+    tracks = a->tracks( g, nullptr )->all();
     ASSERT_NE( tracks.size(), a->nbTracks() );
     ASSERT_EQ( 5u, tracks.size() );
 }
@@ -284,7 +284,7 @@ TEST_F( Albums, SearchByTitle )
     ml->createAlbum( "sea otters" );
     ml->createAlbum( "pangolins of fire" );
 
-    auto albums = ml->searchAlbums( "otte", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "otte", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 }
 
@@ -294,7 +294,7 @@ TEST_F( Albums, SearchByArtist )
     auto artist = ml->createArtist( "pangolins" );
     a->setAlbumArtist( artist );
 
-    auto albums = ml->searchAlbums( "pangol", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "pangol", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 }
 
@@ -304,7 +304,7 @@ TEST_F( Albums, SearchNoDuplicate )
     auto artist = ml->createArtist( "otters" );
     a->setAlbumArtist( artist );
 
-    auto albums = ml->searchAlbums( "otters", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "otters", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 }
 
@@ -314,7 +314,7 @@ TEST_F( Albums, SearchNoUnknownAlbum )
     auto album = artist->unknownAlbum();
     ASSERT_NE( nullptr, album );
 
-    auto albums = ml->searchAlbums( "otters", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "otters", nullptr )->all();
     ASSERT_EQ( 0u, albums.size() );
     // Can't search by name since there is no name set for unknown albums
 }
@@ -322,12 +322,12 @@ TEST_F( Albums, SearchNoUnknownAlbum )
 TEST_F( Albums, SearchAfterDeletion )
 {
     auto a = ml->createAlbum( "sea otters" );
-    auto albums = ml->searchAlbums( "sea", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "sea", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 
     ml->deleteAlbum( a->id() );
 
-    albums = ml->searchAlbums( "sea", SortingCriteria::Default, false )->all();
+    albums = ml->searchAlbums( "sea", nullptr )->all();
     ASSERT_EQ( 0u, albums.size() );
 }
 
@@ -338,18 +338,18 @@ TEST_F( Albums, SearchAfterArtistUpdate )
     auto artist2 = ml->createArtist( "pangolin of ice" );
     a->setAlbumArtist( artist );
 
-    auto albums = ml->searchAlbums( "fire", SortingCriteria::Default, false )->all();
+    auto albums = ml->searchAlbums( "fire", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 
-    albums = ml->searchAlbums( "ice", SortingCriteria::Default, false )->all();
+    albums = ml->searchAlbums( "ice", nullptr )->all();
     ASSERT_EQ( 0u, albums.size() );
 
     a->setAlbumArtist( artist2 );
 
-    albums = ml->searchAlbums( "fire", SortingCriteria::Default, false )->all();
+    albums = ml->searchAlbums( "fire", nullptr )->all();
     ASSERT_EQ( 0u, albums.size() );
 
-    albums = ml->searchAlbums( "ice", SortingCriteria::Default, false )->all();
+    albums = ml->searchAlbums( "ice", nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
 }
 
@@ -377,19 +377,21 @@ TEST_F( Albums, SortTracks )
     auto t2 = a->addTrack( m2, 2, 1, 0, nullptr );
 
     // Default order is by disc number & track number
-    auto tracks = a->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( 2u, tracks.size() );
     ASSERT_EQ( t1->id(), tracks[0]->id() );
     ASSERT_EQ( t2->id(), tracks[1]->id() );
 
     // Reverse order
-    tracks = a->tracks( SortingCriteria::Default, true )->all();
+    QueryParameters params { SortingCriteria::Default, true };
+    tracks = a->tracks( &params )->all();
     ASSERT_EQ( 2u, tracks.size() );
     ASSERT_EQ( t1->id(), tracks[1]->id() );
     ASSERT_EQ( t2->id(), tracks[0]->id() );
 
     // Try a media based criteria
-    tracks = a->tracks( SortingCriteria::Alpha, false )->all();
+    params = { SortingCriteria::Alpha, false };
+    tracks = a->tracks( &params )->all();
     ASSERT_EQ( 2u, tracks.size() );
     ASSERT_EQ( t1->id(), tracks[1]->id() ); // B-track -> first
     ASSERT_EQ( t2->id(), tracks[0]->id() ); // A-track -> second
@@ -404,13 +406,15 @@ TEST_F( Albums, Sort )
     auto a3 = ml->createAlbum( "C" );
     a3->setReleaseYear( 1000, false );
 
-    auto albums = ml->albums( SortingCriteria::ReleaseDate, false )->all();
+    QueryParameters params { SortingCriteria::ReleaseDate, false };
+    auto albums = ml->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( a1->id(), albums[0]->id() );
     ASSERT_EQ( a3->id(), albums[1]->id() );
     ASSERT_EQ( a2->id(), albums[2]->id() );
 
-    albums = ml->albums( SortingCriteria::ReleaseDate, true )->all();
+    params.desc = true;
+    albums = ml->albums( &params )->all();
     // We do not invert the lexical order when sorting by DESC release date:
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( a2->id(), albums[0]->id() );
@@ -418,13 +422,15 @@ TEST_F( Albums, Sort )
     ASSERT_EQ( a3->id(), albums[2]->id() );
 
     // When listing all albums, default order is lexical order
-    albums = ml->albums( SortingCriteria::Default, false )->all();
+    albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( a1->id(), albums[0]->id() );
     ASSERT_EQ( a2->id(), albums[1]->id() );
     ASSERT_EQ( a3->id(), albums[2]->id() );
 
-    albums = ml->albums( SortingCriteria::Default, true )->all();
+    params.sort = SortingCriteria::Default;
+    params.desc = true;
+    albums = ml->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( a3->id(), albums[0]->id() );
     ASSERT_EQ( a2->id(), albums[1]->id() );
@@ -470,7 +476,8 @@ TEST_F( Albums, SortByPlayCount )
 
     ASSERT_TRUE( f5->increasePlayCount() );
 
-    auto albums = ml->albums( SortingCriteria::PlayCount, false )->all(); // Expect descending order
+    QueryParameters params { SortingCriteria::PlayCount, false };
+    auto albums = ml->albums( &params )->all(); // Expect descending order
     ASSERT_EQ( 4u, albums.size() );
     ASSERT_EQ( a2->id(), albums[0]->id() ); // 4 plays
     ASSERT_EQ( a1->id(), albums[1]->id() ); // 3 plays
@@ -478,7 +485,8 @@ TEST_F( Albums, SortByPlayCount )
     ASSERT_EQ( a3->id(), albums[2]->id() ); // 1 play
     ASSERT_EQ( a4->id(), albums[3]->id() ); // 1 play
 
-    albums = ml->albums( SortingCriteria::PlayCount, true )->all(); // Expect ascending order
+    params.desc = true;
+    albums = ml->albums( &params )->all(); // Expect ascending order
     ASSERT_EQ( 4u, albums.size() );
     ASSERT_EQ( a3->id(), albums[0]->id() ); // 1 play
     ASSERT_EQ( a4->id(), albums[1]->id() ); // 1 play
@@ -489,7 +497,8 @@ TEST_F( Albums, SortByPlayCount )
     ASSERT_TRUE( f1->increasePlayCount() );
     ASSERT_TRUE( f2->increasePlayCount() );
 
-    albums = ml->albums( SortingCriteria::PlayCount, false )->all();
+    params.desc = false;
+    albums = ml->albums( &params )->all();
     ASSERT_EQ( 4u, albums.size() );
     ASSERT_EQ( a1->id(), albums[0]->id() ); // 5 plays
     ASSERT_EQ( a2->id(), albums[1]->id() ); // 4 plays
@@ -511,13 +520,15 @@ TEST_F( Albums, SortByArtist )
     auto a3 = ml->createAlbum( "A" );
     a3->setAlbumArtist( artist1 );
 
-    auto albums = ml->albums( SortingCriteria::Artist, false )->all();
+    QueryParameters params { SortingCriteria::Artist, false };
+    auto albums = ml->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( a3->id(), albums[0]->id() );
     ASSERT_EQ( a1->id(), albums[1]->id() );
     ASSERT_EQ( a2->id(), albums[2]->id() );
 
-    albums = ml->albums( SortingCriteria::Artist, true )->all();
+    params.desc = true;
+    albums = ml->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     // We expect Artist to be sorted in reverse order, but still in alphabetical order for albums
     ASSERT_EQ( a2->id(), albums[0]->id() );
@@ -578,13 +589,15 @@ TEST_F( Albums, SearchAndSort )
     auto m3 = std::static_pointer_cast<Media>( ml->addMedia( "track3.mp3" ) );
     alb2->addTrack( m3, 2, 0, 0, nullptr );
 
-    auto albs = ml->searchAlbums( "album", SortingCriteria::Alpha, false )->all();
+    QueryParameters params { SortingCriteria::Alpha, false };
+    auto albs = ml->searchAlbums( "album", &params )->all();
     ASSERT_EQ( 2u, albs.size() );
     ASSERT_EQ( albs[0]->id(), alb2->id() );
     ASSERT_EQ( albs[1]->id(), alb1->id() );
 
+    params.sort = SortingCriteria::TrackNumber;
     // Sorting by tracknumber is descending by default, so we expect album 2 first
-    albs = ml->searchAlbums( "album", SortingCriteria::TrackNumber, false )->all();
+    albs = ml->searchAlbums( "album", &params )->all();
     ASSERT_EQ( 2u, albs.size() );
     ASSERT_EQ( albs[0]->id(), alb2->id() );
     ASSERT_EQ( albs[1]->id(), alb1->id() );
diff --git a/test/unittest/AlbumTrackTests.cpp b/test/unittest/AlbumTrackTests.cpp
index c5ffbe331225ab27f13f1312957891a1d7580e16..1b1a90e9e3ff72dedc9bcd24ed32749473b95691 100644
--- a/test/unittest/AlbumTrackTests.cpp
+++ b/test/unittest/AlbumTrackTests.cpp
@@ -66,7 +66,7 @@ TEST_F( AlbumTracks, SetGenre )
     Reload();
 
     a = std::static_pointer_cast<Album>( ml->album( a->id() ) );
-    auto tracks = a->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = a->tracks( nullptr )->all();
     ASSERT_EQ( tracks.size(), 1u );
     auto t2 = tracks[0];
     ASSERT_EQ( t->genre()->id(), t2->albumTrack()->genre()->id() );
diff --git a/test/unittest/ArtistTests.cpp b/test/unittest/ArtistTests.cpp
index 9039180d02aad182105db323c29b4c9c3a107d83..1e8701cada5a59ad01717de51d287e606c5a2c40 100644
--- a/test/unittest/ArtistTests.cpp
+++ b/test/unittest/ArtistTests.cpp
@@ -135,13 +135,13 @@ TEST_F( Artists, Albums )
     album1->setAlbumArtist( artist );
     album2->setAlbumArtist( artist );
 
-    auto albums = artist->albums( SortingCriteria::Default, false )->all();
+    auto albums = artist->albums( nullptr )->all();
     ASSERT_EQ( albums.size(), 2u );
 
     Reload();
 
     auto artist2 = ml->artist( "Cannibal Otters" );
-    auto albums2 = artist2->albums( SortingCriteria::Default, false )->all();
+    auto albums2 = artist2->albums( nullptr )->all();
     ASSERT_EQ( albums2.size(), 2u );
 }
 
@@ -181,19 +181,19 @@ TEST_F( Artists, AllSongs )
         ASSERT_TRUE( res );
     }
 
-    auto songs = artist->media( SortingCriteria::Default, false )->all();
+    auto songs = artist->media( nullptr )->all();
     ASSERT_EQ( songs.size(), 3u );
 
     Reload();
 
     auto artist2 = ml->artist( "Cannibal Otters" );
-    songs = artist2->media( SortingCriteria::Default, false )->all();
+    songs = artist2->media( nullptr )->all();
     ASSERT_EQ( songs.size(), 3u );
 }
 
 TEST_F( Artists, GetAll )
 {
-    auto artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    auto artists = ml->artists( true, nullptr )->all();
     // Ensure we don't include Unknown Artist // Various Artists
     ASSERT_EQ( artists.size(), 0u );
 
@@ -205,18 +205,18 @@ TEST_F( Artists, GetAll )
         alb->setAlbumArtist( a );
         ASSERT_NE( a, nullptr );
     }
-    artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( artists.size(), 5u );
 
     Reload();
 
-    auto artists2 = ml->artists( true, SortingCriteria::Default, false )->all();
+    auto artists2 = ml->artists( true, nullptr )->all();
     ASSERT_EQ( artists2.size(), 5u );
 }
 
 TEST_F( Artists, GetAllNoAlbum )
 {
-    auto artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    auto artists = ml->artists( true, nullptr )->all();
     // Ensure we don't include Unknown Artist // Various Artists
     ASSERT_EQ( artists.size(), 0u );
 
@@ -225,15 +225,15 @@ TEST_F( Artists, GetAllNoAlbum )
         auto a = ml->createArtist( std::to_string( i ) );
         a->updateNbTrack( 1 );
     }
-    artists = ml->artists( false, SortingCriteria::Default, false )->all();
+    artists = ml->artists( false, nullptr )->all();
     ASSERT_EQ( artists.size(), 0u );
 
     Reload();
 
-    artists = ml->artists( false, SortingCriteria::Default, false )->all();
+    artists = ml->artists( false, nullptr )->all();
     ASSERT_EQ( artists.size(), 0u );
 
-    artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( artists.size(), 3u );
 }
 
@@ -278,12 +278,13 @@ TEST_F( Artists, Search )
     auto a2 = ml->createArtist( "artist 2" );
     ml->createArtist( "dream seaotter" );
 
-    auto artists = ml->searchArtists( "artist", SortingCriteria::Default, false )->all();
+    auto artists = ml->searchArtists( "artist", nullptr )->all();
     ASSERT_EQ( 2u, artists.size() );
     ASSERT_EQ( artists[0]->id(), a1->id() );
     ASSERT_EQ( artists[1]->id(), a2->id() );
 
-    artists = ml->searchArtists( "artist", SortingCriteria::Default, true )->all();
+    QueryParameters params { SortingCriteria::Default, true };
+    artists = ml->searchArtists( "artist", &params )->all();
     ASSERT_EQ( 2u, artists.size() );
     ASSERT_EQ( artists[0]->id(), a2->id() );
     ASSERT_EQ( artists[1]->id(), a1->id() );
@@ -295,12 +296,12 @@ TEST_F( Artists, SearchAfterDelete )
     ml->createArtist( "artist 2" );
     ml->createArtist( "dream seaotter" );
 
-    auto artists = ml->searchArtists( "artist", SortingCriteria::Default, false )->all();
+    auto artists = ml->searchArtists( "artist", nullptr )->all();
     ASSERT_EQ( 2u, artists.size() );
 
     ml->deleteArtist( a->id() );
 
-    artists = ml->searchArtists( "artist", SortingCriteria::Default, false )->all();
+    artists = ml->searchArtists( "artist", nullptr )->all();
     ASSERT_EQ( 1u, artists.size() );
 }
 
@@ -316,13 +317,15 @@ TEST_F( Artists, SortMedia )
         artist->addMedia( *f );
     }
 
-    auto tracks = artist->media( SortingCriteria::Duration, false )->all();
+    QueryParameters params { SortingCriteria::Duration, false };
+    auto tracks = artist->media( &params )->all();
     ASSERT_EQ( 3u, tracks.size() );
     ASSERT_EQ( "song3.mp3", tracks[0]->title() ); // Duration: 8
     ASSERT_EQ( "song2.mp3", tracks[1]->title() ); // Duration: 9
     ASSERT_EQ( "song1.mp3", tracks[2]->title() ); // Duration: 10
 
-    tracks = artist->media( SortingCriteria::Duration, true )->all();
+    params.desc = true;
+    tracks = artist->media( &params )->all();
     ASSERT_EQ( 3u, tracks.size() );
     ASSERT_EQ( "song1.mp3", tracks[0]->title() );
     ASSERT_EQ( "song2.mp3", tracks[1]->title() );
@@ -349,14 +352,16 @@ TEST_F( Artists, SortMediaByAlbum )
         }
     }
 
-    auto tracks = artist->media( SortingCriteria::Album, false )->all();
+    QueryParameters params { SortingCriteria::Album, false };
+    auto tracks = artist->media( &params )->all();
     ASSERT_EQ( 4u, tracks.size() );
     ASSERT_EQ( "alb0_song1.mp3", tracks[0]->title() );
     ASSERT_EQ( "alb0_song2.mp3", tracks[1]->title() );
     ASSERT_EQ( "alb1_song1.mp3", tracks[2]->title() );
     ASSERT_EQ( "alb1_song2.mp3", tracks[3]->title() );
 
-    tracks = artist->media( SortingCriteria::Album, true )->all();
+    params.desc = true;
+    tracks = artist->media( &params )->all();
     ASSERT_EQ( 4u, tracks.size() );
     ASSERT_EQ( "alb1_song2.mp3", tracks[0]->title() );
     ASSERT_EQ( "alb1_song1.mp3", tracks[1]->title() );
@@ -385,25 +390,29 @@ TEST_F( Artists, SortAlbum )
     album3->setAlbumArtist( artist );
 
     // Default order is by descending year, discriminated by lexical order
-    auto albums = artist->albums( SortingCriteria::Default, false )->all();
+    auto albums = artist->albums( nullptr )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( album1->id(), albums[0]->id() );
     ASSERT_EQ( album3->id(), albums[1]->id() );
     ASSERT_EQ( album2->id(), albums[2]->id() );
 
-    albums = artist->albums( SortingCriteria::Default, true )->all();
+    QueryParameters params { SortingCriteria::Default, true };
+    albums = artist->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( album2->id(), albums[0]->id() );
     ASSERT_EQ( album1->id(), albums[1]->id() );
     ASSERT_EQ( album3->id(), albums[2]->id() );
 
-    albums = artist->albums( SortingCriteria::Alpha, false )->all();
+    params.sort = SortingCriteria::Alpha;
+    params.desc = false;
+    albums = artist->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( album1->id(), albums[0]->id() );
     ASSERT_EQ( album2->id(), albums[1]->id() );
     ASSERT_EQ( album3->id(), albums[2]->id() );
 
-    albums = artist->albums( SortingCriteria::Alpha, true )->all();
+    params.desc = true;
+    albums = artist->albums( &params )->all();
     ASSERT_EQ( 3u, albums.size() );
     ASSERT_EQ( album3->id(), albums[0]->id() );
     ASSERT_EQ( album2->id(), albums[1]->id() );
@@ -420,12 +429,14 @@ TEST_F( Artists, Sort )
     auto alb2 = ml->createAlbum( "albumB" );
     alb2->setAlbumArtist( a2 );
 
-    auto artists = ml->artists( true, SortingCriteria::Alpha, false )->all();
+    QueryParameters params { SortingCriteria::Alpha, false };
+    auto artists = ml->artists( true, &params )->all();
     ASSERT_EQ( 2u, artists.size() );
     ASSERT_EQ( a1->id(), artists[0]->id() );
     ASSERT_EQ( a2->id(), artists[1]->id() );
 
-    artists = ml->artists( true, SortingCriteria::Alpha, true )->all();
+    params.desc = true;
+    artists = ml->artists( true, &params )->all();
     ASSERT_EQ( 2u, artists.size() );
     ASSERT_EQ( a1->id(), artists[1]->id() );
     ASSERT_EQ( a2->id(), artists[0]->id() );
@@ -439,16 +450,16 @@ TEST_F( Artists, DeleteWhenNoAlbum )
     auto m1 = std::static_pointer_cast<Media>( ml->addMedia( "track1.mp3" ) );
     auto track1 = album->addTrack( m1, 1, 1, artist->id(), nullptr );
 
-    auto artists = ml->artists( true, medialibrary::SortingCriteria::Default, false )->all();
+    auto artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 1u, artists.size() );
 
     ml->deleteTrack( track1->id() );
-    artists = ml->artists( true, medialibrary::SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 0u, artists.size() );
 
     Reload();
 
-    artists = ml->artists( true, medialibrary::SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 0u, artists.size() );
 }
 
@@ -499,7 +510,8 @@ TEST_F( Artists, SortTracksMultiDisc )
      * [ Disc 1 - Track 3 ]
      * [ Disc 2 - Track 3 ]
      */
-    auto tracks = artist->media( SortingCriteria::Album, false )->all();
+    QueryParameters params { SortingCriteria::Album, false };
+    auto tracks = artist->media( &params )->all();
     ASSERT_EQ( 6u, tracks.size() );
     ASSERT_EQ( media[0]->id(), tracks[0]->id() );
     ASSERT_EQ( media[2]->id(), tracks[1]->id() );
@@ -508,7 +520,8 @@ TEST_F( Artists, SortTracksMultiDisc )
     ASSERT_EQ( media[3]->id(), tracks[4]->id() );
     ASSERT_EQ( media[5]->id(), tracks[5]->id() );
 
-    tracks = artist->media( SortingCriteria::Album, true )->all();
+    params.desc = true;
+    tracks = artist->media( &params )->all();
     ASSERT_EQ( media[5]->id(), tracks[0]->id() );
     ASSERT_EQ( media[3]->id(), tracks[1]->id() );
     ASSERT_EQ( media[1]->id(), tracks[2]->id() );
diff --git a/test/unittest/DeviceTests.cpp b/test/unittest/DeviceTests.cpp
index 787359cd059cb616bc32523790d760d414c3a6a1..1ab8b5c0f7446a760b1e43e519f241aa8a802633 100644
--- a/test/unittest/DeviceTests.cpp
+++ b/test/unittest/DeviceTests.cpp
@@ -256,18 +256,18 @@ TEST_F( DeviceFs, RemoveAlbum )
         album2->setAlbumArtist( artist );
     }
 
-    auto albums = ml->albums( SortingCriteria::Default, false )->all();
+    auto albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 3u, albums.size() );
-    auto artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    auto artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 2u, artists.size() );
 
     auto device = fsMock->removeDevice( RemovableDeviceUuid );
 
     Reload();
 
-    albums = ml->albums( SortingCriteria::Default, false )->all();
+    albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
-    artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 1u, artists.size() );
 
     // Now check that everything appears again when we plug the device back in
@@ -276,9 +276,9 @@ TEST_F( DeviceFs, RemoveAlbum )
 
     Reload();
 
-    albums = ml->albums( SortingCriteria::Default, false )->all();
+    albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 3u, albums.size() );
-    artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 2u, artists.size() );
 }
 
@@ -300,22 +300,22 @@ TEST_F( DeviceFs, PartialAlbumRemoval )
         newArtist->addMedia( static_cast<Media&>( *media2 ) );
     }
 
-    auto albums = ml->albums( SortingCriteria::Default, false )->all();
+    auto albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
-    auto artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    auto artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 1u, artists.size() );
     auto artist = artists[0];
-    ASSERT_EQ( 2u, artist->media( SortingCriteria::Default, false )->count() );
+    ASSERT_EQ( 2u, artist->media( nullptr )->count() );
 
     auto device = fsMock->removeDevice( RemovableDeviceUuid );
     Reload();
 
-    albums = ml->albums( SortingCriteria::Default, false )->all();
+    albums = ml->albums( nullptr )->all();
     ASSERT_EQ( 1u, albums.size() );
-    artists = ml->artists( true, SortingCriteria::Default, false )->all();
+    artists = ml->artists( true, nullptr )->all();
     ASSERT_EQ( 1u, artists.size() );
-    ASSERT_EQ( 1u, albums[0]->tracks( SortingCriteria::Default, false )->count() );
-    ASSERT_EQ( 1u, artists[0]->media( SortingCriteria::Default, false )->count() );
+    ASSERT_EQ( 1u, albums[0]->tracks( nullptr )->count() );
+    ASSERT_EQ( 1u, artists[0]->media( nullptr )->count() );
 }
 
 TEST_F( DeviceFs, ChangeDevice )
diff --git a/test/unittest/GenreTests.cpp b/test/unittest/GenreTests.cpp
index 58285e11d2321cd80ea29a5638071a0d253efd9a..5ffec52db8b191cebc50e5a70b235353ca586931 100644
--- a/test/unittest/GenreTests.cpp
+++ b/test/unittest/GenreTests.cpp
@@ -48,7 +48,7 @@ TEST_F( Genres, Create )
 {
     ASSERT_NE( nullptr, g );
     ASSERT_EQ( "genre", g->name() );
-    auto tracks = g->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = g->tracks( nullptr )->all();
     ASSERT_EQ( 0u, tracks.size() );
 }
 
@@ -56,7 +56,7 @@ TEST_F( Genres, List )
 {
     auto g2 = ml->createGenre( "genre 2" );
     ASSERT_NE( nullptr, g2 );
-    auto genres = ml->genres( SortingCriteria::Default, false )->all();
+    auto genres = ml->genres( nullptr )->all();
     ASSERT_EQ( 2u, genres.size() );
 }
 
@@ -71,13 +71,13 @@ TEST_F( Genres, ListAlbumTracks )
         if ( i != 1 )
             t->setGenre( g );
     }
-    auto tracks = g->tracks( SortingCriteria::Default, false )->all();
+    auto tracks = g->tracks( nullptr )->all();
     ASSERT_EQ( 2u, tracks.size() );
 }
 
 TEST_F( Genres, ListArtists )
 {
-    auto artists = g->artists( SortingCriteria::Default, false )->all();
+    auto artists = g->artists( nullptr )->all();
     ASSERT_EQ( 0u, artists.size() );
 
     auto a = ml->createArtist( "artist" );
@@ -99,7 +99,7 @@ TEST_F( Genres, ListArtists )
         auto track = album2->addTrack( m, i, 1, a2->id(), nullptr );
         track->setGenre( g );
     }
-    artists = g->artists( SortingCriteria::Default, false )->all();
+    artists = g->artists( nullptr )->all();
     ASSERT_EQ( 2u, artists.size() );
 }
 
@@ -125,10 +125,10 @@ TEST_F( Genres, ListAlbums )
         track->setGenre( g );
     }
 
-    auto genres = ml->genres( SortingCriteria::Default, false )->all();
+    auto genres = ml->genres( nullptr )->all();
     for ( auto& genre : genres )
     {
-        auto albums = genre->albums( SortingCriteria::Default, false )->all();
+        auto albums = genre->albums( nullptr )->all();
 
         if ( genre->id() == g->id() )
         {
@@ -148,18 +148,18 @@ TEST_F( Genres, Search )
     ml->createGenre( "something" );
     ml->createGenre( "blork" );
 
-    auto genres = ml->searchGenre( "genr", SortingCriteria::Default, false )->all();
+    auto genres = ml->searchGenre( "genr", nullptr )->all();
     ASSERT_EQ( 1u, genres.size() );
 }
 
 TEST_F( Genres, SearchAfterDelete )
 {
-    auto genres = ml->searchGenre( "genre", SortingCriteria::Default, false )->all();
+    auto genres = ml->searchGenre( "genre", nullptr )->all();
     ASSERT_EQ( 1u, genres.size() );
 
     ml->deleteGenre( g->id() );
 
-    genres = ml->searchGenre( "genre", SortingCriteria::Default, false )->all();
+    genres = ml->searchGenre( "genre", nullptr )->all();
     ASSERT_EQ( 0u, genres.size() );
 }
 
@@ -175,12 +175,14 @@ TEST_F( Genres, SortTracks )
         m->save();
         t->setGenre( g );
     }
-    auto tracks = g->tracks( SortingCriteria::Duration, false )->all();
+    QueryParameters params { SortingCriteria::Duration, false };
+    auto tracks = g->tracks( &params )->all();
     ASSERT_EQ( 2u, tracks.size() );
     ASSERT_EQ( 1u, tracks[0]->albumTrack()->trackNumber() );
     ASSERT_EQ( 2u, tracks[1]->albumTrack()->trackNumber() );
 
-    tracks = g->tracks( SortingCriteria::Duration, true )->all();
+    params.desc = true;
+    tracks = g->tracks( &params )->all();
     ASSERT_EQ( 2u, tracks.size() );
     ASSERT_EQ( 1u, tracks[1]->albumTrack()->trackNumber() );
     ASSERT_EQ( 2u, tracks[0]->albumTrack()->trackNumber() );
@@ -190,12 +192,13 @@ TEST_F( Genres, Sort )
 {
     auto g2 = ml->createGenre( "metal" );
 
-    auto genres = ml->genres( SortingCriteria::Default, false )->all();
+    auto genres = ml->genres( nullptr )->all();
     ASSERT_EQ( 2u, genres.size() );
     ASSERT_EQ( g->id(), genres[0]->id() );
     ASSERT_EQ( g2->id(), genres[1]->id() );
 
-    genres = ml->genres( SortingCriteria::Default, true )->all();
+    QueryParameters params { SortingCriteria::Default, true };
+    genres = ml->genres( &params )->all();
     ASSERT_EQ( 2u, genres.size() );
     ASSERT_EQ( g->id(), genres[1]->id() );
     ASSERT_EQ( g2->id(), genres[0]->id() );
diff --git a/test/unittest/MediaTests.cpp b/test/unittest/MediaTests.cpp
index e3f70f4c3f705d9707cffb515978310d68d3d6da..88fe66154164c216b9eb0acbdbba2902e53a1b26 100644
--- a/test/unittest/MediaTests.cpp
+++ b/test/unittest/MediaTests.cpp
@@ -160,16 +160,16 @@ TEST_F( Medias, Search )
     {
         ml->addMedia( "track " + std::to_string( i ) + ".mp3" );
     }
-    auto media = ml->searchMedia( "tra", SortingCriteria::Default, false ).others->all();
+    auto media = ml->searchMedia( "tra", nullptr ).others->all();
     ASSERT_EQ( 10u, media.size() );
 
-    media = ml->searchMedia( "track 1", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "track 1", nullptr ).others->all();
     ASSERT_EQ( 2u, media.size() );
 
-    media = ml->searchMedia( "grouik", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "grouik", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 
-    media = ml->searchMedia( "rack", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "rack", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 }
 
@@ -184,13 +184,14 @@ TEST_F( Medias, SearchAndSort )
     }
     ml->addMedia( "this pattern doesn't match.mp3" );
 
-    auto media = ml->searchMedia( "tra", SortingCriteria::Default, false ).others->all();
+    auto media = ml->searchMedia( "tra", nullptr ).others->all();
     ASSERT_EQ( 3u, media.size() );
     ASSERT_EQ( media[0]->title(), "track 1.mp3" );
     ASSERT_EQ( media[1]->title(), "track 2.mp3" );
     ASSERT_EQ( media[2]->title(), "track 3.mp3" );
 
-    media = ml->searchMedia( "tra", SortingCriteria::Duration, false ).others->all();
+    QueryParameters params { SortingCriteria::Duration, false };
+    media = ml->searchMedia( "tra", &params ).others->all();
     ASSERT_EQ( 3u, media.size() );
     ASSERT_EQ( media[0]->title(), "track 3.mp3" );
     ASSERT_EQ( media[1]->title(), "track 2.mp3" );
@@ -201,16 +202,16 @@ TEST_F( Medias, SearchAfterEdit )
 {
     auto m = std::static_pointer_cast<Media>( ml->addMedia( "media.mp3" ) );
 
-    auto media = ml->searchMedia( "media", SortingCriteria::Default, false ).others->all();
+    auto media = ml->searchMedia( "media", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     m->setTitleBuffered( "otters are awesome" );
     m->save();
 
-    media = ml->searchMedia( "media", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "media", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 
-    media = ml->searchMedia( "otters", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otters", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 }
 
@@ -218,59 +219,59 @@ TEST_F( Medias, SearchAfterDelete )
 {
     auto m = std::static_pointer_cast<Media>( ml->addMedia( "media.mp3" ) );
 
-    auto media = ml->searchMedia( "media", SortingCriteria::Default, false ).others->all();
+    auto media = ml->searchMedia( "media", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     auto f = m->files()[0];
     m->removeFile( static_cast<File&>( *f ) );
 
-    media = ml->searchMedia( "media", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "media", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 }
 
 TEST_F( Medias, SearchByLabel )
 {
     auto m = std::static_pointer_cast<Media>( ml->addMedia( "media.mkv" ) );
-    auto media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    auto media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 
     auto l = ml->createLabel( "otter" );
     m->addLabel( l );
 
-    media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     auto l2 = ml->createLabel( "pangolins" );
     m->addLabel( l2 );
 
-    media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
-    media = ml->searchMedia( "pangolin", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "pangolin", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     m->removeLabel( l );
 
-    media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 
-    media = ml->searchMedia( "pangolin", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "pangolin", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     m->addLabel( l );
 
-    media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
-    media = ml->searchMedia( "pangolin", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "pangolin", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 
     ml->deleteLabel( l );
 
-    media = ml->searchMedia( "otter", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "otter", nullptr ).others->all();
     ASSERT_EQ( 0u, media.size() );
 
-    media = ml->searchMedia( "pangolin", SortingCriteria::Default, false ).others->all();
+    media = ml->searchMedia( "pangolin", nullptr ).others->all();
     ASSERT_EQ( 1u, media.size() );
 }
 
@@ -283,16 +284,16 @@ TEST_F( Medias, SearchTracks )
        a->addTrack( m, i, 1, 0, 0 );
        m->save();
     }
-    auto tracks = ml->searchMedia( "tra", SortingCriteria::Default, false ).tracks->all();
+    auto tracks = ml->searchMedia( "tra", nullptr ).tracks->all();
     ASSERT_EQ( 10u, tracks.size() );
 
-    tracks = ml->searchMedia( "track 1", SortingCriteria::Default, false ).tracks->all();
+    tracks = ml->searchMedia( "track 1", nullptr ).tracks->all();
     ASSERT_EQ( 2u, tracks.size() );
 
-    tracks = ml->searchMedia( "grouik", SortingCriteria::Default, false ).tracks->all();
+    tracks = ml->searchMedia( "grouik", nullptr ).tracks->all();
     ASSERT_EQ( 0u, tracks.size() );
 
-    tracks = ml->searchMedia( "rack", SortingCriteria::Default, false ).tracks->all();
+    tracks = ml->searchMedia( "rack", nullptr ).tracks->all();
     ASSERT_EQ( 0u, tracks.size() );
 }
 
@@ -388,13 +389,15 @@ TEST_F( Medias, SortByAlpha )
     m3->setType( Media::Type::Audio );
     m3->save();
 
-    auto media = ml->audioFiles( SortingCriteria::Alpha, false )->all();
+    QueryParameters params { SortingCriteria::Alpha, false };
+    auto media = ml->audioFiles( &params )->all();
     ASSERT_EQ( 3u, media.size() );
     ASSERT_EQ( m1->id(), media[0]->id() );
     ASSERT_EQ( m3->id(), media[1]->id() );
     ASSERT_EQ( m2->id(), media[2]->id() );
 
-    media = ml->audioFiles( SortingCriteria::Alpha, true )->all();
+    params.desc = true;
+    media = ml->audioFiles( &params )->all();
     ASSERT_EQ( 3u, media.size() );
     ASSERT_EQ( m2->id(), media[0]->id() );
     ASSERT_EQ( m3->id(), media[1]->id() );
@@ -415,12 +418,14 @@ TEST_F( Medias, SortByLastModifDate )
     m2->setType( Media::Type::Video );
     m2->save();
 
-    auto media = ml->videoFiles( SortingCriteria::LastModificationDate, false )->all();
+    QueryParameters params { SortingCriteria::LastModificationDate, false };
+    auto media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[0]->id() );
     ASSERT_EQ( m1->id(), media[1]->id() );
 
-    media = ml->videoFiles( SortingCriteria::LastModificationDate, true )->all();
+    params.desc = true;
+    media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[1]->id() );
     ASSERT_EQ( m1->id(), media[0]->id() );
@@ -440,12 +445,14 @@ TEST_F( Medias, SortByFileSize )
     m2->setType( Media::Type::Video );
     m2->save();
 
-    auto media = ml->videoFiles( SortingCriteria::FileSize, false )->all();
+    QueryParameters params { SortingCriteria::FileSize, false };
+    auto media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[0]->id() );
     ASSERT_EQ( m1->id(), media[1]->id() );
 
-    media = ml->videoFiles( SortingCriteria::FileSize, true )->all();
+    params.desc = true;
+    media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[1]->id() );
     ASSERT_EQ( m1->id(), media[0]->id() );
@@ -463,12 +470,14 @@ TEST_F( Medias, SortByFilename )
     m2->setTitle( "zzzzz" );
     m2->save();
 
-    auto media = ml->videoFiles( SortingCriteria::Filename, false )->all();
+    QueryParameters params { SortingCriteria::Filename, false };
+    auto media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[0]->id() );
     ASSERT_EQ( m1->id(), media[1]->id() );
 
-    media = ml->videoFiles( SortingCriteria::LastModificationDate, true )->all();
+    params.desc = true;
+    media = ml->videoFiles( &params )->all();
     ASSERT_EQ( 2u, media.size() );
     ASSERT_EQ( m2->id(), media[1]->id() );
     ASSERT_EQ( m1->id(), media[0]->id() );
@@ -541,10 +550,10 @@ TEST_F( Medias, ExternalMrl )
     ASSERT_EQ( m->title(), "sea-otters.mkv" );
 
     // External files shouldn't appear in listings
-    auto videos = ml->videoFiles( medialibrary::SortingCriteria::Default, false )->all();
+    auto videos = ml->videoFiles( nullptr )->all();
     ASSERT_EQ( 0u, videos.size() );
 
-    auto audios = ml->audioFiles( medialibrary::SortingCriteria::Default, false )->all();
+    auto audios = ml->audioFiles( nullptr )->all();
     ASSERT_EQ( 0u, audios.size() );
 
     Reload();
@@ -591,10 +600,10 @@ TEST_F( Medias, Pagination )
        m->save();
     }
 
-    auto allMedia = ml->videoFiles( SortingCriteria::Default, false )->all();
+    auto allMedia = ml->videoFiles( nullptr )->all();
     ASSERT_EQ( 9u, allMedia.size() );
 
-    auto paginator = ml->videoFiles( SortingCriteria::Default, false );
+    auto paginator = ml->videoFiles( nullptr );
     auto media = paginator->items( 1, 0 );
     int i = 0u;
     while( media.size() > 0 )
diff --git a/test/unittest/PlaylistTests.cpp b/test/unittest/PlaylistTests.cpp
index 3fea28d5fa39b2c2c47e45b7c94f3318df342540..e40593cce544df23fff8eae6c4ec0a8b927b19e4 100644
--- a/test/unittest/PlaylistTests.cpp
+++ b/test/unittest/PlaylistTests.cpp
@@ -62,7 +62,7 @@ TEST_F( Playlists, Fetch )
     ASSERT_NE( nullptr, pl2 );
     ASSERT_EQ( pl->id(), pl2->id() );
 
-    auto playlists = ml->playlists( SortingCriteria::Default, false )->all();
+    auto playlists = ml->playlists( nullptr )->all();
     ASSERT_EQ( 1u, playlists.size() );
     ASSERT_EQ( pl->id(), playlists[0]->id() );
 }
@@ -72,7 +72,7 @@ TEST_F( Playlists, DeletePlaylist )
 {
     auto res = ml->deletePlaylist( pl->id() );
     ASSERT_TRUE( res );
-    auto playlists = ml->playlists( SortingCriteria::Default, false )->all();
+    auto playlists = ml->playlists( nullptr )->all();
     ASSERT_EQ( 0u, playlists.size() );
 }
 
@@ -97,7 +97,7 @@ TEST_F( Playlists, FetchAll )
     ml->createPlaylist( "pl 3" );
     ml->createPlaylist( "pl 4" );
 
-    auto playlists = ml->playlists( SortingCriteria::Default, false )->all();
+    auto playlists = ml->playlists( nullptr )->all();
     ASSERT_EQ( 4u, playlists.size() );
     for ( auto& p : playlists )
     {
@@ -256,7 +256,7 @@ TEST_F( Playlists, Search )
     ml->createPlaylist( "playlist 2" );
     ml->createPlaylist( "laylist 3" );
 
-    auto playlists = ml->searchPlaylists( "play", SortingCriteria::Default, false )->all();
+    auto playlists = ml->searchPlaylists( "play", nullptr )->all();
     ASSERT_EQ( 2u, playlists.size() );
 }
 
@@ -264,12 +264,13 @@ TEST_F( Playlists, SearchAndSort )
 {
     auto pl2 = ml->createPlaylist( "playlist 2" );
 
-    auto playlists = ml->searchPlaylists( "play", SortingCriteria::Default, false )->all();
+    auto playlists = ml->searchPlaylists( "play", nullptr )->all();
     ASSERT_EQ( 2u, playlists.size() );
     ASSERT_EQ( pl2->id(), playlists[0]->id() );
     ASSERT_EQ( pl->id(), playlists[1]->id() );
 
-    playlists = ml->searchPlaylists( "play", SortingCriteria::Default, true )->all();
+    QueryParameters params = { SortingCriteria::Default, true };
+    playlists = ml->searchPlaylists( "play", &params )->all();
     ASSERT_EQ( 2u, playlists.size() );
     ASSERT_EQ( pl->id(), playlists[0]->id() );
     ASSERT_EQ( pl2->id(), playlists[1]->id() );
@@ -278,27 +279,27 @@ TEST_F( Playlists, SearchAndSort )
 TEST_F( Playlists, SearchAfterDelete )
 {
     auto pl = ml->createPlaylist( "sea otters greatest hits" );
-    auto pls = ml->searchPlaylists( "sea otters", SortingCriteria::Default, false )->all();
+    auto pls = ml->searchPlaylists( "sea otters", nullptr )->all();
     ASSERT_EQ( 1u, pls.size() );
 
     ml->deletePlaylist( pl->id() );
 
-    pls = ml->searchPlaylists( "sea otters", SortingCriteria::Default, false )->all();
+    pls = ml->searchPlaylists( "sea otters", nullptr )->all();
     ASSERT_EQ( 0u, pls.size() );
 }
 
 TEST_F( Playlists, SearchAfterUpdate )
 {
     auto pl = ml->createPlaylist( "sea otters greatest hits" );
-    auto pls = ml->searchPlaylists( "sea otters", SortingCriteria::Default, false )->all();
+    auto pls = ml->searchPlaylists( "sea otters", nullptr )->all();
     ASSERT_EQ( 1u, pls.size() );
 
     pl->setName( "pangolins are cool too" );
 
-    pls = ml->searchPlaylists( "sea otters", SortingCriteria::Default, false )->all();
+    pls = ml->searchPlaylists( "sea otters", nullptr )->all();
     ASSERT_EQ( 0u, pls.size() );
 
-    pls = ml->searchPlaylists( "pangolins", SortingCriteria::Default, false )->all();
+    pls = ml->searchPlaylists( "pangolins", nullptr )->all();
     ASSERT_EQ( 1u, pls.size() );
 }
 
@@ -306,12 +307,13 @@ TEST_F( Playlists, Sort )
 {
     auto pl2 = ml->createPlaylist( "A playlist" );
 
-    auto pls = ml->playlists( SortingCriteria::Default, false )->all();
+    auto pls = ml->playlists( nullptr )->all();
     ASSERT_EQ( 2u, pls.size() );
     ASSERT_EQ( pl2->id(), pls[0]->id() );
     ASSERT_EQ( pl->id(), pls[1]->id() );
 
-    pls = ml->playlists( SortingCriteria::Default, true )->all();
+    QueryParameters params { SortingCriteria::Default, true };
+    pls = ml->playlists( &params )->all();
     ASSERT_EQ( 2u, pls.size() );
     ASSERT_EQ( pl2->id(), pls[1]->id() );
     ASSERT_EQ( pl->id(), pls[0]->id() );