diff --git a/autotests/databaseinterfacetest.cpp b/autotests/databaseinterfacetest.cpp
--- a/autotests/databaseinterfacetest.cpp
+++ b/autotests/databaseinterfacetest.cpp
@@ -165,15 +165,16 @@
         QCOMPARE(track.composer(), QStringLiteral("composer1"));
         QCOMPARE(track.lyricist(), QStringLiteral("lyricist1"));
 
-        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
+        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"), QStringLiteral("/"));
         QVERIFY(albumId != 0);
         auto album = musicDb.albumDataFromDatabaseId(albumId);
         auto albumData = musicDb.albumData(albumId);
 
         QCOMPARE(album.isValid(), true);
         QCOMPARE(albumData.count(), 1);
         QCOMPARE(album.title(), QStringLiteral("album3"));
         QCOMPARE(album.artist(), QStringLiteral("artist2"));
+        QCOMPARE(album[DatabaseInterface::ColumnsRoles::SecondaryTextRole], QStringLiteral("artist2"));
         QVERIFY(album.isValidArtist());
         QCOMPARE(album.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("album3")));
         QCOMPARE(album.isSingleDiscAlbum(), true);
@@ -249,7 +250,6 @@
         QCOMPARE(track.title(), QStringLiteral("track10"));
         QCOMPARE(track.artist(), QStringLiteral("artist8"));
         QCOMPARE(track.album(), QString());
-        QEXPECT_FAIL("","Album artist is currently associated with the album in the database. if the album is missing, we lose this information", Continue);
         QVERIFY(!track.albumArtist().isEmpty());
         QCOMPARE(track.albumCover(), QUrl());
         QCOMPARE(track.trackNumber(), 9);
@@ -618,7 +618,7 @@
 
         musicDbTrackAddedSpy.wait(300);
 
-        QCOMPARE(musicDb.allAlbumsData().count(), 2);
+        QCOMPARE(musicDb.allAlbumsData().count(), 1);
         QCOMPARE(musicDb.allArtistsData().count(), 2);
         QCOMPARE(musicDb.allTracksData().count(), 2);
         QCOMPARE(musicDbArtistAddedSpy.count(), 1);
@@ -669,23 +669,12 @@
         QCOMPARE(secondTrack.lyricist(), QStringLiteral("lyricist1"));
         QCOMPARE(secondTrack.hasEmbeddedCover(), false);
 
-        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
+        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), {}, QStringLiteral("/"));
         auto album = musicDb.albumDataFromDatabaseId(albumId);
         auto albumData = musicDb.albumData(albumId);
 
         QCOMPARE(album.isValid(), true);
-        QCOMPARE(albumData.count(), 1);
-        QCOMPARE(album.title(), QStringLiteral("album3"));
-        QVERIFY(album.isValidArtist());
-        QCOMPARE(album.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("album3")));
-        QCOMPARE(album.isSingleDiscAlbum(), true);
-
-        albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist3"));
-        album = musicDb.albumDataFromDatabaseId(albumId);
-        albumData = musicDb.albumData(albumId);
-
-        QCOMPARE(album.isValid(), true);
-        QCOMPARE(albumData.count(), 1);
+        QCOMPARE(albumData.count(), 2);
         QCOMPARE(album.title(), QStringLiteral("album3"));
         QVERIFY(album.isValidArtist());
         QCOMPARE(album.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("album3")));
@@ -822,7 +811,7 @@
         QCOMPARE(thirdTrack.lyricist(), QStringLiteral("lyricist1"));
         QCOMPARE(thirdTrack.isSingleDiscAlbum(), true);
 
-        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
+        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), {}, QStringLiteral("/"));
         auto album = musicDb.albumDataFromDatabaseId(albumId);
         auto albumData = musicDb.albumData(albumId);
 
@@ -891,7 +880,7 @@
 
         musicDbTrackAddedSpy.wait(300);
 
-        QCOMPARE(musicDb.allAlbumsData().count(), 2);
+        QCOMPARE(musicDb.allAlbumsData().count(), 1);
         QCOMPARE(musicDb.allArtistsData().count(), 3);
         QCOMPARE(musicDb.allTracksData().count(), 2);
         QCOMPARE(musicDbArtistAddedSpy.count(), 1);
@@ -911,7 +900,7 @@
         QCOMPARE(firstTrack.title(), QStringLiteral("track6"));
         QCOMPARE(firstTrack.artist(), QStringLiteral("artist2"));
         QCOMPARE(firstTrack.album(), QStringLiteral("album3"));
-        QCOMPARE(firstTrack.albumArtist(), QStringLiteral("artist2"));
+        QCOMPARE(firstTrack.albumArtist(), QStringLiteral("artist4"));
         QCOMPARE(firstTrack.albumCover(), QUrl::fromLocalFile(QStringLiteral("album3")));
         QCOMPARE(firstTrack.trackNumber(), 6);
         QCOMPARE(firstTrack.discNumber(), 1);
@@ -944,29 +933,17 @@
         QCOMPARE(secondTrack.isSingleDiscAlbum(), true);
         QCOMPARE(secondTrack.hasEmbeddedCover(), false);
 
-        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist4"));
+        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist4"), QStringLiteral("/"));
         auto album = musicDb.albumDataFromDatabaseId(albumId);
         auto albumData = musicDb.albumData(albumId);
 
         QCOMPARE(album.isValid(), true);
-        QCOMPARE(albumData.count(), 1);
+        QCOMPARE(albumData.count(), 2);
         QCOMPARE(album.title(), QStringLiteral("album3"));
         QCOMPARE(album.artist(), QStringLiteral("artist4"));
         QCOMPARE(album.isValidArtist(), true);
         QCOMPARE(album.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("album3")));
         QCOMPARE(album.isSingleDiscAlbum(), true);
-
-        albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
-        album = musicDb.albumDataFromDatabaseId(albumId);
-        albumData = musicDb.albumData(albumId);
-
-        QCOMPARE(album.isValid(), true);
-        QCOMPARE(albumData.count(), 1);
-        QCOMPARE(album.title(), QStringLiteral("album3"));
-        QCOMPARE(album.artist(), QStringLiteral("artist2"));
-        QCOMPARE(album.isValidArtist(), true);
-        QCOMPARE(album.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("album3")));
-        QCOMPARE(album.isSingleDiscAlbum(), true);
     }
 
     void addMultipleTimeSameTracks()
@@ -1011,13 +988,13 @@
         QCOMPARE(musicDb.allAlbumsData().count(), 5);
         QCOMPARE(musicDbErrorSpy.count(), 0);
 
-        auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+        auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
         QCOMPARE(firstAlbum.isValid(), true);
         QCOMPARE(firstAlbum.title(), QStringLiteral("album1"));
         QCOMPARE(musicDbErrorSpy.count(), 0);
 
-        auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist")));
+        auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
 
         QCOMPARE(firstAlbumInvalid.isValid(), false);
         QCOMPARE(musicDbErrorSpy.count(), 0);
@@ -1041,12 +1018,12 @@
 
             QCOMPARE(musicDb.allAlbumsData().count(), 5);
 
-            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbum.isValid(), true);
             QCOMPARE(firstAlbum.title(), QStringLiteral("album1"));
 
-            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist")));
+            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbumInvalid.isValid(), false);
         }
@@ -1064,12 +1041,12 @@
 
             QCOMPARE(musicDb.allAlbumsData().count(), 5);
 
-            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbum.isValid(), true);
             QCOMPARE(firstAlbum.title(), QStringLiteral("album1"));
 
-            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist")));
+            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbumInvalid.isValid(), false);
         }
@@ -1151,16 +1128,16 @@
             QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
             QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
 
-            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbum.isValid(), true);
             QCOMPARE(firstAlbum.title(), QStringLiteral("album1"));
 
-            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist")));
+            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbumInvalid.isValid(), false);
 
-            auto fourthAlbumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
+            auto fourthAlbumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"), QStringLiteral("/"));
             auto fourthAlbum = musicDb.albumDataFromDatabaseId(fourthAlbumId);
             auto fourthAlbumData = musicDb.albumData(fourthAlbumId);
 
@@ -1248,16 +1225,16 @@
 
             QCOMPARE(musicDb.allAlbumsData().count(), 5);
 
-            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+            auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbum.isValid(), true);
             QCOMPARE(firstAlbum.title(), QStringLiteral("album1"));
 
-            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist")));
+            auto firstAlbumInvalid = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1Invalid"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
 
             QCOMPARE(firstAlbumInvalid.isValid(), false);
 
-            auto fourthAlbumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"));
+            auto fourthAlbumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"), QStringLiteral("/"));
             auto fourthAlbum = musicDb.albumDataFromDatabaseId(fourthAlbumId);
             auto fourthAlbumData = musicDb.albumData(fourthAlbumId);
 
@@ -2381,7 +2358,7 @@
         QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
         QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
 
-        auto removedAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")));
+        auto removedAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")));
 
         QCOMPARE(removedAlbum.isValid(), false);
     }
@@ -3412,7 +3389,7 @@
         QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
         QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
 
-        const auto &newAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album7"), QStringLiteral("artist2")));
+        const auto &newAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album7"), QStringLiteral("artist2"), QStringLiteral("/")));
         QCOMPARE(newAlbum.albumArtURI(), QUrl::fromLocalFile(QStringLiteral("file://image$19")));
     }
 
@@ -3676,7 +3653,7 @@
         QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
         QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
 
-        auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Invalid Artist")));
+        auto firstAlbum = musicDb.albumDataFromDatabaseId(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Invalid Artist"), QStringLiteral("/")));
     }
 
     void addTwoIdenticalTracksWithPartialAlbumArtist()
@@ -3888,7 +3865,7 @@
         QCOMPARE(firstTrack.title(), QStringLiteral("track6"));
         QCOMPARE(firstTrack.artist(), QStringLiteral("artist4"));
         QCOMPARE(firstTrack.album(), QStringLiteral("album3"));
-        QCOMPARE(firstTrack.albumArtist(), QStringLiteral("artist4"));
+        QVERIFY(!firstTrack.albumArtist().isEmpty());
         QCOMPARE(firstTrack.albumCover(), QUrl::fromLocalFile(QStringLiteral("album3")));
         QCOMPARE(firstTrack.trackNumber(), 6);
         QCOMPARE(firstTrack.discNumber(), 1);
@@ -3919,7 +3896,7 @@
         QCOMPARE(secondTrack.lyricist(), QStringLiteral("lyricist1"));
         QCOMPARE(secondTrack.hasEmbeddedCover(), false);
 
-        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist4"));
+        auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist4"), QStringLiteral("/"));
         auto album = musicDb.albumDataFromDatabaseId(albumId);
         auto albumData = musicDb.albumData(albumId);
 
@@ -4003,7 +3980,7 @@
 
         musicDbTrackAddedSpy.wait(300);
 
-        QCOMPARE(musicDb.allAlbumsData().count(), 4);
+        QCOMPARE(musicDb.allAlbumsData().count(), 2);
         QCOMPARE(musicDb.allArtistsData().count(), 4);
         QCOMPARE(musicDb.allTracksData().count(), 4);
         QCOMPARE(musicDbArtistAddedSpy.count(), 1);
@@ -4016,17 +3993,17 @@
         QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
         QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
 
-        QCOMPARE(musicDb.allAlbumsData().size(), 4);
+        QCOMPARE(musicDb.allAlbumsData().size(), 2);
         QCOMPARE(musicDb.allArtistsData().size(), 4);
         QCOMPARE(musicDb.allTracksData().size(), 4);
 
         auto allAlbums = musicDb.allAlbumsData();
         auto firstAlbum = allAlbums[0];
         auto firstAlbumData = musicDb.albumData(firstAlbum.databaseId());
-        QCOMPARE(firstAlbumData.count(), 1);
+        QCOMPARE(firstAlbumData.count(), 2);
         auto secondAlbum = allAlbums[1];
         auto secondAlbumData = musicDb.albumData(secondAlbum.databaseId());
-        QCOMPARE(secondAlbumData.count(), 1);
+        QCOMPARE(secondAlbumData.count(), 2);
     }
 
     void addTwoAlbumsWithDifferentPathsAndSameTracks()
@@ -4114,7 +4091,7 @@
 
         musicDbTrackAddedSpy.wait(300);
 
-        QCOMPARE(musicDb.allAlbumsData().count(), 6);
+        QCOMPARE(musicDb.allAlbumsData().count(), 2);
         QCOMPARE(musicDb.allArtistsData().count(), 3);
         QCOMPARE(musicDb.allTracksData().count(), 6);
         QCOMPARE(musicDbArtistAddedSpy.count(), 1);
@@ -4130,10 +4107,10 @@
         auto allAlbums = musicDb.allAlbumsData();
         auto firstAlbum = allAlbums[0];
         auto firstAlbumData = musicDb.albumData(firstAlbum.databaseId());
-        QCOMPARE(firstAlbumData.count(), 1);
+        QCOMPARE(firstAlbumData.count(), 3);
         auto secondAlbum = allAlbums[1];
         auto secondAlbumData = musicDb.albumData(secondAlbum.databaseId());
-        QCOMPARE(secondAlbumData.count(), 1);
+        QCOMPARE(secondAlbumData.count(), 3);
     }
 
     void addTwoTracksFromSameAlbumButDifferentDiscs()
@@ -5107,6 +5084,97 @@
         QCOMPARE(secondTrackRating, 9);
         QCOMPARE(secondIsSingleDiscAlbum, true);
     }
+
+    void testCompilationWithoutAlbumArtist()
+    {
+        QTemporaryFile databaseFile;
+        databaseFile.open();
+
+        qDebug() << "testCompilationWithoutAlbumArtist" << databaseFile.fileName();
+
+        DatabaseInterface musicDb;
+
+        musicDb.init(QStringLiteral("testDb"), databaseFile.fileName());
+
+        QSignalSpy musicDbArtistAddedSpy(&musicDb, &DatabaseInterface::artistsAdded);
+        QSignalSpy musicDbAlbumAddedSpy(&musicDb, &DatabaseInterface::albumsAdded);
+        QSignalSpy musicDbTrackAddedSpy(&musicDb, &DatabaseInterface::tracksAdded);
+        QSignalSpy musicDbArtistRemovedSpy(&musicDb, &DatabaseInterface::artistRemoved);
+        QSignalSpy musicDbAlbumRemovedSpy(&musicDb, &DatabaseInterface::albumRemoved);
+        QSignalSpy musicDbTrackRemovedSpy(&musicDb, &DatabaseInterface::trackRemoved);
+        QSignalSpy musicDbAlbumModifiedSpy(&musicDb, &DatabaseInterface::albumModified);
+        QSignalSpy musicDbTrackModifiedSpy(&musicDb, &DatabaseInterface::trackModified);
+        QSignalSpy musicDbDatabaseErrorSpy(&musicDb, &DatabaseInterface::databaseError);
+
+        QCOMPARE(musicDb.allAlbumsData().count(), 0);
+        QCOMPARE(musicDb.allArtistsData().count(), 0);
+        QCOMPARE(musicDb.allTracksData().count(), 0);
+        QCOMPARE(musicDbArtistAddedSpy.count(), 0);
+        QCOMPARE(musicDbAlbumAddedSpy.count(), 0);
+        QCOMPARE(musicDbTrackAddedSpy.count(), 0);
+        QCOMPARE(musicDbArtistRemovedSpy.count(), 0);
+        QCOMPARE(musicDbAlbumRemovedSpy.count(), 0);
+        QCOMPARE(musicDbTrackRemovedSpy.count(), 0);
+        QCOMPARE(musicDbAlbumModifiedSpy.count(), 0);
+        QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
+        QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
+
+        auto newTracks = QList<MusicAudioTrack>{
+        {true, QStringLiteral("$23"), QStringLiteral("0"), QStringLiteral("track6"),
+                QStringLiteral("artist2"), QStringLiteral("album3"), {},
+                6, 1, QTime::fromMSecsSinceStartOfDay(23), {QUrl::fromLocalFile(QStringLiteral("/test/$23"))},
+                QDateTime::fromMSecsSinceEpoch(23),
+                QUrl::fromLocalFile(QStringLiteral("album3")), 5, true,
+                QStringLiteral("genre1"), QStringLiteral("composer1"), QStringLiteral("lyricist1"), false},
+        {true, QStringLiteral("$24"), QStringLiteral("0"), QStringLiteral("track7"),
+                QStringLiteral("artist3"), QStringLiteral("album3"), {},
+                7, 1, QTime::fromMSecsSinceStartOfDay(24), {QUrl::fromLocalFile(QStringLiteral("/test/$24"))},
+                QDateTime::fromMSecsSinceEpoch(24),
+                QUrl::fromLocalFile(QStringLiteral("album3")), 5, true,
+                QStringLiteral("genre1"), QStringLiteral("composer1"), QStringLiteral("lyricist1"), false},
+        {true, QStringLiteral("$25"), QStringLiteral("0"), QStringLiteral("track8"),
+                QStringLiteral("artist4"), QStringLiteral("album3"), {},
+                8, 1, QTime::fromMSecsSinceStartOfDay(25), {QUrl::fromLocalFile(QStringLiteral("/test/$25"))},
+                QDateTime::fromMSecsSinceEpoch(25),
+                QUrl::fromLocalFile(QStringLiteral("album3")), 5, true,
+                QStringLiteral("genre1"), QStringLiteral("composer1"), QStringLiteral("lyricist1"), false}};
+
+        auto newCovers = mNewCovers;
+        newCovers[QStringLiteral("/test/$23")] = QUrl::fromLocalFile(QStringLiteral("album3"));
+        newCovers[QStringLiteral("/test/$24")] = QUrl::fromLocalFile(QStringLiteral("album3"));
+        newCovers[QStringLiteral("/test/$25")] = QUrl::fromLocalFile(QStringLiteral("album3"));
+
+        musicDb.insertTracksList(newTracks, newCovers);
+
+        musicDbTrackAddedSpy.wait(300);
+
+        QCOMPARE(musicDb.allAlbumsData().count(), 1);
+        QCOMPARE(musicDb.allArtistsData().count(), 3);
+        QCOMPARE(musicDb.allTracksData().count(), 3);
+        QCOMPARE(musicDbArtistAddedSpy.count(), 1);
+        QCOMPARE(musicDbAlbumAddedSpy.count(), 1);
+        QCOMPARE(musicDbTrackAddedSpy.count(), 1);
+        QCOMPARE(musicDbArtistRemovedSpy.count(), 0);
+        QCOMPARE(musicDbAlbumRemovedSpy.count(), 0);
+        QCOMPARE(musicDbTrackRemovedSpy.count(), 0);
+        QCOMPARE(musicDbAlbumModifiedSpy.count(), 0);
+        QCOMPARE(musicDbTrackModifiedSpy.count(), 0);
+        QCOMPARE(musicDbDatabaseErrorSpy.count(), 0);
+
+        const auto newAlbumSignal = musicDbAlbumAddedSpy.at(0);
+        QCOMPARE(newAlbumSignal.size(), 1);
+        const auto newAlbums = newAlbumSignal.at(0).value<DatabaseInterface::ListAlbumDataType>();
+        QCOMPARE(newAlbums.size(), 1);
+        const auto newAlbum = newAlbums.at(0);
+        QCOMPARE(newAlbum.title(), QStringLiteral("album3"));
+        QCOMPARE(newAlbum.artist(), QStringLiteral("Various Artists"));
+        QCOMPARE(newAlbum[DatabaseInterface::ColumnsRoles::SecondaryTextRole], QStringLiteral("Various Artists"));
+
+        const auto oneAlbum = musicDb.allAlbumsData()[0];
+        QCOMPARE(oneAlbum.title(), QStringLiteral("album3"));
+        QCOMPARE(oneAlbum.artist(), QStringLiteral("Various Artists"));
+        QCOMPARE(oneAlbum[DatabaseInterface::ColumnsRoles::SecondaryTextRole], QStringLiteral("Various Artists"));
+    }
 };
 
 QTEST_GUILESS_MAIN(DatabaseInterfaceTests)
diff --git a/autotests/datamodeltest.cpp b/autotests/datamodeltest.cpp
--- a/autotests/datamodeltest.cpp
+++ b/autotests/datamodeltest.cpp
@@ -88,15 +88,15 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         albumsModel.initialize(nullptr, nullptr, ElisaUtils::Track, ElisaUtils::FilterById, {}, {},
-                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(beginRemoveRowsSpy.count(), 0);
         QCOMPARE(endRemoveRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
 
-        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"))));
+        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/"))));
 
         QCOMPARE(albumsModel.rowCount(), 4);
         QCOMPARE(beginInsertRowsSpy.count(), 1);
@@ -155,15 +155,15 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         albumsModel.initialize(nullptr, nullptr, ElisaUtils::Track, ElisaUtils::FilterById, {}, {},
-                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2")));
+                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"), QStringLiteral("/")));
 
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(beginRemoveRowsSpy.count(), 0);
         QCOMPARE(endRemoveRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
 
-        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"))));
+        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album3"), QStringLiteral("artist2"), QStringLiteral("/"))));
 
         QCOMPARE(albumsModel.rowCount(), 3);
         QCOMPARE(beginInsertRowsSpy.count(), 1);
@@ -236,15 +236,15 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         albumsModel.initialize(nullptr, nullptr, ElisaUtils::Track, ElisaUtils::FilterById, {}, {},
-                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(beginRemoveRowsSpy.count(), 0);
         QCOMPARE(endRemoveRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
 
-        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"))));
+        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/"))));
 
         QCOMPARE(albumsModel.rowCount(), 4);
         QCOMPARE(beginInsertRowsSpy.count(), 1);
@@ -352,15 +352,15 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         albumsModel.initialize(nullptr, nullptr, ElisaUtils::Track, ElisaUtils::FilterById, {}, {},
-                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(beginRemoveRowsSpy.count(), 0);
         QCOMPARE(endRemoveRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
 
-        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"))));
+        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/"))));
 
         QCOMPARE(albumsModel.rowCount(), 4);
         QCOMPARE(beginInsertRowsSpy.count(), 1);
@@ -1444,7 +1444,8 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         auto albumId = musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"),
-                                                         QStringLiteral("Various Artists"));
+                                                         QStringLiteral("Various Artists"),
+                                                         QStringLiteral("/"));
 
         QVERIFY(albumId != 0);
 
@@ -1534,15 +1535,15 @@
         QCOMPARE(dataChangedSpy.count(), 0);
 
         albumsModel.initialize(nullptr, nullptr, ElisaUtils::Track, ElisaUtils::FilterById, {}, {},
-                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")));
+                               musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")));
 
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(beginRemoveRowsSpy.count(), 0);
         QCOMPARE(endRemoveRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
 
-        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"))));
+        albumsModel.tracksAdded(musicDb.albumData(musicDb.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/"))));
 
         QCOMPARE(albumsModel.rowCount(), 4);
         QCOMPARE(beginInsertRowsSpy.count(), 1);
diff --git a/autotests/mediaplaylisttest.cpp b/autotests/mediaplaylisttest.cpp
--- a/autotests/mediaplaylisttest.cpp
+++ b/autotests/mediaplaylisttest.cpp
@@ -188,7 +188,7 @@
     QCOMPARE(newTrackByNameInListSpy.count(), 0);
     QCOMPARE(newEntryInListSpy.count(), 0);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")),
                         QStringLiteral("album2")},
                        ElisaUtils::Album);
 
@@ -316,7 +316,7 @@
     QCOMPARE(newEntryInListSpy.count(), 0);
     QCOMPARE(currentTrackChangedSpy.count(), 0);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")),
                         QStringLiteral("album2")},
                        ElisaUtils::Album);
 
@@ -462,7 +462,7 @@
     QCOMPARE(newEntryInListSpy.count(), 0);
     QCOMPARE(currentTrackChangedSpy.count(), 0);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")),
                         QStringLiteral("album2")},
                        ElisaUtils::Album);
 
@@ -667,7 +667,7 @@
     QCOMPARE(newEntryInListSpy.count(), 0);
     QCOMPARE(currentTrackChangedSpy.count(), 0);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")),
                         QStringLiteral("album2")},
                        ElisaUtils::Album);
 
@@ -727,7 +727,7 @@
 
     QCOMPARE(myPlayList.currentTrack(), QPersistentModelIndex(myPlayList.index(0, 0)));
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")),
                         QStringLiteral("album1")},
                        ElisaUtils::Album,
                        ElisaUtils::ReplacePlayList,
@@ -1023,7 +1023,7 @@
     QCOMPARE(newTrackByNameInListSpy.count(), 0);
     QCOMPARE(newEntryInListSpy.count(), 0);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album2"), QStringLiteral("artist1"), QStringLiteral("/")),
                         QStringLiteral("album2")},
                        ElisaUtils::Album);
 
@@ -2632,7 +2632,7 @@
     QCOMPARE(myPlayList.data(myPlayList.index(1, 0), MediaPlayList::TrackNumberRole).toInt(), 1);
     QCOMPARE(myPlayList.data(myPlayList.index(1, 0), MediaPlayList::DiscNumberRole).toInt(), 1);
 
-    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists")),
+    myPlayList.enqueue({myDatabaseContent.albumIdFromTitleAndArtist(QStringLiteral("album1"), QStringLiteral("Various Artists"), QStringLiteral("/")),
                         QStringLiteral("album1")},
                        ElisaUtils::Album,
                        ElisaUtils::ReplacePlayList,
diff --git a/src/databaseinterface.h b/src/databaseinterface.h
--- a/src/databaseinterface.h
+++ b/src/databaseinterface.h
@@ -60,6 +60,7 @@
         HighestTrackRating,
         AlbumRole,
         AlbumArtistRole,
+        IsValidAlbumArtistRole,
         TrackNumberRole,
         DiscNumberRole,
         RatingRole,
@@ -352,7 +353,7 @@
 
     Q_INVOKABLE void init(const QString &dbName, const QString &databaseFileName = {});
 
-    qulonglong albumIdFromTitleAndArtist(const QString &title, const QString &artist);
+    qulonglong albumIdFromTitleAndArtist(const QString &title, const QString &artist, const QString &albumPath);
 
     ListTrackDataType allTracksData();
 
@@ -458,7 +459,7 @@
 
     QList<qulonglong> fetchTrackIds(qulonglong albumId);
 
-    qulonglong internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist);
+    qulonglong internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist, const QString &albumPath);
 
     MusicAudioTrack internalTrackFromDatabaseId(qulonglong id);
 
@@ -479,7 +480,7 @@
 
     void initRequest();
 
-    qulonglong insertAlbum(const QString &title, const QString &albumArtist, const QString &trackArtist,
+    qulonglong insertAlbum(const QString &title, const QString &albumArtist,
                            const QString &trackPath, const QUrl &albumArtURI);
 
     bool updateAlbumFromId(qulonglong albumId, const QUrl &albumArtUri,
diff --git a/src/databaseinterface.cpp b/src/databaseinterface.cpp
--- a/src/databaseinterface.cpp
+++ b/src/databaseinterface.cpp
@@ -322,16 +322,16 @@
     }
 }
 
-qulonglong DatabaseInterface::albumIdFromTitleAndArtist(const QString &title, const QString &artist)
+qulonglong DatabaseInterface::albumIdFromTitleAndArtist(const QString &title, const QString &artist, const QString &albumPath)
 {
     auto result = qulonglong{0};
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
-    result = internalAlbumIdFromTitleAndArtist(title, artist);
+    result = internalAlbumIdFromTitleAndArtist(title, artist, albumPath);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
@@ -2935,6 +2935,7 @@
                                                    ") AND "
                                                    "tracks2.`AlbumPath` = album.`AlbumPath` "
                                                    ") as `IsSingleDiscAlbum`, "
+                                                   "COUNT(DISTINCT tracks.`ArtistName`) as ArtistsCount, "
                                                    "GROUP_CONCAT(tracks.`ArtistName`, ', ') as AllArtists, "
                                                    "MAX(tracks.`Rating`) as HighestRating, "
                                                    "GROUP_CONCAT(genres.`Name`, ', ') as AllGenres, "
@@ -3004,6 +3005,7 @@
                                                   "album.`ArtistName` as SecondaryText, "
                                                   "album.`CoverFileName`, "
                                                   "album.`ArtistName`, "
+                                                  "COUNT(DISTINCT tracks.`ArtistName`) as ArtistsCount, "
                                                   "GROUP_CONCAT(tracks.`ArtistName`, ', ') as AllArtists, "
                                                   "MAX(tracks.`Rating`) as HighestRating, "
                                                   "GROUP_CONCAT(genres.`Name`, ', ') as AllGenres, "
@@ -3067,6 +3069,7 @@
                                                   "album.`ArtistName` as SecondaryText, "
                                                   "album.`CoverFileName`, "
                                                   "album.`ArtistName`, "
+                                                  "COUNT(DISTINCT tracks.`ArtistName`) as ArtistsCount, "
                                                   "GROUP_CONCAT(tracks.`ArtistName`, ', ') as AllArtists, "
                                                   "MAX(tracks.`Rating`) as HighestRating, "
                                                   "GROUP_CONCAT(genres.`Name`, ', ') as AllGenres, "
@@ -3142,6 +3145,7 @@
                                                   "album.`ArtistName` as SecondaryText, "
                                                   "album.`CoverFileName`, "
                                                   "album.`ArtistName`, "
+                                                  "COUNT(DISTINCT tracks.`ArtistName`) as ArtistsCount, "
                                                   "GROUP_CONCAT(tracks.`ArtistName`, ', ') as AllArtists, "
                                                   "MAX(tracks.`Rating`) as HighestRating, "
                                                   "GROUP_CONCAT(genres.`Name`, ', ') as AllGenres, "
@@ -3324,6 +3328,34 @@
                                                   "tracks.`Title`, "
                                                   "album.`ID`, "
                                                   "tracks.`ArtistName`, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum1 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS ArtistsCount, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum2 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS AllArtists, "
                                                   "tracks.`AlbumArtistName`, "
                                                   "tracksMapping.`FileName`, "
                                                   "tracksMapping.`FileModifiedTime`, "
@@ -3419,6 +3451,34 @@
                                                   "tracks.`Title`, "
                                                   "album.`ID`, "
                                                   "tracks.`ArtistName`, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum1 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS ArtistsCount, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum2 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS AllArtists, "
                                                   "tracks.`AlbumArtistName`, "
                                                   "tracksMapping.`FileName`, "
                                                   "tracksMapping.`FileModifiedTime`, "
@@ -3516,6 +3576,34 @@
                                                   "tracks.`Title`, "
                                                   "album.`ID`, "
                                                   "tracks.`ArtistName`, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum1 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS ArtistsCount, "
+                                                  "( "
+                                                  "SELECT "
+                                                  "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                  "FROM "
+                                                  "`Tracks` tracksFromAlbum2 "
+                                                  "WHERE "
+                                                  "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                  "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                  "album.`ArtistName` IS NULL "
+                                                  ") "
+                                                  ") AND "
+                                                  "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                  ") AS AllArtists, "
                                                   "tracks.`AlbumArtistName`, "
                                                   "tracksMapping.`FileName`, "
                                                   "tracksMapping.`FileModifiedTime`, "
@@ -3691,6 +3779,34 @@
                                                        "tracks.`Title`, "
                                                        "tracks.`ArtistName`, "
                                                        "tracks.`AlbumTitle`, "
+                                                       "( "
+                                                       "SELECT "
+                                                       "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                       "FROM "
+                                                       "`Tracks` tracksFromAlbum1 "
+                                                       "WHERE "
+                                                       "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                       "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                       "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                       "album.`ArtistName` IS NULL "
+                                                       ") "
+                                                       ") AND "
+                                                       "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                       ") AS ArtistsCount, "
+                                                       "( "
+                                                       "SELECT "
+                                                       "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                       "FROM "
+                                                       "`Tracks` tracksFromAlbum2 "
+                                                       "WHERE "
+                                                       "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                       "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                       "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                       "album.`ArtistName` IS NULL "
+                                                       ") "
+                                                       ") AND "
+                                                       "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                       ") AS AllArtists, "
                                                        "tracks.`AlbumArtistName`, "
                                                        "tracks.`Duration`, "
                                                        "album.`CoverFileName`, "
@@ -3839,6 +3955,34 @@
                                                    "tracks.`Title`, "
                                                    "album.`ID`, "
                                                    "tracks.`ArtistName`, "
+                                                   "( "
+                                                   "SELECT "
+                                                   "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                   "FROM "
+                                                   "`Tracks` tracksFromAlbum1 "
+                                                   "WHERE "
+                                                   "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                   "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                   "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                   "album.`ArtistName` IS NULL "
+                                                   ") "
+                                                   ") AND "
+                                                   "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                   ") AS ArtistsCount, "
+                                                   "( "
+                                                   "SELECT "
+                                                   "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                   "FROM "
+                                                   "`Tracks` tracksFromAlbum2 "
+                                                   "WHERE "
+                                                   "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                   "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                   "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                   "album.`ArtistName` IS NULL "
+                                                   ") "
+                                                   ") AND "
+                                                   "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                   ") AS AllArtists, "
                                                    "tracks.`AlbumArtistName`, "
                                                    "tracksMapping.`FileName`, "
                                                    "tracksMapping.`FileModifiedTime`, "
@@ -3978,6 +4122,34 @@
                                                          "tracks.`Title`, "
                                                          "album.`ID`, "
                                                          "tracks.`ArtistName`, "
+                                                         "( "
+                                                         "SELECT "
+                                                         "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                         "FROM "
+                                                         "`Tracks` tracksFromAlbum1 "
+                                                         "WHERE "
+                                                         "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                         "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                         "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                         "album.`ArtistName` IS NULL "
+                                                         ") "
+                                                         ") AND "
+                                                         "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                         ") AS ArtistsCount, "
+                                                         "( "
+                                                         "SELECT "
+                                                         "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                         "FROM "
+                                                         "`Tracks` tracksFromAlbum2 "
+                                                         "WHERE "
+                                                         "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                         "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                         "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                         "album.`ArtistName` IS NULL "
+                                                         ") "
+                                                         ") AND "
+                                                         "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                         ") AS AllArtists, "
                                                          "tracks.`AlbumArtistName`, "
                                                          "tracksMapping.`FileName`, "
                                                          "tracksMapping.`FileModifiedTime`, "
@@ -4199,7 +4371,7 @@
                                                                        "FROM "
                                                                        "`Albums` album "
                                                                        "WHERE "
-                                                                       "album.`ArtistName` = :artistName AND "
+                                                                       "(album.`ArtistName` = :artistName OR :artistName IS NULL OR album.`ArtistName` IS NULL) AND "
                                                                        "album.`Title` = :title AND "
                                                                        "album.`AlbumPath` = :albumPath");
 
@@ -4342,6 +4514,34 @@
                                                                   "tracks.`Title`, "
                                                                   "album.`ID`, "
                                                                   "tracks.`ArtistName`, "
+                                                                  "( "
+                                                                  "SELECT "
+                                                                  "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                                  "FROM "
+                                                                  "`Tracks` tracksFromAlbum1 "
+                                                                  "WHERE "
+                                                                  "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                                  "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                                  "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                                  "album.`ArtistName` IS NULL "
+                                                                  ") "
+                                                                  ") AND "
+                                                                  "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                                  ") AS ArtistsCount, "
+                                                                  "( "
+                                                                  "SELECT "
+                                                                  "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                                  "FROM "
+                                                                  "`Tracks` tracksFromAlbum2 "
+                                                                  "WHERE "
+                                                                  "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                                  "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                                  "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                                  "album.`ArtistName` IS NULL "
+                                                                  ") "
+                                                                  ") AND "
+                                                                  "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                                  ") AS AllArtists, "
                                                                   "tracks.`AlbumArtistName`, "
                                                                   "\"\" as FileName, "
                                                                   "NULL as FileModifiedTime, "
@@ -4879,6 +5079,34 @@
                                                               "tracks.`Title`, "
                                                               "album.`ID`, "
                                                               "tracks.`ArtistName`, "
+                                                              "( "
+                                                              "SELECT "
+                                                              "COUNT(DISTINCT tracksFromAlbum1.`ArtistName`) "
+                                                              "FROM "
+                                                              "`Tracks` tracksFromAlbum1 "
+                                                              "WHERE "
+                                                              "tracksFromAlbum1.`AlbumTitle` = album.`Title` AND "
+                                                              "(tracksFromAlbum1.`AlbumArtistName` = album.`ArtistName` OR "
+                                                              "(tracksFromAlbum1.`AlbumArtistName` IS NULL AND "
+                                                              "album.`ArtistName` IS NULL "
+                                                              ") "
+                                                              ") AND "
+                                                              "tracksFromAlbum1.`AlbumPath` = album.`AlbumPath` "
+                                                              ") AS ArtistsCount, "
+                                                              "( "
+                                                              "SELECT "
+                                                              "GROUP_CONCAT(tracksFromAlbum2.`ArtistName`) "
+                                                              "FROM "
+                                                              "`Tracks` tracksFromAlbum2 "
+                                                              "WHERE "
+                                                              "tracksFromAlbum2.`AlbumTitle` = album.`Title` AND "
+                                                              "(tracksFromAlbum2.`AlbumArtistName` = album.`ArtistName` OR "
+                                                              "(tracksFromAlbum2.`AlbumArtistName` IS NULL AND "
+                                                              "album.`ArtistName` IS NULL "
+                                                              ") "
+                                                              ") AND "
+                                                              "tracksFromAlbum2.`AlbumPath` = album.`AlbumPath` "
+                                                              ") AS AllArtists, "
                                                               "tracks.`AlbumArtistName`, "
                                                               "tracksMapping.`FileName`, "
                                                               "tracksMapping.`FileModifiedTime`, "
@@ -5139,93 +5367,60 @@
     Q_EMIT requestsInitDone();
 }
 
-qulonglong DatabaseInterface::insertAlbum(const QString &title, const QString &albumArtist, const QString &trackArtist,
+qulonglong DatabaseInterface::insertAlbum(const QString &title, const QString &albumArtist,
                                           const QString &trackPath, const QUrl &albumArtURI)
 {
     auto result = qulonglong(0);
 
     if (title.isEmpty()) {
         return result;
     }
 
-    if (!albumArtist.isEmpty() || !trackArtist.isEmpty()) {
-        d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":title"), title);
-        d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":albumPath"), trackPath);
-        if (!albumArtist.isEmpty()) {
-            d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":artistName"), albumArtist);
-        } else {
-            d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":artistName"), trackArtist);
-        }
-
-        auto queryResult = execQuery(d->mSelectAlbumIdFromTitleAndArtistQuery);
+    d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":title"), title);
+    d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":albumPath"), trackPath);
+    d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":artistName"), albumArtist);
 
-        if (!queryResult || !d->mSelectAlbumIdFromTitleAndArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleAndArtistQuery.isActive()) {
-            Q_EMIT databaseError();
-
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastQuery();
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.boundValues();
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastError();
-
-            d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
-
-            return result;
-        }
+    auto queryResult = execQuery(d->mSelectAlbumIdFromTitleAndArtistQuery);
 
-        if (d->mSelectAlbumIdFromTitleAndArtistQuery.next()) {
-            result = d->mSelectAlbumIdFromTitleAndArtistQuery.record().value(0).toULongLong();
+    if (!queryResult || !d->mSelectAlbumIdFromTitleAndArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleAndArtistQuery.isActive()) {
+        Q_EMIT databaseError();
 
-            d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
-
-            return result;
-        }
+        qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastQuery();
+        qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.boundValues();
+        qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastError();
 
         d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
-    }
-
-    if (result == 0) {
-        d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":title"), title);
-        d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":albumPath"), trackPath);
-
-        auto queryResult = execQuery(d->mSelectAlbumIdFromTitleWithoutArtistQuery);
-
-        if (!queryResult || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isActive()) {
-            Q_EMIT databaseError();
-
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastQuery();
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.boundValues();
-            qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastError();
-
-            d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
 
-            return result;
-        }
+        return result;
+    }
 
-        if (d->mSelectAlbumIdFromTitleWithoutArtistQuery.next()) {
-            result = d->mSelectAlbumIdFromTitleWithoutArtistQuery.record().value(0).toULongLong();
+    if (d->mSelectAlbumIdFromTitleAndArtistQuery.next()) {
+        result = d->mSelectAlbumIdFromTitleAndArtistQuery.record().value(0).toULongLong();
 
-            d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
+        d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
 
-            return result;
+        if (!albumArtist.isEmpty()) {
+            const auto similarAlbum = internalOneAlbumPartialData(result);
+            updateAlbumArtist(result, title, trackPath, albumArtist);
         }
 
-        d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
+        return result;
     }
 
+    d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
+
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumId"), d->mAlbumId);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":title"), title);
     if (!albumArtist.isEmpty()) {
         insertArtist(albumArtist);
         d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumArtist"), albumArtist);
-    } else if (!trackArtist.isEmpty()) {
-        insertArtist(trackArtist);
-        d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumArtist"), trackArtist);
     } else {
         d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumArtist"), {});
     }
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumPath"), trackPath);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":coverFileName"), albumArtURI);
 
-    auto queryResult = execQuery(d->mInsertAlbumQuery);
+    queryResult = execQuery(d->mInsertAlbumQuery);
 
     if (!queryResult || !d->mInsertAlbumQuery.isActive()) {
         Q_EMIT databaseError();
@@ -5550,7 +5745,7 @@
     }
 
     auto albumId = insertAlbum(oneTrack.albumName(), (oneTrack.isValidAlbumArtist() ? oneTrack.albumArtist() : QString()),
-                               oneTrack.artist(), trackPath, albumCover);
+                               trackPath, albumCover);
 
     auto oldAlbumId = albumId;
 
@@ -5655,8 +5850,12 @@
     d->mInsertTrackQuery.bindValue(QStringLiteral(":title"), oneTrack.title());
     insertArtist(oneTrack.artist());
     d->mInsertTrackQuery.bindValue(QStringLiteral(":artistName"), oneTrack.artist());
-    d->mInsertTrackQuery.bindValue(QStringLiteral(":albumTitle"), albumData[AlbumDataType::key_type::TitleRole]);
-    d->mInsertTrackQuery.bindValue(QStringLiteral(":albumArtistName"), albumData[AlbumDataType::key_type::ArtistRole]);
+    d->mInsertTrackQuery.bindValue(QStringLiteral(":albumTitle"), oneTrack.albumName());
+    if (oneTrack.isValidAlbumArtist()) {
+        d->mInsertTrackQuery.bindValue(QStringLiteral(":albumArtistName"), oneTrack.albumArtist());
+    } else {
+        d->mInsertTrackQuery.bindValue(QStringLiteral(":albumArtistName"), {});
+    }
     d->mInsertTrackQuery.bindValue(QStringLiteral(":albumPath"), trackPath);
     if (oneTrack.trackNumberIsValid()) {
         d->mInsertTrackQuery.bindValue(QStringLiteral(":trackNumber"), oneTrack.trackNumber());
@@ -5765,51 +5964,57 @@
     result.setParentId(trackRecord.value(2).toString());
     result.setArtist(trackRecord.value(3).toString());
 
-    if (trackRecord.value(4).isValid()) {
-        result.setAlbumArtist(trackRecord.value(4).toString());
-    }
-
-    result.setResourceURI(trackRecord.value(5).toUrl());
-    result.setFileModificationTime(trackRecord.value(6).toDateTime());
-    if (trackRecord.value(7).isValid()) {
-        result.setTrackNumber(trackRecord.value(7).toInt());
-    }
-    if (trackRecord.value(8).isValid()) {
-        result.setDiscNumber(trackRecord.value(8).toInt());
-    }
-    result.setDuration(QTime::fromMSecsSinceStartOfDay(trackRecord.value(9).toInt()));
-    result.setAlbumName(trackRecord.value(10).toString());
-    result.setRating(trackRecord.value(11).toInt());
-    result.setAlbumCover(trackRecord.value(12).toUrl());
-    result.setIsSingleDiscAlbum(trackRecord.value(13).toBool());
-    result.setGenre(trackRecord.value(14).toString());
-    result.setComposer(trackRecord.value(15).toString());
-    result.setLyricist(trackRecord.value(16).toString());
-    result.setComment(trackRecord.value(17).toString());
-    result.setYear(trackRecord.value(18).toInt());
-    if (trackRecord.value(19).isValid()) {
+    if (trackRecord.value(6).isValid()) {
+        result.setAlbumArtist(trackRecord.value(6).toString());
+    } else {
+        if (trackRecord.value(5).toInt() == 1) {
+            result.setAlbumArtist(trackRecord.value(6).toString());
+        } else if (trackRecord.value(5).toInt() > 1) {
+            result.setAlbumArtist(QStringLiteral("Various Artists"));
+        }
+    }
+
+    result.setResourceURI(trackRecord.value(7).toUrl());
+    result.setFileModificationTime(trackRecord.value(8).toDateTime());
+    if (trackRecord.value(9).isValid()) {
+        result.setTrackNumber(trackRecord.value(9).toInt());
+    }
+    if (trackRecord.value(10).isValid()) {
+        result.setDiscNumber(trackRecord.value(10).toInt());
+    }
+    result.setDuration(QTime::fromMSecsSinceStartOfDay(trackRecord.value(11).toInt()));
+    result.setAlbumName(trackRecord.value(12).toString());
+    result.setRating(trackRecord.value(13).toInt());
+    result.setAlbumCover(trackRecord.value(14).toUrl());
+    result.setIsSingleDiscAlbum(trackRecord.value(15).toBool());
+    result.setGenre(trackRecord.value(16).toString());
+    result.setComposer(trackRecord.value(17).toString());
+    result.setLyricist(trackRecord.value(18).toString());
+    result.setComment(trackRecord.value(19).toString());
+    result.setYear(trackRecord.value(20).toInt());
+    if (trackRecord.value(21).isValid()) {
         bool isValid;
-        auto value = trackRecord.value(19).toInt(&isValid);
+        auto value = trackRecord.value(21).toInt(&isValid);
         if (isValid) {
             result.setChannels(value);
         }
     }
-    if (trackRecord.value(20).isValid()) {
+    if (trackRecord.value(22).isValid()) {
         bool isValid;
-        auto value = trackRecord.value(20).toInt(&isValid);
+        auto value = trackRecord.value(22).toInt(&isValid);
         if (isValid) {
             result.setBitRate(value);
         }
     }
-    if (trackRecord.value(21).isValid()) {
+    if (trackRecord.value(23).isValid()) {
         bool isValid;
-        auto value = trackRecord.value(21).toInt(&isValid);
+        auto value = trackRecord.value(23).toInt(&isValid);
         if (isValid) {
             result.setSampleRate(value);
         }
     }
     result.setAlbumId(trackRecord.value(2).toULongLong());
-    result.setHasEmbeddedCover(trackRecord.value(22).toBool());
+    result.setHasEmbeddedCover(trackRecord.value(24).toBool());
 
     result.setValid(true);
 
@@ -5822,51 +6027,61 @@
 
     result[TrackDataType::key_type::DatabaseIdRole] = trackRecord.value(0);
     result[TrackDataType::key_type::TitleRole] = trackRecord.value(1);
-    if (!trackRecord.value(10).isNull()) {
-        result[TrackDataType::key_type::AlbumRole] = trackRecord.value(10);
+    if (!trackRecord.value(12).isNull()) {
+        result[TrackDataType::key_type::AlbumRole] = trackRecord.value(12);
         result[TrackDataType::key_type::AlbumIdRole] = trackRecord.value(2);
     }
     if (!trackRecord.value(3).isNull()) {
         result[TrackDataType::key_type::ArtistRole] = trackRecord.value(3);
     }
-    if (!trackRecord.value(4).isNull()) {
-        result[TrackDataType::key_type::AlbumArtistRole] = trackRecord.value(4);
+
+    if (!trackRecord.value(6).isNull()) {
+        result[TrackDataType::key_type::IsValidAlbumArtistRole] = true;
+        result[TrackDataType::key_type::AlbumArtistRole] = trackRecord.value(6);
+    } else {
+        result[TrackDataType::key_type::IsValidAlbumArtistRole] = false;
+        if (trackRecord.value(4).toInt() == 1) {
+            result[TrackDataType::key_type::AlbumArtistRole] = trackRecord.value(3);
+        } else if (trackRecord.value(4).toInt() > 1) {
+            result[TrackDataType::key_type::AlbumArtistRole] = QStringLiteral("Various Artists");
+        }
     }
-    result[TrackDataType::key_type::ResourceRole] = trackRecord.value(5);
-    if (!trackRecord.value(7).isNull()) {
-        result[TrackDataType::key_type::TrackNumberRole] = trackRecord.value(7);
+
+    result[TrackDataType::key_type::ResourceRole] = trackRecord.value(7);
+    if (!trackRecord.value(9).isNull()) {
+        result[TrackDataType::key_type::TrackNumberRole] = trackRecord.value(9);
     }
-    if (!trackRecord.value(8).isNull()) {
-        result[TrackDataType::key_type::DiscNumberRole] = trackRecord.value(8);
+    if (!trackRecord.value(10).isNull()) {
+        result[TrackDataType::key_type::DiscNumberRole] = trackRecord.value(10);
     }
-    result[TrackDataType::key_type::DurationRole] = QTime::fromMSecsSinceStartOfDay(trackRecord.value(9).toInt());
-    result[TrackDataType::key_type::MilliSecondsDurationRole] = trackRecord.value(9).toInt();
-    result[TrackDataType::key_type::RatingRole] = trackRecord.value(11);
-    if (!trackRecord.value(12).toString().isEmpty()) {
-        result[TrackDataType::key_type::ImageUrlRole] = QUrl(trackRecord.value(12).toString());
-    } else if (!trackRecord.value(28).toString().isEmpty()) {
-        result[TrackDataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + trackRecord.value(28).toUrl().toLocalFile()};
+    result[TrackDataType::key_type::DurationRole] = QTime::fromMSecsSinceStartOfDay(trackRecord.value(11).toInt());
+    result[TrackDataType::key_type::MilliSecondsDurationRole] = trackRecord.value(11).toInt();
+    result[TrackDataType::key_type::RatingRole] = trackRecord.value(13);
+    if (!trackRecord.value(14).toString().isEmpty()) {
+        result[TrackDataType::key_type::ImageUrlRole] = QUrl(trackRecord.value(14).toString());
+    } else if (!trackRecord.value(30).toString().isEmpty()) {
+        result[TrackDataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + trackRecord.value(30).toUrl().toLocalFile()};
     }
-    result[TrackDataType::key_type::IsSingleDiscAlbumRole] = trackRecord.value(13);
-    if (!trackRecord.value(14).isNull()) {
-        result[TrackDataType::key_type::GenreRole] = trackRecord.value(14);
+    result[TrackDataType::key_type::IsSingleDiscAlbumRole] = trackRecord.value(15);
+    if (!trackRecord.value(16).isNull()) {
+        result[TrackDataType::key_type::GenreRole] = trackRecord.value(16);
     }
-    if (!trackRecord.value(15).isNull()) {
-        result[TrackDataType::key_type::ComposerRole] = trackRecord.value(15);
+    if (!trackRecord.value(17).isNull()) {
+        result[TrackDataType::key_type::ComposerRole] = trackRecord.value(17);
     }
-    if (!trackRecord.value(16).isNull()) {
-        result[TrackDataType::key_type::LyricistRole] = trackRecord.value(16);
+    if (!trackRecord.value(18).isNull()) {
+        result[TrackDataType::key_type::LyricistRole] = trackRecord.value(18);
     }
-    result[TrackDataType::key_type::HasEmbeddedCover] = trackRecord.value(22);
-    result[TrackDataType::key_type::FileModificationTime] = trackRecord.value(6);
-    if (!trackRecord.value(24).isNull()) {
-        result[TrackDataType::key_type::FirstPlayDate] = trackRecord.value(24);
+    result[TrackDataType::key_type::HasEmbeddedCover] = trackRecord.value(24);
+    result[TrackDataType::key_type::FileModificationTime] = trackRecord.value(8);
+    if (!trackRecord.value(26).isNull()) {
+        result[TrackDataType::key_type::FirstPlayDate] = trackRecord.value(26);
     }
-    if (!trackRecord.value(25).isNull()) {
-        result[TrackDataType::key_type::LastPlayDate] = trackRecord.value(25);
+    if (!trackRecord.value(27).isNull()) {
+        result[TrackDataType::key_type::LastPlayDate] = trackRecord.value(27);
     }
-    result[TrackDataType::key_type::PlayCounter] = trackRecord.value(26);
-    result[TrackDataType::key_type::PlayFrequency] = trackRecord.value(27);
+    result[TrackDataType::key_type::PlayCounter] = trackRecord.value(28);
+    result[TrackDataType::key_type::PlayFrequency] = trackRecord.value(29);
     result[DataType::key_type::ElementTypeRole] = ElisaUtils::Track;
 
     return result;
@@ -5890,11 +6105,11 @@
 
         removeTrackInDatabase(removedTrackId);
 
-        const auto &modifiedAlbumId = internalAlbumIdFromTitleAndArtist(oneRemovedTrack.albumName(), oneRemovedTrack.albumArtist());
+        const auto &trackPath = oneRemovedTrack.resourceURI().toString(currentOptions);
+        const auto &modifiedAlbumId = internalAlbumIdFromTitleAndArtist(oneRemovedTrack.albumName(), oneRemovedTrack.albumArtist(), trackPath);
         const auto &allTracksFromArtist = internalTracksFromAuthor(oneRemovedTrack.artist());
         const auto &allAlbumsFromArtist = internalAlbumIdsFromAuthor(oneRemovedTrack.artist());
         const auto &removedArtistId = internalArtistIdFromName(oneRemovedTrack.artist());
-        const auto &trackPath = oneRemovedTrack.resourceURI().toString(currentOptions);
 
         if (modifiedAlbumId) {
             recordModifiedAlbum(modifiedAlbumId);
@@ -6374,7 +6589,7 @@
     return allTracks;
 }
 
-qulonglong DatabaseInterface::internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist)
+qulonglong DatabaseInterface::internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist, const QString &albumPath)
 {
     auto result = qulonglong(0);
 
@@ -6403,6 +6618,7 @@
 
     if (result == 0) {
         d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":title"), title);
+        d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":albumPath"), albumPath);
 
         auto queryResult = execQuery(d->mSelectAlbumIdFromTitleWithoutArtistQuery);
 
@@ -6699,17 +6915,27 @@
 
         newData[DataType::key_type::DatabaseIdRole] = currentRecord.value(0);
         newData[DataType::key_type::TitleRole] = currentRecord.value(1);
-        newData[DataType::key_type::SecondaryTextRole] = currentRecord.value(2);
         if (!currentRecord.value(3).toString().isEmpty()) {
             newData[DataType::key_type::ImageUrlRole] = currentRecord.value(3);
-        } else if (!currentRecord.value(9).toString().isEmpty()) {
-            newData[DataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + currentRecord.value(9).toUrl().toLocalFile()};
-        }
-        newData[DataType::key_type::ArtistRole] = currentRecord.value(4);
-        newData[DataType::key_type::AllArtistsRole] = QVariant::fromValue(currentRecord.value(5).toString().split(QStringLiteral(", ")));
-        newData[DataType::key_type::HighestTrackRating] = currentRecord.value(6);
-        newData[DataType::key_type::IsSingleDiscAlbumRole] = currentRecord.value(8);
-        newData[DataType::key_type::GenreRole] = QVariant::fromValue(currentRecord.value(7).toString().split(QStringLiteral(", ")));
+        } else if (!currentRecord.value(10).toString().isEmpty()) {
+            newData[DataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + currentRecord.value(10).toUrl().toLocalFile()};
+        }
+        newData[DataType::key_type::AllArtistsRole] = QVariant::fromValue(currentRecord.value(6).toString().split(QStringLiteral(", ")));
+        if (!currentRecord.value(4).isNull()) {
+            newData[DataType::key_type::IsValidAlbumArtistRole] = true;
+            newData[DataType::key_type::SecondaryTextRole] = currentRecord.value(4);
+        } else {
+            newData[DataType::key_type::IsValidAlbumArtistRole] = false;
+            if (currentRecord.value(5).toInt() == 1) {
+                newData[DataType::key_type::SecondaryTextRole] = currentRecord.value(6);
+            } else if (currentRecord.value(5).toInt() > 1) {
+                newData[DataType::key_type::SecondaryTextRole] = QStringLiteral("Various Artists");
+            }
+        }
+        newData[DataType::key_type::ArtistRole] = newData[DataType::key_type::SecondaryTextRole];
+        newData[DataType::key_type::HighestTrackRating] = currentRecord.value(7);
+        newData[DataType::key_type::IsSingleDiscAlbumRole] = currentRecord.value(9);
+        newData[DataType::key_type::GenreRole] = QVariant::fromValue(currentRecord.value(8).toString().split(QStringLiteral(", ")));
         newData[DataType::key_type::ElementTypeRole] = ElisaUtils::Album;
 
         result.push_back(newData);
@@ -6735,17 +6961,28 @@
 
         result[DataType::key_type::DatabaseIdRole] = currentRecord.value(0);
         result[DataType::key_type::TitleRole] = currentRecord.value(1);
-        result[DataType::key_type::SecondaryTextRole] = currentRecord.value(2);
         if (!currentRecord.value(4).toString().isEmpty()) {
             result[DataType::key_type::ImageUrlRole] = currentRecord.value(4);
-        } else if (!currentRecord.value(10).toString().isEmpty()) {
-            result[DataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + currentRecord.value(10).toUrl().toLocalFile()};
+        } else if (!currentRecord.value(11).toString().isEmpty()) {
+            result[DataType::key_type::ImageUrlRole] = QVariant{QStringLiteral("image://cover/") + currentRecord.value(11).toUrl().toLocalFile()};
+        }
+
+        if (!currentRecord.value(2).isNull()) {
+            result[DataType::key_type::IsValidAlbumArtistRole] = true;
+            result[DataType::key_type::SecondaryTextRole] = currentRecord.value(2);
+        } else {
+            result[DataType::key_type::IsValidAlbumArtistRole] = false;
+            if (currentRecord.value(7).toInt() == 1) {
+                result[DataType::key_type::SecondaryTextRole] = currentRecord.value(8);
+            } else if (currentRecord.value(7).toInt() > 1) {
+                result[DataType::key_type::SecondaryTextRole] = QStringLiteral("Various Artists");
+            }
         }
-        result[DataType::key_type::ArtistRole] = currentRecord.value(2);
-        result[DataType::key_type::AllArtistsRole] = QVariant::fromValue(currentRecord.value(7).toString().split(QStringLiteral(", ")));
-        result[DataType::key_type::HighestTrackRating] = currentRecord.value(8);
+        result[DataType::key_type::ArtistRole] = result[DataType::key_type::SecondaryTextRole];
+        result[DataType::key_type::AllArtistsRole] = QVariant::fromValue(currentRecord.value(8).toString().split(QStringLiteral(", ")));
+        result[DataType::key_type::HighestTrackRating] = currentRecord.value(9);
         result[DataType::key_type::IsSingleDiscAlbumRole] = currentRecord.value(6);
-        result[DataType::key_type::GenreRole] = QVariant::fromValue(currentRecord.value(9).toString().split(QStringLiteral(", ")));
+        result[DataType::key_type::GenreRole] = QVariant::fromValue(currentRecord.value(10).toString().split(QStringLiteral(", ")));
         result[DataType::key_type::ElementTypeRole] = ElisaUtils::Album;
     }
 
diff --git a/src/mediaplaylist.h b/src/mediaplaylist.h
--- a/src/mediaplaylist.h
+++ b/src/mediaplaylist.h
@@ -88,6 +88,7 @@
         HighestTrackRating,
         AlbumRole,
         AlbumArtistRole,
+        IsValidAlbumArtistRole,
         TrackNumberRole,
         DiscNumberRole,
         RatingRole,
diff --git a/src/models/trackmetadatamodel.cpp b/src/models/trackmetadatamodel.cpp
--- a/src/models/trackmetadatamodel.cpp
+++ b/src/models/trackmetadatamodel.cpp
@@ -168,6 +168,7 @@
         case DatabaseInterface::ChildModelRole:
         case DatabaseInterface::StringDurationRole:
         case DatabaseInterface::MilliSecondsDurationRole:
+        case DatabaseInterface::IsValidAlbumArtistRole:
         case DatabaseInterface::AllArtistsRole:
         case DatabaseInterface::HighestTrackRating:
         case DatabaseInterface::ResourceRole:
@@ -243,6 +244,7 @@
         case DatabaseInterface::ChildModelRole:
         case DatabaseInterface::StringDurationRole:
         case DatabaseInterface::MilliSecondsDurationRole:
+        case DatabaseInterface::IsValidAlbumArtistRole:
         case DatabaseInterface::AllArtistsRole:
         case DatabaseInterface::HighestTrackRating:
         case DatabaseInterface::ResourceRole: