sync: reset queues only for successfully changed origins

This commit is contained in:
austinried
2026-11-14 12:05:28 +00:00
parent acc820e263
commit 548bf39136
4 changed files with 942 additions and 73 deletions
@@ -3,8 +3,10 @@ package com.subtracks.data.sync
import com.subtracks.R
import com.subtracks.UiMessage
import com.subtracks.data.db.SubtracksDatabase
import com.subtracks.data.model.QueueOrigin
import com.subtracks.data.prefs.UserPreferences
import com.subtracks.data.repo.QueueRepository
import com.subtracks.data.repo.QueueResetPoint
import com.subtracks.data.repo.SourceRepository
import com.subtracks.data.source.ServerActionSink
import com.subtracks.data.source.subsonic.SubsonicException
@@ -81,17 +83,25 @@ class SyncManager(
runCatching { preferences.setLastSyncAt(System.currentTimeMillis()) }
.onFailure { Log.w("sync", "could not record the sync attempt", it) }
val startedAt = System.nanoTime()
var summary: SyncSummary? = null
var resetPoint: QueueResetPoint? = null
var syncSourceId: Long? = null
val result =
try {
val source = sourceRepository.activeMusicSource() ?: throw NoServerException()
Log.i("sync", "started (source ${source.id})")
serverActions.flush()
val summary = SyncService(db, source).sync()
resetPoint = queueRepository.captureResetPoint()
syncSourceId = source.id
val service = SyncService(db, source)
val completed = service.sync()
val pending = db.queueDao().pendingSyncOrigins(source.id).map { QueueOrigin(it.kind, it.sourceId, it.refId) }
summary = completed.copy(changedOrigins = pending.toSet() + completed.changedOrigins)
Log.i(
"sync",
"finished in ${elapsedMs(startedAt)}ms: " +
"${summary.artists} artists, ${summary.albums} albums, ${summary.songs} songs, " +
"${summary.playlists} playlists, ${summary.playlistSongs} playlist tracks, ${summary.pruned} pruned",
"${completed.artists} artists, ${completed.albums} albums, ${completed.songs} songs, " +
"${completed.playlists} playlists, ${completed.playlistSongs} playlist tracks, ${completed.pruned} pruned",
)
SyncStatus.Success
} catch (cancellation: CancellationException) {
@@ -112,7 +122,14 @@ class SyncManager(
if (!silent) showMessage(message)
SyncStatus.Failed(message)
}
queueRepository.invalidateLibraryCache()
if (result is SyncStatus.Success) {
val completed = summary
val point = resetPoint
if (completed != null && point != null) {
queueRepository.resetChangedOrigins(completed.changedOrigins, point)
db.queueDao().clearPendingSyncOrigins(sourceId = checkNotNull(syncSourceId))
}
}
_status.value = result
}
@@ -14,6 +14,8 @@ import com.subtracks.data.model.Disc
import com.subtracks.data.model.DiscKey
import com.subtracks.data.model.Playlist
import com.subtracks.data.model.PlaylistSong
import com.subtracks.data.model.QueueKind
import com.subtracks.data.model.QueueOrigin
import com.subtracks.data.model.Song
import com.subtracks.data.model.SongArtistRef
import com.subtracks.data.model.SongGenre
@@ -30,6 +32,27 @@ class SyncService(
private var playlistsSynced = 0
private var playlistSongsSynced = 0
private var pruned = 0
private val committedOrigins = mutableSetOf<QueueOrigin>()
private var transactionOrigins: MutableSet<QueueOrigin>? = null
private val changedOrigins =
object : AbstractMutableSet<QueueOrigin>() {
override val size: Int get() = committedOrigins.size
override fun iterator(): MutableIterator<QueueOrigin> = committedOrigins.iterator()
override fun add(element: QueueOrigin): Boolean = (transactionOrigins ?: committedOrigins).add(element)
}
private suspend fun <T> commitOrigins(block: suspend () -> T): T {
check(transactionOrigins == null)
val pending = mutableSetOf<QueueOrigin>()
transactionOrigins = pending
return try {
block().also { committedOrigins.addAll(pending) }
} finally {
transactionOrigins = null
}
}
suspend fun sync(): SyncSummary {
val sources = db.sourcesDao()
@@ -51,6 +74,7 @@ class SyncService(
playlists = playlistsSynced,
playlistSongs = playlistSongsSynced,
pruned = pruned,
changedOrigins = changedOrigins.toSet(),
)
}
@@ -61,13 +85,24 @@ class SyncService(
source.artists().collect { batch ->
if (batch.isEmpty()) return@collect
changed =
write("artists", primaryKey, batch, preserved = setOf("albumCount"), markStale = true) { it.columns() } ||
write(
"artists",
primaryKey,
batch,
preserved = setOf("albumCount"),
markStale = true,
onChanged = { changedOrigins += origin(QueueKind.Artist, it.id) },
) { it.columns() } ||
changed
batch.forEach { seen.add(idHash(it.id)) }
artistsSynced += batch.size
}
val prunedBefore = pruned
pruned += pruneStaleIds(seen, { library.artistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteArtists(source.id, it) })
pruned +=
pruneStaleIds(seen, { library.artistIdsAfter(source.id, it, PRUNE_PAGE) }, {
it.forEach { id -> changedOrigins += origin(QueueKind.Artist, id) }
deleteSyncedIds("artists", it)
})
return changed || pruned > prunedBefore
}
@@ -92,7 +127,18 @@ class SyncService(
pruneStaleIds(
seenAlbums,
{ library.albumIdsAfter(source.id, it, PRUNE_PAGE) },
{ library.deleteAlbums(source.id, it) },
{
it.forEach { id -> changedOrigins += origin(QueueKind.Album, id) }
db.useWriterConnection { connection ->
connection.immediateTransaction {
val artistIds = connection.albumArtistIds(it.toSet()).values.flatten()
val trackArtistIds = connection.songArtistIds(it.toSet()).values.flatten()
changedOrigins += (artistIds + trackArtistIds).map { id -> origin(QueueKind.Artist, id) }
connection.deleteIds("albums", it)
connection.persistPendingOrigins()
}
}
},
markStale = { db.sourcesDao().setCreditsStale(source.id, true) },
)
pruned +=
@@ -117,7 +163,9 @@ class SyncService(
pruneStaleIds(
seen,
{ library.songIdsAfter(source.id, it, PRUNE_PAGE) },
{ library.deleteSongs(source.id, it) },
{
deleteSongsAndRecordOrigins(it)
},
markStale = { db.sourcesDao().setCreditsStale(source.id, true) },
)
return changed || pruned > prunedBefore
@@ -133,40 +181,227 @@ class SyncService(
batch.flatMap { song ->
song.artistPositions().map { (position, ref) -> SongArtistRef(song.sourceId, song.id, position, ref.id, ref.name) }
}
return db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
val resolved = connection.resolveSongSortNames(batch)
connection.upsertChanged("songs", primaryKey, resolved) { it.columns() }
connection.usePrepared("DELETE FROM song_genres WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
batch.forEach { song ->
statement.bind(1, song.sourceId)
statement.bind(2, song.id)
statement.bind(3, names.getValue(song.id).size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
return commitOrigins {
db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
val previousStates = connection.storedSongSyncStates(batch.map { it.id })
val albumArtists = connection.albumArtistIds(batch.mapNotNull { it.albumId }.toSet())
val resolved = connection.resolveSongSortNames(batch)
val nextStates = resolved.associate { it.id to it.syncState(albumArtists) }
val downloadedIds = connection.completedDownloadIds(batch.map { it.id })
val changedSongIds = mutableSetOf<String>()
connection.upsertChanged("songs", primaryKey, resolved, onChanged = { changedSongIds += it.id }) { it.columns() }
connection.usePrepared("DELETE FROM song_genres WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
batch.forEach { song ->
statement.bind(1, song.sourceId)
statement.bind(2, song.id)
statement.bind(3, names.getValue(song.id).size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
}
}
}
connection.upsertChanged("song_genres", songGenreKey, genres) { it.columns() }
connection.usePrepared("DELETE FROM song_artists WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
batch.forEach { song ->
statement.bind(1, song.sourceId)
statement.bind(2, song.id)
statement.bind(3, song.artistPositions().size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
connection.upsertChanged("song_genres", songGenreKey, genres) { it.columns() }
connection.usePrepared("DELETE FROM song_artists WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
batch.forEach { song ->
statement.bind(1, song.sourceId)
statement.bind(2, song.id)
statement.bind(3, song.artistPositions().size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
}
}
}
connection.upsertChanged("song_artists", songArtistKey, artists) { it.columns() }
(connection.totalChanges() != before).also { changed ->
connection.upsertChanged("song_artists", songArtistKey, artists) { it.columns() }
batch.forEach { song ->
val previous = previousStates[song.id]
val next = nextStates.getValue(song.id)
if (song.id in changedSongIds || previous != next) {
recordSongOrigins(previous, next)
}
if (song.id in downloadedIds && (previous == null || previous.sortName != next.sortName)) {
changedOrigins += origin(QueueKind.Downloaded, "")
}
}
val changed = connection.totalChanges() != before
if (changed) connection.markCreditsStale(batch.first().sourceId)
connection.persistPendingOrigins()
changed
}
}
}
}
private suspend fun deleteSongsAndRecordOrigins(ids: Collection<String>) {
ids.forEach { changedOrigins += origin(QueueKind.Song, it) }
db.useWriterConnection { connection ->
connection.immediateTransaction {
connection.storedSongSyncStates(ids.toList()).values.forEach { recordSongOrigins(it, null) }
if (connection.completedDownloadIds(ids.toList()).isNotEmpty()) changedOrigins += origin(QueueKind.Downloaded, "")
connection.deleteIds("songs", ids)
connection.persistPendingOrigins()
}
}
}
private suspend fun PooledConnection.recordSongOrigins(
previous: SongSyncState?,
next: SongSyncState?,
) {
if ((previous == null) != (next == null)) {
val songId = (previous ?: next)!!.id
usePrepared("SELECT playlistId FROM playlist_songs WHERE sourceId = ? AND songId = ?") { statement ->
statement.bindLong(1, source.id)
statement.bindText(2, songId)
while (statement.step()) changedOrigins += origin(QueueKind.Playlist, statement.getText(0))
}
}
val states = listOfNotNull(previous, next)
states.mapTo(changedOrigins) { origin(QueueKind.Song, it.id) }
states.mapNotNullTo(changedOrigins) { it.albumId?.let { id -> origin(QueueKind.Album, id) } }
states.flatMapTo(changedOrigins) { state -> state.artistIds.map { origin(QueueKind.Artist, it) } }
states.flatMapTo(changedOrigins) { state -> state.genres.map { origin(QueueKind.Genre, it) } }
if (states.any { it.starred }) changedOrigins += origin(QueueKind.Starred, "")
}
private suspend fun PooledConnection.storedSongSyncStates(ids: List<String>): Map<String, SongSyncState> {
val states = mutableMapOf<String, MutableSongSyncState>()
readSourceIds(
ids,
{ "SELECT id, albumId, artistId, sortName, starred FROM songs WHERE sourceId = ? AND id IN ($it)" },
) { statement ->
val state = MutableSongSyncState()
state.albumId = if (statement.isNull(1)) null else statement.getText(1)
if (!statement.isNull(2)) state.artistIds += statement.getText(2)
state.sortName = statement.getText(3)
state.starred = !statement.isNull(4)
states[statement.getText(0)] = state
}
readSourceIds(ids, { "SELECT songId, artistId FROM song_artists WHERE sourceId = ? AND songId IN ($it)" }) { statement ->
states[statement.getText(0)]?.artistIds?.plusAssign(statement.getText(1))
}
readSourceIds(ids, { "SELECT songId, genre FROM song_genres WHERE sourceId = ? AND songId IN ($it)" }) { statement ->
states[statement.getText(0)]?.genres?.plusAssign(statement.getText(1))
}
val albumArtists = albumArtistIds(states.values.mapNotNull { it.albumId }.toSet())
return states.mapValues { (id, state) ->
SongSyncState(
id = id,
albumId = state.albumId,
artistIds = state.artistIds + state.albumId?.let { albumArtists[it].orEmpty() }.orEmpty(),
genres = state.genres,
starred = state.starred,
sortName = state.sortName,
)
}
}
private suspend fun PooledConnection.completedDownloadIds(ids: List<String>): Set<String> {
val result = mutableSetOf<String>()
readSourceIds(
ids,
{ "SELECT songId FROM song_downloads WHERE sourceId = ? AND status = 'Completed' AND songId IN ($it)" },
) { statement ->
result += statement.getText(0)
}
return result
}
private suspend fun PooledConnection.albumArtistIds(albumIds: Set<String>): Map<String, Set<String>> {
val artists = mutableMapOf<String, MutableSet<String>>()
readSourceIds(albumIds, { "SELECT id, artistId FROM albums WHERE sourceId = ? AND artistId IS NOT NULL AND id IN ($it)" }) {
artists.getOrPut(it.getText(0)) { mutableSetOf() } += it.getText(1)
}
readSourceIds(albumIds, { "SELECT albumId, artistId FROM album_artists WHERE sourceId = ? AND albumId IN ($it)" }) {
artists.getOrPut(it.getText(0)) { mutableSetOf() } += it.getText(1)
}
return artists
}
private suspend fun PooledConnection.songArtistIds(albumIds: Set<String>): Map<String, Set<String>> {
val result = mutableMapOf<String, MutableSet<String>>()
readSourceIds(albumIds, {
"SELECT albumId, artistId FROM songs WHERE sourceId = ? AND artistId IS NOT NULL AND albumId IN ($it)"
}) { statement ->
result.getOrPut(statement.getText(0)) { mutableSetOf() } += statement.getText(1)
}
albumIds.chunked(SQL_VARIABLES).forEach { chunk ->
val placeholders = chunk.joinToString(",") { "?" }
usePrepared(
"SELECT songs.albumId, song_artists.artistId FROM song_artists " +
"JOIN songs ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId " +
"WHERE song_artists.sourceId = ? AND songs.albumId IN ($placeholders)",
) { statement ->
statement.bindLong(1, source.id)
chunk.forEachIndexed { index, id -> statement.bindText(index + 2, id) }
while (statement.step()) result.getOrPut(statement.getText(0)) { mutableSetOf() } += statement.getText(1)
}
}
return result
}
private suspend fun PooledConnection.readSourceIds(
ids: Collection<String>,
sql: (placeholders: String) -> String,
row: (SQLiteStatement) -> Unit,
) {
ids.chunked(SQL_VARIABLES).forEach { chunk ->
usePrepared(sql(chunk.joinToString(",") { "?" })) { statement ->
statement.bindLong(1, source.id)
chunk.forEachIndexed { index, id -> statement.bindText(index + 2, id) }
while (statement.step()) row(statement)
}
}
}
private fun origin(
kind: QueueKind,
refId: String,
) = QueueOrigin(kind, source.id, refId)
private suspend fun PooledConnection.persistPendingOrigins() {
val origins = transactionOrigins.orEmpty()
origins.chunked(SQL_VARIABLES).forEach { chunk ->
usePrepared("INSERT OR IGNORE INTO pending_sync_origins (sourceId, kind, refId) VALUES (?, ?, ?)") { statement ->
chunk.forEach { origin ->
statement.bindLong(1, origin.sourceId)
statement.bindText(2, origin.kind.name)
statement.bindText(3, origin.refId)
statement.step()
statement.reset()
statement.clearBindings()
}
}
}
}
private suspend fun PooledConnection.deleteIds(
table: String,
ids: Collection<String>,
) {
ids.chunked(SQL_VARIABLES).forEach { chunk ->
val placeholders = chunk.joinToString(",") { "?" }
usePrepared("DELETE FROM $table WHERE sourceId = ? AND id IN ($placeholders)") { statement ->
statement.bindLong(1, source.id)
chunk.forEachIndexed { index, id -> statement.bindText(index + 2, id) }
statement.step()
}
}
}
private suspend fun deleteSyncedIds(
table: String,
ids: Collection<String>,
) {
db.useWriterConnection { connection ->
connection.immediateTransaction {
connection.deleteIds(table, ids)
connection.persistPendingOrigins()
}
}
}
private suspend fun recomputeAggregates() {
db.libraryDao().recomputeAggregates(source.id)
}
@@ -180,6 +415,15 @@ class SyncService(
return value
}
private suspend fun PooledConnection.changes(): Long {
var value = 0L
usePrepared("SELECT changes()") { statement ->
statement.step()
value = statement.getLong(0)
}
return value
}
private suspend fun PooledConnection.markCreditsStale(sourceId: Long) {
usePrepared("UPDATE sources SET creditsStale = 1 WHERE id = ? AND creditsStale = 0") { statement ->
statement.bindLong(1, sourceId)
@@ -256,11 +500,15 @@ class SyncService(
val seen = HashedIds()
source.playlists().collect { batch ->
if (batch.isEmpty()) return@collect
write("playlists", primaryKey, batch) { it.columns() }
write("playlists", primaryKey, batch, onChanged = { changedOrigins += origin(QueueKind.Playlist, it.id) }) { it.columns() }
batch.forEach { seen.add(idHash(it.id)) }
playlistsSynced += batch.size
}
pruned += pruneStaleIds(seen, { library.playlistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deletePlaylists(source.id, it) })
pruned +=
pruneStaleIds(seen, { library.playlistIdsAfter(source.id, it, PRUNE_PAGE) }, {
it.forEach { id -> changedOrigins += origin(QueueKind.Playlist, id) }
deleteSyncedIds("playlists", it)
})
}
private suspend fun syncPlaylistSongs() {
@@ -269,14 +517,43 @@ class SyncService(
val counts = HashMap<String, Long>()
source.playlistSongs(playlistIds).collect { batch ->
if (batch.isEmpty()) return@collect
write("playlist_songs", playlistSongKey, batch) { it.columns() }
write("playlist_songs", playlistSongKey, batch, onChanged = { changedOrigins += origin(QueueKind.Playlist, it.playlistId) }) {
it.columns()
}
batch.forEach { counts[it.playlistId] = (counts[it.playlistId] ?: 0L) + 1L }
playlistSongsSynced += batch.size
}
playlistIds.forEach { library.deletePlaylistSongsFrom(source.id, it, counts[it] ?: 0L) }
playlistIds.forEach { playlistId ->
deletePlaylistSongsFrom(playlistId, counts[playlistId] ?: 0L)
}
library.deleteOrphanPlaylistSongs(source.id)
}
private suspend fun deletePlaylistSongsFrom(
playlistId: String,
position: Long,
): Boolean =
commitOrigins {
db.useWriterConnection { connection ->
connection.immediateTransaction {
connection.usePrepared(
"DELETE FROM playlist_songs WHERE sourceId = ? AND playlistId = ? AND position >= ?",
) { statement ->
statement.bindLong(1, source.id)
statement.bindText(2, playlistId)
statement.bindLong(3, position)
statement.step()
}
val changed = connection.changes() > 0
if (changed) {
changedOrigins += origin(QueueKind.Playlist, playlistId)
connection.persistPendingOrigins()
}
changed
}
}
}
// One commit per batch, so Room notifies paged observers once per batch rather than per row.
private suspend fun <T> write(
table: String,
@@ -284,14 +561,18 @@ class SyncService(
rows: List<T>,
preserved: Set<String> = emptySet(),
markStale: Boolean = false,
onChanged: (T) -> Unit = {},
columns: (T) -> List<Pair<String, Any?>>,
): Boolean =
db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
connection.upsertChanged(table, key, rows, preserved, columns)
(connection.totalChanges() != before).also { changed ->
commitOrigins {
db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
connection.upsertChanged(table, key, rows, preserved, onChanged, columns)
val changed = connection.totalChanges() != before
if (changed && markStale) connection.markCreditsStale(source.id)
connection.persistPendingOrigins()
changed
}
}
}
@@ -304,25 +585,54 @@ class SyncService(
albums.flatMap { album ->
album.artistPositions().map { (position, ref) -> AlbumArtistRef(album.sourceId, album.id, position, ref.id, ref.name) }
}
return db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
val resolved = connection.resolveAlbumSortNames(albums)
connection.upsertChanged("albums", primaryKey, resolved) { it.columns() }
connection.upsertChanged("discs", discKey, discs) { it.columns() }
connection.usePrepared("DELETE FROM album_artists WHERE sourceId = ? AND albumId = ? AND position >= ?") { statement ->
albums.forEach { album ->
statement.bind(1, album.sourceId)
statement.bind(2, album.id)
statement.bind(3, album.artistPositions().size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
return commitOrigins {
db.useWriterConnection { connection ->
connection.immediateTransaction {
val before = connection.totalChanges()
val previousArtists = connection.albumArtistIds(albums.map { it.id }.toSet())
val previousTrackArtists = connection.songArtistIds(albums.map { it.id }.toSet())
val changedAlbums = mutableSetOf<String>()
val resolved = connection.resolveAlbumSortNames(albums)
connection.upsertChanged(
"albums",
primaryKey,
resolved,
onChanged = {
changedAlbums += it.id
changedOrigins += origin(QueueKind.Album, it.id)
},
) { it.columns() }
connection.upsertChanged(
"discs",
discKey,
discs,
onChanged = { changedOrigins += origin(QueueKind.Album, it.albumId) },
) { it.columns() }
connection.usePrepared("DELETE FROM album_artists WHERE sourceId = ? AND albumId = ? AND position >= ?") { statement ->
albums.forEach { album ->
statement.bind(1, album.sourceId)
statement.bind(2, album.id)
statement.bind(3, album.artistPositions().size.toLong())
statement.step()
statement.reset()
statement.clearBindings()
}
}
}
connection.upsertChanged("album_artists", albumArtistKey, artists) { it.columns() }
(connection.totalChanges() != before).also { changed ->
connection.upsertChanged("album_artists", albumArtistKey, artists) { it.columns() }
albums.forEach { album ->
val previous = previousArtists[album.id].orEmpty()
val current = (album.artistPositions().map { it.second.id } + album.artistId).filterNotNull().toSet()
if (album.id in changedAlbums || previous != current) {
changedOrigins += (previous + current).map { origin(QueueKind.Artist, it) }
}
}
changedAlbums.forEach { albumId ->
changedOrigins += previousTrackArtists[albumId].orEmpty().map { origin(QueueKind.Artist, it) }
}
val changed = connection.totalChanges() != before
if (changed) connection.markCreditsStale(albums.first().sourceId)
connection.persistPendingOrigins()
changed
}
}
}
@@ -330,17 +640,21 @@ class SyncService(
private suspend fun deleteStaleDiscs(stale: Collection<DiscKey>) {
stale.chunked(DELETE_CHUNK).forEach { chunk ->
db.useWriterConnection { connection ->
connection.immediateTransaction {
connection.usePrepared("DELETE FROM discs WHERE sourceId = ? AND albumId = ? AND disc = ?") { statement ->
chunk.forEach { key ->
statement.bind(1, source.id)
statement.bind(2, key.albumId)
statement.bind(3, key.disc)
statement.step()
statement.reset()
statement.clearBindings()
commitOrigins {
chunk.forEach { changedOrigins += origin(QueueKind.Album, it.albumId) }
db.useWriterConnection { connection ->
connection.immediateTransaction {
connection.usePrepared("DELETE FROM discs WHERE sourceId = ? AND albumId = ? AND disc = ?") { statement ->
chunk.forEach { key ->
statement.bind(1, source.id)
statement.bind(2, key.albumId)
statement.bind(3, key.disc)
statement.step()
statement.reset()
statement.clearBindings()
}
}
connection.persistPendingOrigins()
}
}
}
@@ -361,7 +675,7 @@ class SyncService(
if (ids.isEmpty()) return pruned
val stale = ids.filterNot { seen.contains(idHash(it)) }
if (stale.isNotEmpty()) markStale?.invoke()
stale.chunked(DELETE_CHUNK).forEach { delete(it) }
stale.chunked(DELETE_CHUNK).forEach { commitOrigins { delete(it) } }
pruned += stale.size
if (ids.size < PRUNE_PAGE) return pruned
afterId = ids.last()
@@ -397,8 +711,26 @@ data class SyncSummary(
val playlists: Int,
val playlistSongs: Int,
val pruned: Int,
val changedOrigins: Set<QueueOrigin> = emptySet(),
)
private data class SongSyncState(
val id: String,
val albumId: String?,
val artistIds: Set<String>,
val genres: Set<String>,
val starred: Boolean,
val sortName: String,
)
private class MutableSongSyncState {
var albumId: String? = null
var sortName: String = ""
val artistIds = mutableSetOf<String>()
val genres = mutableSetOf<String>()
var starred = false
}
private const val DELETE_CHUNK = 500
private const val SQL_VARIABLES = 500
private const val PRUNE_PAGE = 500
@@ -446,6 +778,20 @@ private fun Song.genreNames(): List<String> =
.map { part -> id3v1Genre(part) ?: part }
.distinct()
private fun Song.syncState(albumArtists: Map<String, Set<String>>): SongSyncState {
val artistIds = artistPositions().mapTo(mutableSetOf()) { it.second.id }
this.artistId?.let(artistIds::add)
albumId?.let { artistIds += albumArtists[it].orEmpty() }
return SongSyncState(
id = id,
albumId = albumId,
artistIds = artistIds,
genres = genreNames().toSet(),
starred = starred != null,
sortName = sortName,
)
}
// Navidrome's default genre tag split (resources/mappings.yaml): semicolon, slash, comma.
private fun String.genreParts(): List<String> = split(';', '/', ',').map { it.trim() }.filter { it.isNotEmpty() }
@@ -583,6 +929,7 @@ private suspend fun <T> PooledConnection.upsertChanged(
key: List<String>,
rows: List<T>,
preserved: Set<String> = emptySet(),
onChanged: (T) -> Unit = {},
columns: (T) -> List<Pair<String, Any?>>,
) {
if (rows.isEmpty()) return
@@ -593,11 +940,12 @@ private suspend fun <T> PooledConnection.upsertChanged(
"ON CONFLICT(${key.joinToString()}) DO UPDATE SET " +
updates.joinToString { "$it = excluded.$it" } +
" WHERE " +
updates.joinToString(" OR ") { "$table.$it COLLATE BINARY IS NOT excluded.$it" }
updates.joinToString(" OR ") { "$table.$it COLLATE BINARY IS NOT excluded.$it" } +
" RETURNING 1"
usePrepared(sql) { statement ->
rows.forEach { row ->
columns(row).forEachIndexed { index, (_, value) -> statement.bind(index + 1, value) }
statement.step()
if (statement.step()) onChanged(row)
statement.reset()
statement.clearBindings()
}