Convert clear database queries to SQLDelight

(cherry picked from commit e15a867106bea490ed92d78b046535d3985ba1d0)

# Conflicts:
#	app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt
#	app/src/main/java/eu/kanade/domain/DomainModule.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/database/queries/RawQueries.kt
#	app/src/main/java/eu/kanade/tachiyomi/ui/setting/database/ClearDatabasePresenter.kt

app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt

@@ -8,12 +8,12 @@ import eu.kanade.tachiyomi.util.system.logcat
 import logcat.LogPriority
 
 class ChapterRepositoryImpl(
-    private val databaseHandler: DatabaseHandler,
+    private val handler: DatabaseHandler,
 ) : ChapterRepository {
 
     override suspend fun update(chapterUpdate: ChapterUpdate) {
         try {
-            databaseHandler.await {
+            handler.await {
                 chaptersQueries.update(
                     chapterUpdate.mangaId,
                     chapterUpdate.url,

app/src/main/java/eu/kanade/data/manga/MangaRepositoryImpl.kt

@@ -8,16 +8,16 @@ import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority
 
 class MangaRepositoryImpl(
-    private val databaseHandler: DatabaseHandler,
+    private val handler: DatabaseHandler,
 ) : MangaRepository {
 
     override fun getFavoritesBySourceId(sourceId: Long): Flow<List<Manga>> {
-        return databaseHandler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, mangaMapper) }
+        return handler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, mangaMapper) }
     }
 
     override suspend fun resetViewerFlags(): Boolean {
         return try {
-            databaseHandler.await { mangasQueries.resetViewerFlags() }
+            handler.await { mangasQueries.resetViewerFlags() }
             true
         } catch (e: Exception) {
             logcat(LogPriority.ERROR, e)

app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt

@@ -8,6 +8,7 @@ import eu.kanade.tachiyomi.source.SourceManager
 import exh.source.MERGED_SOURCE_ID
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import eu.kanade.tachiyomi.source.Source as LoadedSource
 
 class SourceRepositoryImpl(
     private val sourceManager: SourceManager,
@@ -30,13 +31,23 @@ class SourceRepositoryImpl(
         val sourceIdWithFavoriteCount = handler.subscribeToList { mangasQueries.getSourceIdWithFavoriteCount() }
         return sourceIdWithFavoriteCount.map { sourceIdsWithCount ->
             sourceIdsWithCount
+                .filterNot { it.source == LocalSource.ID /* SY --> */ || it.source == MERGED_SOURCE_ID /* SY <-- */ }
                 .map { (sourceId, count) ->
                     val source = sourceManager.getOrStub(sourceId).run {
                         sourceMapper(this)
                     }
                     source to count
                 }
-                .filterNot { it.first.id == LocalSource.ID /* SY --> */ || it.first.id == MERGED_SOURCE_ID /* SY <-- */ }
+        }
+    }
+
+    override fun getSourcesWithNonLibraryManga(): Flow<List<Pair<LoadedSource, Long>>> {
+        val sourceIdWithNonLibraryManga = handler.subscribeToList { mangasQueries.getSourceIdsWithNonLibraryManga() }
+        return sourceIdWithNonLibraryManga.map { sourceId ->
+            sourceId.map { (sourceId, count) ->
+                val source = sourceManager.getOrStub(sourceId)
+                source to count
+            }
         }
     }
 }

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -25,6 +25,7 @@ import eu.kanade.domain.source.interactor.GetLanguagesWithSources
 import eu.kanade.domain.source.interactor.GetShowLatest
 import eu.kanade.domain.source.interactor.GetSourceCategories
 import eu.kanade.domain.source.interactor.GetSourcesWithFavoriteCount
+import eu.kanade.domain.source.interactor.GetSourcesWithNonLibraryManga
 import eu.kanade.domain.source.interactor.SetMigrateSorting
 import eu.kanade.domain.source.interactor.SetSourceCategories
 import eu.kanade.domain.source.interactor.ToggleExcludeFromDataSaver
@@ -63,13 +64,14 @@ class DomainModule : InjektModule {
         addFactory { GetExtensionLanguages(get(), get()) }
 
         addSingletonFactory<SourceRepository> { SourceRepositoryImpl(get(), get()) }
-        addFactory { GetLanguagesWithSources(get(), get()) }
         addFactory { GetEnabledSources(get(), get()) }
-        addFactory { ToggleSource(get()) }
+        addFactory { GetLanguagesWithSources(get(), get()) }
-        addFactory { ToggleSourcePin(get()) }
         addFactory { GetSourcesWithFavoriteCount(get(), get()) }
+        addFactory { GetSourcesWithNonLibraryManga(get()) }
         addFactory { SetMigrateSorting(get()) }
         addFactory { ToggleLanguage(get()) }
+        addFactory { ToggleSource(get()) }
+        addFactory { ToggleSourcePin(get()) }
 
         // SY -->
         addFactory { GetSourceCategories(get()) }

app/src/main/java/eu/kanade/domain/source/interactor/GetSourcesWithNonLibraryManga.kt

@@ -0,0 +1,14 @@
+package eu.kanade.domain.source.interactor
+
+import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.tachiyomi.source.Source
+import kotlinx.coroutines.flow.Flow
+
+class GetSourcesWithNonLibraryManga(
+    private val repository: SourceRepository,
+) {
+
+    fun subscribe(): Flow<List<Pair<Source, Long>>> {
+        return repository.getSourcesWithNonLibraryManga()
+    }
+}

app/src/main/java/eu/kanade/domain/source/repository/SourceRepository.kt

@@ -2,6 +2,7 @@ package eu.kanade.domain.source.repository
 
 import eu.kanade.domain.source.model.Source
 import kotlinx.coroutines.flow.Flow
+import eu.kanade.tachiyomi.source.Source as LoadedSource
 
 interface SourceRepository {
 
@@ -10,4 +11,6 @@ interface SourceRepository {
     fun getOnlineSources(): Flow<List<Source>>
 
     fun getSourcesWithFavoriteCount(): Flow<List<Pair<Source, Long>>>
+
+    fun getSourcesWithNonLibraryManga(): Flow<List<Pair<LoadedSource, Long>>>
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/models/SourceIdMangaCount.kt

@@ -1,3 +0,0 @@
-package eu.kanade.tachiyomi.data.database.models
-
-data class SourceIdMangaCount(val source: Long, val count: Int)

app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt

@@ -1,14 +1,11 @@
 package eu.kanade.tachiyomi.data.database.queries
 
-import com.pushtorefresh.storio.Queries
 import com.pushtorefresh.storio.sqlite.operations.get.PreparedGetListOfObjects
-import com.pushtorefresh.storio.sqlite.queries.DeleteQuery
 import com.pushtorefresh.storio.sqlite.queries.Query
 import com.pushtorefresh.storio.sqlite.queries.RawQuery
 import eu.kanade.tachiyomi.data.database.DbProvider
 import eu.kanade.tachiyomi.data.database.models.LibraryManga
 import eu.kanade.tachiyomi.data.database.models.Manga
-import eu.kanade.tachiyomi.data.database.models.SourceIdMangaCount
 import eu.kanade.tachiyomi.data.database.resolvers.LibraryMangaGetResolver
 import eu.kanade.tachiyomi.data.database.resolvers.MangaCoverLastModifiedPutResolver
 import eu.kanade.tachiyomi.data.database.resolvers.MangaFavoritePutResolver
@@ -18,12 +15,10 @@ import eu.kanade.tachiyomi.data.database.resolvers.MangaInfoPutResolver
 import eu.kanade.tachiyomi.data.database.resolvers.MangaLastUpdatedPutResolver
 import eu.kanade.tachiyomi.data.database.resolvers.MangaMigrationPutResolver
 import eu.kanade.tachiyomi.data.database.resolvers.MangaThumbnailPutResolver
-import eu.kanade.tachiyomi.data.database.resolvers.SourceIdMangaCountGetResolver
 import eu.kanade.tachiyomi.data.database.tables.CategoryTable
 import eu.kanade.tachiyomi.data.database.tables.ChapterTable
 import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable
 import eu.kanade.tachiyomi.data.database.tables.MangaTable
-import exh.merged.sql.tables.MergedTable
 import exh.metadata.sql.tables.SearchMetadataTable
 
 interface MangaQueries : DbProvider {
@@ -92,17 +87,6 @@ interface MangaQueries : DbProvider {
         )
         .prepare()
 
-    fun getSourceIdsWithNonLibraryManga() = db.get()
-        .listOfObjects(SourceIdMangaCount::class.java)
-        .withQuery(
-            RawQuery.builder()
-                .query(getSourceIdsWithNonLibraryMangaQuery())
-                .observesTables(MangaTable.TABLE)
-                .build(),
-        )
-        .withGetResolver(SourceIdMangaCountGetResolver.INSTANCE)
-        .prepare()
-
     // SY -->
     fun getMangas() = db.get()
         .listOfObjects(Manga::class.java)
@@ -186,44 +170,6 @@ interface MangaQueries : DbProvider {
 
     fun deleteManga(manga: Manga) = db.delete().`object`(manga).prepare()
 
-    fun deleteMangasNotInLibraryBySourceIds(sourceIds: List<Long>) = db.delete()
-        .byQuery(
-            DeleteQuery.builder()
-                .table(MangaTable.TABLE)
-                // SY -->
-                .where(
-                    """
-                    ${MangaTable.COL_FAVORITE} = ? AND ${MangaTable.COL_SOURCE} IN (${Queries.placeholders(sourceIds.size)}) AND ${MangaTable.COL_ID} NOT IN (
-                        SELECT ${MergedTable.COL_MANGA_ID} FROM ${MergedTable.TABLE} WHERE ${MergedTable.COL_MANGA_ID} != ${MergedTable.COL_MERGE_ID}
-                    )
-                    """.trimIndent(),
-                )
-                // SY <--
-                .whereArgs(0, *sourceIds.toTypedArray())
-                .build(),
-        )
-        .prepare()
-
-    // SY -->
-    fun deleteMangasNotInLibraryAndNotReadBySourceIds(sourceIds: List<Long>) = db.delete()
-        .byQuery(
-            DeleteQuery.builder()
-                .table(MangaTable.TABLE)
-                .where(
-                    """
-                    ${MangaTable.COL_FAVORITE} = ? AND ${MangaTable.COL_SOURCE} IN (${Queries.placeholders(sourceIds.size)}) AND ${MangaTable.COL_ID} NOT IN (
-                        SELECT ${MergedTable.COL_MANGA_ID} FROM ${MergedTable.TABLE} WHERE ${MergedTable.COL_MANGA_ID} != ${MergedTable.COL_MERGE_ID}
-                    ) AND ${MangaTable.COL_ID} NOT IN (
-                        SELECT ${ChapterTable.COL_MANGA_ID} FROM ${ChapterTable.TABLE} WHERE ${ChapterTable.COL_READ} = 1 OR ${ChapterTable.COL_LAST_PAGE_READ} != 0
-                    )
-                    """.trimIndent(),
-                )
-                .whereArgs(0, *sourceIds.toTypedArray())
-                .build(),
-        )
-        .prepare()
-    // SY <--
-
     fun getLastReadManga() = db.get()
         .listOfObjects(Manga::class.java)
         .withQuery(

app/src/main/java/eu/kanade/tachiyomi/data/database/queries/RawQueries.kt

@@ -1,6 +1,5 @@
 package eu.kanade.tachiyomi.data.database.queries
 
-import eu.kanade.tachiyomi.data.database.resolvers.SourceIdMangaCountGetResolver
 import exh.source.MERGED_SOURCE_ID
 import eu.kanade.tachiyomi.data.database.tables.CategoryTable as Category
 import eu.kanade.tachiyomi.data.database.tables.ChapterTable as Chapter
@@ -218,14 +217,3 @@ fun getCategoriesForMangaQuery() =
     ${MangaCategory.TABLE}.${MangaCategory.COL_CATEGORY_ID}
     WHERE ${MangaCategory.COL_MANGA_ID} = ?
 """
-
-/** Query to get the list of sources in the database that have
- * non-library manga, and how many
- */
-fun getSourceIdsWithNonLibraryMangaQuery() =
-    """
-    SELECT ${Manga.COL_SOURCE}, COUNT(*) as ${SourceIdMangaCountGetResolver.COL_COUNT}
-    FROM ${Manga.TABLE}
-    WHERE ${Manga.COL_FAVORITE} = 0
-    GROUP BY ${Manga.COL_SOURCE}
-    """

app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/SourceIdMangaCountGetResolver.kt

@@ -1,23 +0,0 @@
-package eu.kanade.tachiyomi.data.database.resolvers
-
-import android.annotation.SuppressLint
-import android.database.Cursor
-import com.pushtorefresh.storio.sqlite.operations.get.DefaultGetResolver
-import eu.kanade.tachiyomi.data.database.models.SourceIdMangaCount
-import eu.kanade.tachiyomi.data.database.tables.MangaTable
-
-class SourceIdMangaCountGetResolver : DefaultGetResolver<SourceIdMangaCount>() {
-
-    companion object {
-        val INSTANCE = SourceIdMangaCountGetResolver()
-        const val COL_COUNT = "manga_count"
-    }
-
-    @SuppressLint("Range")
-    override fun mapFromCursor(cursor: Cursor): SourceIdMangaCount {
-        val sourceID = cursor.getLong(cursor.getColumnIndexOrThrow(MangaTable.COL_SOURCE))
-        val count = cursor.getInt(cursor.getColumnIndexOrThrow(COL_COUNT))
-
-        return SourceIdMangaCount(sourceID, count)
-    }
-}

app/src/main/java/eu/kanade/tachiyomi/ui/setting/database/ClearDatabasePresenter.kt

@@ -1,49 +1,43 @@
 package eu.kanade.tachiyomi.ui.setting.database
 
 import android.os.Bundle
+import eu.kanade.domain.source.interactor.GetSourcesWithNonLibraryManga
 import eu.kanade.tachiyomi.Database
-import eu.kanade.tachiyomi.data.database.DatabaseHelper
-import eu.kanade.tachiyomi.source.SourceManager
 import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
-import rx.Observable
+import eu.kanade.tachiyomi.util.lang.launchIO
-import rx.android.schedulers.AndroidSchedulers
+import eu.kanade.tachiyomi.util.lang.withUIContext
-import rx.schedulers.Schedulers
+import kotlinx.coroutines.flow.collectLatest
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
-class ClearDatabasePresenter : BasePresenter<ClearDatabaseController>() {
+class ClearDatabasePresenter(
-
+    private val database: Database = Injekt.get(),
-    private val db = Injekt.get<DatabaseHelper>()
+    private val getSourcesWithNonLibraryManga: GetSourcesWithNonLibraryManga = Injekt.get(),
-    private val database = Injekt.get<Database>()
+) : BasePresenter<ClearDatabaseController>() {
-
-    private val sourceManager = Injekt.get<SourceManager>()
 
     override fun onCreate(savedState: Bundle?) {
         super.onCreate(savedState)
-        getDatabaseSourcesObservable()
+
-            .subscribeOn(Schedulers.io())
+        presenterScope.launchIO {
-            .observeOn(AndroidSchedulers.mainThread())
+            getSourcesWithNonLibraryManga.subscribe()
-            .subscribeLatestCache(ClearDatabaseController::setItems)
+                .collectLatest { list ->
+                    val items = list
+                        .map { (source, count) -> ClearDatabaseSourceItem(source, count) }
+                        .sortedBy { it.source.name }
+
+                    withUIContext { view?.setItems(items) }
+                }
+        }
     }
 
     fun clearDatabaseForSourceIds(sources: List<Long>, /* SY --> */ keepReadManga: Boolean /* SY <-- */) {
         // SY -->
         if (keepReadManga) {
-            db.deleteMangasNotInLibraryAndNotReadBySourceIds(sources).executeAsBlocking()
+            database.mangasQueries.deleteMangasNotInLibraryAndNotReadBySourceIds(sources)
         } else {
-            db.deleteMangasNotInLibraryBySourceIds(sources).executeAsBlocking()
+            database.mangasQueries.deleteMangasNotInLibraryBySourceIds(sources)
         }
         // SY <--
         database.historyQueries.removeResettedHistory()
     }
-
-    private fun getDatabaseSourcesObservable(): Observable<List<ClearDatabaseSourceItem>> {
-        return db.getSourceIdsWithNonLibraryManga().asRxObservable()
-            .map { sourceCounts ->
-                sourceCounts.map {
-                    val sourceObj = sourceManager.getOrStub(it.source)
-                    ClearDatabaseSourceItem(sourceObj, it.count)
-                }.sortedBy { it.source.name }
-            }
-    }
 }

app/src/main/java/eu/kanade/tachiyomi/ui/setting/database/ClearDatabaseSourceItem.kt

@@ -13,7 +13,7 @@ import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceManager
 import eu.kanade.tachiyomi.source.icon
 
-data class ClearDatabaseSourceItem(val source: Source, private val mangaCount: Int) : AbstractFlexibleItem<ClearDatabaseSourceItem.Holder>() {
+data class ClearDatabaseSourceItem(val source: Source, private val mangaCount: Long) : AbstractFlexibleItem<ClearDatabaseSourceItem.Holder>() {
 
     override fun getLayoutRes(): Int {
         return R.layout.clear_database_source_item
@@ -31,7 +31,7 @@ data class ClearDatabaseSourceItem(val source: Source, private val mangaCount: I
 
         private val binding = ClearDatabaseSourceItemBinding.bind(view)
 
-        fun bind(source: Source, count: Int) {
+        fun bind(source: Source, count: Long) {
             binding.title.text = source.toString()
             binding.description.text = itemView.context.getString(R.string.clear_database_source_item_count, count)
 

app/src/main/sqldelight/data/mangas.sq

@@ -47,4 +47,24 @@ AND source = :sourceId;
 
 resetViewerFlags:
 UPDATE mangas
-SET viewer = 0;
+SET viewer = 0;
+
+getSourceIdsWithNonLibraryManga:
+SELECT source, COUNT(*) AS manga_count
+FROM mangas
+WHERE favorite = 0
+GROUP BY source;
+
+deleteMangasNotInLibraryBySourceIds:
+DELETE FROM mangas
+WHERE favorite = 0 AND source IN :sourceIdsAND AND _id NOT IN (
+    SELECT manga_id FROM merged WHERE manga_id != merge_id
+);
+
+deleteMangasNotInLibraryAndNotReadBySourceIds:
+DELETE FROM mangas
+WHERE favorite = 0 AND source IN :sourceIdsAND AND _id NOT IN (
+    SELECT manga_id FROM merged WHERE manga_id != merge_id
+) AND _id NOT IN (
+    SELECT manga_id FROM chapters WHERE read = 1 OR last_page_read != 0
+);