Library: Add last_played_at column

res/schema.xml

@@ -503,4 +503,38 @@ METADATA
       ALTER TABLE library ADD COLUMN coverart_digest BLOB;
     </sql>
   </revision>
+  <revision version="34" min_compatible="3">
+    <description>
+      Add indexes for tracks in playlists and crates
+    </description>
+    <sql>
+      CREATE INDEX IF NOT EXISTS idx_PlaylistTracks_playlist_id_track_id ON PlaylistTracks (
+          playlist_id,
+          track_id
+      );
+      CREATE INDEX IF NOT EXISTS idx_PlaylistTracks_track_id ON PlaylistTracks (
+          track_id
+      );
+      CREATE INDEX IF NOT EXISTS idx_crate_tracks_track_id ON crate_tracks (
+          track_id
+      );
+    </sql>
+  </revision>
+  <revision version="35" min_compatible="3">
+    <description>
+      Add last_played_at column to library table
+    </description>
+    <sql>
+      -- Add new column
+      ALTER TABLE library ADD COLUMN last_played_at DATETIME DEFAULT NULL;
+      -- Populate new column from history playlists
+      UPDATE library SET last_played_at=(
+        SELECT MAX(PlaylistTracks.pl_datetime_added)
+          FROM PlaylistTracks
+          JOIN Playlists ON PlaylistTracks.playlist_id=Playlists.id
+          WHERE PlaylistTracks.track_id=library.id
+          AND Playlists.hidden=2
+          GROUP BY PlaylistTracks.track_id);
+    </sql>
+  </revision>
 </schema>

src/database/mixxxdb.cpp

@@ -1,17 +1,15 @@
 #include "database/mixxxdb.h"
 
 #include "database/schemamanager.h"
-
 #include "util/assert.h"
 #include "util/logger.h"
 
-
 // The schema XML is baked into the binary via Qt resources.
 //static
 const QString MixxxDb::kDefaultSchemaFile(":/schema.xml");
 
 //static
-const int MixxxDb::kRequiredSchemaVersion = 33;
+const int MixxxDb::kRequiredSchemaVersion = 35;
 
 namespace {
 

src/library/dao/autodjcratesdao.cpp

@@ -15,6 +15,11 @@
 #include "mixer/playerinfo.h"
 #include "mixer/playermanager.h"
 
+#if !defined(VERBOSE_DEBUG_LOG)
+// set to true for verbose debug logs
+#define VERBOSE_DEBUG_LOG false
+#endif
+
 #define AUTODJCRATESTABLE_TRACKID "track_id"
 #define AUTODJCRATESTABLE_CRATEREFS "craterefs"
 #define AUTODJCRATESTABLE_TIMESPLAYED "timesplayed"
@@ -138,35 +143,38 @@ void AutoDJCratesDAO::createAndConnectAutoDjCratesDatabase() {
         return;
     }
 
-    // Fill out the first three columns.
-    // Supply default values for the last two.
-    // INSERT INTO temp_autodj_crates (
-    //     track_id, craterefs, timesplayed, autodjrefs, lastplayed)
-    // SELECT crate_tracks.track_id, COUNT (*), library.timesplayed, 0, ""
-    // FROM crate_tracks, library
-    // WHERE crate_tracks.crate_id IN (
-    //     SELECT id
-    //     FROM crates
-    //     WHERE autodj = 1)
-    // AND crate_tracks.track_id = library.id
-    // AND library.mixxx_deleted = 0
-    // GROUP BY crate_tracks.track_id, library.timesplayed;
-    strQuery = QString("INSERT INTO " AUTODJCRATES_TABLE
-            " (" AUTODJCRATESTABLE_TRACKID ", " AUTODJCRATESTABLE_CRATEREFS ", "
-            AUTODJCRATESTABLE_TIMESPLAYED ", " AUTODJCRATESTABLE_AUTODJREFS ", "
-            AUTODJCRATESTABLE_LASTPLAYED ") SELECT " CRATE_TRACKS_TABLE
-            ".%1 , COUNT (*), " LIBRARY_TABLE ".%2, 0, \"\" FROM "
-            CRATE_TRACKS_TABLE ", " LIBRARY_TABLE " WHERE " CRATE_TRACKS_TABLE
-            ".%4 IN (SELECT %5 FROM " CRATE_TABLE " WHERE %6 = 1) AND "
-            CRATE_TRACKS_TABLE ".%1 = " LIBRARY_TABLE ".%7 AND " LIBRARY_TABLE
-            ".%3 == 0 GROUP BY " CRATE_TRACKS_TABLE ".%1, " LIBRARY_TABLE ".%2")
-                .arg(CRATETRACKSTABLE_TRACKID, // %1
-                     LIBRARYTABLE_TIMESPLAYED, // %2
-                     LIBRARYTABLE_MIXXXDELETED, // %3
-                     CRATETRACKSTABLE_CRATEID, // %4
-                     CRATETABLE_ID, // %5
-                     CRATETABLE_AUTODJ_SOURCE, // %6
-                     LIBRARYTABLE_ID); // %7
+    strQuery = QStringLiteral(
+            "INSERT INTO " AUTODJCRATES_TABLE "(" AUTODJCRATESTABLE_TRACKID
+            "," AUTODJCRATESTABLE_CRATEREFS "," AUTODJCRATESTABLE_TIMESPLAYED
+            "," AUTODJCRATESTABLE_LASTPLAYED "," AUTODJCRATESTABLE_AUTODJREFS
+            ") SELECT " CRATE_TRACKS_TABLE
+            ".%5,"               // TRACKID
+            "COUNT(*),"          // CRATEREFS
+            LIBRARY_TABLE ".%2," // TIMESPLAYED
+            LIBRARY_TABLE
+            ".%3," // LASTPLAYED
+            "0"    // AUTODJREFS = default
+            " FROM " CRATE_TRACKS_TABLE
+            " INNER JOIN " LIBRARY_TABLE " ON " LIBRARY_TABLE ".%1=" CRATE_TRACKS_TABLE
+            ".%5"
+            " WHERE " LIBRARY_TABLE
+            ".%4=0"
+            " AND " CRATE_TRACKS_TABLE ".%6 IN (SELECT %7 FROM " CRATE_TABLE
+            " WHERE %8=1)"
+            " GROUP BY " CRATE_TRACKS_TABLE ".%5")
+                       .arg(LIBRARYTABLE_ID,                // %1
+                               LIBRARYTABLE_TIMESPLAYED,    // %2
+                               LIBRARYTABLE_LAST_PLAYED_AT, // %3
+                               LIBRARYTABLE_MIXXXDELETED,   // %4
+                               CRATETRACKSTABLE_TRACKID,    // %5
+                               CRATETRACKSTABLE_CRATEID,    // %6
+                               CRATETABLE_ID,               // %7
+                               CRATETABLE_AUTODJ_SOURCE);   // %8
+#if !defined(VERBOSE_DEBUG_LOG)
+    qDebug().noquote()
+            << "Populating " AUTODJCRATES_TABLE " using the following SQL query:"
+            << strQuery;
+#endif
     oQuery.prepare(strQuery);
     if (!oQuery.exec()) {
         LOG_FAILED_QUERY(oQuery);

src/library/dao/playlistdao.cpp

@@ -172,6 +172,9 @@ void PlaylistDAO::deletePlaylist(const int playlistId) {
     //qDebug() << "PlaylistDAO::deletePlaylist" << QThread::currentThread() << m_database.connectionName();
     ScopedTransaction transaction(m_database);
 
+    const HiddenType hiddenType = getHiddenType(playlistId);
+    const QList<TrackId> trackIds = getTrackIds(playlistId);
+
     // Get the playlist id for this
     QSqlQuery query(m_database);
 
@@ -205,7 +208,7 @@ void PlaylistDAO::deletePlaylist(const int playlistId) {
         }
     }
 
-    emit deleted(playlistId);
+    emit deleted(playlistId, hiddenType, trackIds);
 }
 
 void PlaylistDAO::renamePlaylist(const int playlistId, const QString& newName) {

src/library/dao/playlistdao.h

@@ -122,7 +122,7 @@ class PlaylistDAO : public QObject, public virtual DAO {
 
   signals:
     void added(int playlistId);
-    void deleted(int playlistId);
+    void deleted(int playlistId, HiddenType hiddenType, const QList<TrackId>& trackIds);
     void renamed(int playlistId, QString newName);
     void lockChanged(int playlistId);
     void trackAdded(int playlistId, TrackId trackId, int position);

src/library/dao/trackdao.cpp

@@ -29,6 +29,7 @@
 #include "util/assert.h"
 #include "util/compatibility.h"
 #include "util/datetime.h"
+#include "util/db/fwdsqlquery.h"
 #include "util/db/sqllikewildcardescaper.h"
 #include "util/db/sqllikewildcards.h"
 #include "util/db/sqlstringformatter.h"
@@ -57,6 +58,15 @@ void markTrackLocationsAsDeleted(QSqlDatabase database, const QString& directory
     }
 }
 
+QString joinTrackIdList(const QSet<TrackId>& trackIds) {
+    QStringList trackIdList;
+    trackIdList.reserve(trackIds.size());
+    for (const auto& trackId : trackIds) {
+        trackIdList.append(trackId.toString());
+    }
+    return trackIdList.join(QChar(','));
+}
+
 } // anonymous namespace
 
 TrackDAO::TrackDAO(CueDAO& cueDao,
@@ -72,6 +82,36 @@ TrackDAO::TrackDAO(CueDAO& cueDao,
           m_trackLocationIdColumn(UndefinedRecordIndex),
           m_queryLibraryIdColumn(UndefinedRecordIndex),
           m_queryLibraryMixxxDeletedColumn(UndefinedRecordIndex) {
+    connect(&m_playlistDao,
+            &PlaylistDAO::deleted,
+            [this](int playlistId, PlaylistDAO::HiddenType hiddenType, const QList<TrackId>& trackIds) {
+                Q_UNUSED(playlistId)
+                if (hiddenType != PlaylistDAO::PLHT_SET_LOG) {
+                    // Nothing to do
+                    return;
+                }
+                QSet<TrackId> trackIdSet;
+                for (const auto& trackId : trackIds) {
+                    trackIdSet.insert(trackId);
+                }
+                VERIFY_OR_DEBUG_ASSERT(updatePlayCounterFromHistoryPlaylists(trackIdSet)) {
+                    return;
+                }
+            });
+    connect(&m_playlistDao,
+            &PlaylistDAO::trackRemoved,
+            [this](int playlistId, TrackId trackId, int position) {
+                Q_UNUSED(position)
+                if (m_playlistDao.getHiddenType(playlistId) != PlaylistDAO::PLHT_SET_LOG) {
+                    // Nothing to do
+                    return;
+                }
+                QSet<TrackId> trackIdSet;
+                trackIdSet.insert(trackId);
+                VERIFY_OR_DEBUG_ASSERT(updatePlayCounterFromHistoryPlaylists(trackIdSet)) {
+                    return;
+                }
+            });
 }
 
 TrackDAO::~TrackDAO() {
@@ -373,6 +413,7 @@ void TrackDAO::addTracksPrepare() {
             "replaygain_peak,"
             "wavesummaryhex,"
             "timesplayed,"
+            "last_played_at,"
             "played,"
             "mixxx_deleted,"
             "header_parsed,"
@@ -419,6 +460,7 @@ void TrackDAO::addTracksPrepare() {
             ":replaygain_peak,"
             ":wavesummaryhex,"
             ":timesplayed,"
+            ":last_played_at,"
             ":played,"
             ":mixxx_deleted,"
             ":header_parsed,"
@@ -532,6 +574,7 @@ void bindTrackLibraryValues(
 
     const PlayCounter& playCounter = track.getPlayCounter();
     pTrackLibraryQuery->bindValue(":timesplayed", playCounter.getTimesPlayed());
+    pTrackLibraryQuery->bindValue(":last_played_at", playCounter.getLastPlayedAt());
     pTrackLibraryQuery->bindValue(":played", playCounter.isPlayed() ? 1 : 0);
 
     const CoverInfoRelative& coverInfo = track.getCoverInfo();
@@ -1142,7 +1185,14 @@ bool setTrackTimesPlayed(const QSqlRecord& record, const int column,
 bool setTrackPlayed(const QSqlRecord& record, const int column,
                     TrackPointer pTrack) {
     PlayCounter playCounter(pTrack->getPlayCounter());
-    playCounter.setPlayed(record.value(column).toBool());
+    playCounter.setPlayedFlag(record.value(column).toBool());
+    pTrack->setPlayCounter(playCounter);
+    return false;
+}
+
+bool setTrackLastPlayedAt(const QSqlRecord& record, const int column, TrackPointer pTrack) {
+    PlayCounter playCounter(pTrack->getPlayCounter());
+    playCounter.setLastPlayedAt(record.value(column).toDateTime());
     pTrack->setPlayCounter(playCounter);
     return false;
 }
@@ -1291,6 +1341,7 @@ TrackPointer TrackDAO::getTrackById(TrackId trackId) const {
             {"replaygain", setTrackReplayGainRatio},
             {"replaygain_peak", setTrackReplayGainPeak},
             {"timesplayed", setTrackTimesPlayed},
+            {"last_played_at", setTrackLastPlayedAt},
             {"played", setTrackPlayed},
             {"datetime_added", setTrackDateAdded},
             {"header_parsed", setTrackMetadataSynchronized},
@@ -1551,6 +1602,7 @@ bool TrackDAO::updateTrack(Track* pTrack) const {
             "replaygain=:replaygain,"
             "replaygain_peak=:replaygain_peak,"
             "timesplayed=:timesplayed,"
+            "last_played_at=:last_played_at,"
             "played=:played,"
             "header_parsed=:header_parsed,"
             "channels=:channels,"
@@ -2137,3 +2189,36 @@ TrackFile TrackDAO::relocateCachedTrack(
         return TrackFile(trackLocation);
     }
 }
+
+bool TrackDAO::updatePlayCounterFromHistoryPlaylists(
+        const QSet<TrackId> trackIds) const {
+    FwdSqlQuery query(
+            m_database,
+            QStringLiteral(
+                    "UPDATE library SET "
+                    "timesplayed=q.timesplayed,"
+                    "last_played_at=q.last_played_at "
+                    "FROM("
+                    "SELECT "
+                    "PlaylistTracks.track_id as id,"
+                    "COUNT(PlaylistTracks.track_id) as timesplayed,"
+                    "MAX(PlaylistTracks.pl_datetime_added) as last_played_at "
+                    "FROM PlaylistTracks "
+                    "JOIN Playlists ON "
+                    "PlaylistTracks.playlist_id=Playlists.id "
+                    "WHERE Playlists.hidden=%2 "
+                    "GROUP BY PlaylistTracks.track_id"
+                    ") q "
+                    "WHERE library.id=q.id "
+                    "AND library.id IN (%1)")
+                    .arg(joinTrackIdList(trackIds),
+                            QString::number(PlaylistDAO::PLHT_SET_LOG)));
+    VERIFY_OR_DEBUG_ASSERT(!query.hasError()) {
+        return false;
+    }
+    VERIFY_OR_DEBUG_ASSERT(query.execPrepared()) {
+        return false;
+    }
+    emit tracksChanged(trackIds);
+    return true;
+}

src/library/dao/trackdao.h

@@ -15,6 +15,7 @@
 #include "util/class.h"
 #include "util/memory.h"
 
+class FwdSqlQuery;
 class SqlTransaction;
 class PlaylistDAO;
 class AnalysisDao;
@@ -69,6 +70,9 @@ class TrackDAO : public QObject, public virtual DAO, public virtual GlobalTrackC
     // Only used by friend class TrackCollection, but public for testing!
     void saveTrack(Track* pTrack) const;
 
+    bool updatePlayCounterFromHistoryPlaylists(
+            const QSet<TrackId> trackIds) const;
+
   signals:
     // Forwarded from Track object
     void trackDirty(TrackId trackId) const;
@@ -160,7 +164,7 @@ class TrackDAO : public QObject, public virtual DAO, public virtual GlobalTrackC
     AnalysisDao& m_analysisDao;
     LibraryHashDAO& m_libraryHashDao;
 
-    UserSettingsPointer m_pConfig;
+    const UserSettingsPointer m_pConfig;
 
     std::unique_ptr<QSqlQuery> m_pQueryTrackLocationInsert;
     std::unique_ptr<QSqlQuery> m_pQueryTrackLocationSelect;

src/library/dao/trackschema.h

@@ -30,6 +30,7 @@ const QString LIBRARYTABLE_MIXXXDELETED = QStringLiteral("mixxx_deleted");
 const QString LIBRARYTABLE_DATETIMEADDED = QStringLiteral("datetime_added");
 const QString LIBRARYTABLE_HEADERPARSED = QStringLiteral("header_parsed");
 const QString LIBRARYTABLE_TIMESPLAYED = QStringLiteral("timesplayed");
+const QString LIBRARYTABLE_LAST_PLAYED_AT = QStringLiteral("last_played_at");
 const QString LIBRARYTABLE_PLAYED = QStringLiteral("played");
 const QString LIBRARYTABLE_RATING = QStringLiteral("rating");
 const QString LIBRARYTABLE_KEY = QStringLiteral("key");

src/library/searchqueryparser.cpp

@@ -49,6 +49,7 @@ SearchQueryParser::SearchQueryParser(TrackCollection* pTrackCollection)
     m_fieldToSqlColumns["key"] << "key";
     m_fieldToSqlColumns["key_id"] << "key_id";
     m_fieldToSqlColumns["played"] << "timesplayed";
+    m_fieldToSqlColumns["lastplayed"] << "last_played_at";
     m_fieldToSqlColumns["rating"] << "rating";
     m_fieldToSqlColumns["location"] << "location";
     m_fieldToSqlColumns["datetime_added"] << "datetime_added";

src/library/trackset/setlogfeature.cpp

@@ -265,7 +265,7 @@ void SetlogFeature::slotJoinWithPrevious() {
                                     m_pPlaylistTableModel->getTrack(index);
                             // Do not update the play count, just set played status.
                             PlayCounter playCounter(track->getPlayCounter());
-                            playCounter.setPlayed();
+                            playCounter.triggerLastPlayedNow();
                             track->setPlayCounter(playCounter);
                         }
                     }

src/test/playcountertest.cpp

@@ -9,7 +9,7 @@ class PlayCounterTest : public testing::Test {
     void updatePlayedAndVerify(PlayCounter* pPlayCounter, bool bPlayed) {
         bool isPlayedBefore = pPlayCounter->isPlayed();
         int timesPlayedBefore = pPlayCounter->getTimesPlayed();
-        pPlayCounter->setPlayedAndUpdateTimesPlayed(bPlayed);
+        pPlayCounter->updateLastPlayedNowAndTimesPlayed(bPlayed);
         bool isPlayedAfter = pPlayCounter->isPlayed();
         int timesPlayedAfter = pPlayCounter->getTimesPlayed();
         if (bPlayed) {
@@ -46,9 +46,10 @@ class PlayCounterTest : public testing::Test {
         updatePlayedAndVerify(pPlayCounter, true);
         updatePlayedAndVerify(pPlayCounter, true);
         updatePlayedAndVerify(pPlayCounter, false);
-        EXPECT_EQ(PlayCounter(1), *pPlayCounter);
+        EXPECT_EQ(1, pPlayCounter->getTimesPlayed());
+        EXPECT_FALSE(pPlayCounter->isPlayed());
         resetAndVerify(pPlayCounter);
-        EXPECT_EQ(PlayCounter(), *pPlayCounter);
+        ASSERT_EQ(PlayCounter(), *pPlayCounter);
     }
 };