Revert history Compose/SQLDelight changes

app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupManager.kt

@@ -299,7 +299,7 @@ class FullBackupManager(context: Context) : AbstractBackupManager(context) {
                 }
             }
         }
-        databaseHelper.upsertHistoryLastRead(historyToBeUpdated).executeAsBlocking()
+        databaseHelper.updateHistoryLastRead(historyToBeUpdated).executeAsBlocking()
     }
 
     /**

app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupManager.kt

@@ -168,7 +168,7 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
                 }
             }
         }
-        databaseHelper.upsertHistoryLastRead(historyToBeUpdated).executeAsBlocking()
+        databaseHelper.updateHistoryLastRead(historyToBeUpdated).executeAsBlocking()
     }
 
     /**

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

@@ -26,15 +26,12 @@ import io.requery.android.database.sqlite.RequerySQLiteOpenHelperFactory
 /**
  * This class provides operations to manage the database through its interfaces.
  */
-open class DatabaseHelper(
-    context: Context,
-    callback: DbOpenCallback
-) :
+open class DatabaseHelper(context: Context) :
     MangaQueries, ChapterQueries, TrackQueries, CategoryQueries, MangaCategoryQueries, HistoryQueries {
 
     private val configuration = SupportSQLiteOpenHelper.Configuration.builder(context)
         .name(DbOpenCallback.DATABASE_NAME)
-        .callback(callback)
+        .callback(DbOpenCallback())
         .build()
 
     override val db = DefaultStorIOSQLite.builder()

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

@@ -2,28 +2,98 @@ package eu.kanade.tachiyomi.data.database
 
 import androidx.sqlite.db.SupportSQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteOpenHelper
-import com.squareup.sqldelight.android.AndroidSqliteDriver
-import eu.kanade.tachiyomi.Database
+import eu.kanade.tachiyomi.data.database.tables.CategoryTable
+import eu.kanade.tachiyomi.data.database.tables.ChapterTable
+import eu.kanade.tachiyomi.data.database.tables.HistoryTable
+import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable
+import eu.kanade.tachiyomi.data.database.tables.MangaTable
+import eu.kanade.tachiyomi.data.database.tables.TrackTable
 
-class DbOpenCallback : SupportSQLiteOpenHelper.Callback(Database.Schema.version) {
+class DbOpenCallback : SupportSQLiteOpenHelper.Callback(DATABASE_VERSION) {
 
     companion object {
         /**
          * Name of the database file.
          */
         const val DATABASE_NAME = "tachiyomi.db"
+
+        /**
+         * Version of the database.
+         */
+        const val DATABASE_VERSION = 14
     }
 
-    override fun onCreate(db: SupportSQLiteDatabase) {
-        Database.Schema.create(AndroidSqliteDriver(database = db, cacheSize = 1))
+    override fun onCreate(db: SupportSQLiteDatabase) = with(db) {
+        execSQL(MangaTable.createTableQuery)
+        execSQL(ChapterTable.createTableQuery)
+        execSQL(TrackTable.createTableQuery)
+        execSQL(CategoryTable.createTableQuery)
+        execSQL(MangaCategoryTable.createTableQuery)
+        execSQL(HistoryTable.createTableQuery)
+
+        // DB indexes
+        execSQL(MangaTable.createUrlIndexQuery)
+        execSQL(MangaTable.createLibraryIndexQuery)
+        execSQL(ChapterTable.createMangaIdIndexQuery)
+        execSQL(ChapterTable.createUnreadChaptersIndexQuery)
+        execSQL(HistoryTable.createChapterIdIndexQuery)
     }
 
     override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
-        Database.Schema.migrate(
-            driver = AndroidSqliteDriver(database = db, cacheSize = 1),
-            oldVersion = oldVersion,
-            newVersion = newVersion
-        )
+        if (oldVersion < 2) {
+            db.execSQL(ChapterTable.sourceOrderUpdateQuery)
+
+            // Fix kissmanga covers after supporting cloudflare
+            db.execSQL(
+                """UPDATE mangas SET thumbnail_url =
+                    REPLACE(thumbnail_url, '93.174.95.110', 'kissmanga.com') WHERE source = 4""",
+            )
+        }
+        if (oldVersion < 3) {
+            // Initialize history tables
+            db.execSQL(HistoryTable.createTableQuery)
+            db.execSQL(HistoryTable.createChapterIdIndexQuery)
+        }
+        if (oldVersion < 4) {
+            db.execSQL(ChapterTable.bookmarkUpdateQuery)
+        }
+        if (oldVersion < 5) {
+            db.execSQL(ChapterTable.addScanlator)
+        }
+        if (oldVersion < 6) {
+            db.execSQL(TrackTable.addTrackingUrl)
+        }
+        if (oldVersion < 7) {
+            db.execSQL(TrackTable.addLibraryId)
+        }
+        if (oldVersion < 8) {
+            db.execSQL("DROP INDEX IF EXISTS mangas_favorite_index")
+            db.execSQL(MangaTable.createLibraryIndexQuery)
+            db.execSQL(ChapterTable.createUnreadChaptersIndexQuery)
+        }
+        if (oldVersion < 9) {
+            db.execSQL(TrackTable.addStartDate)
+            db.execSQL(TrackTable.addFinishDate)
+        }
+        if (oldVersion < 10) {
+            db.execSQL(MangaTable.addCoverLastModified)
+        }
+        if (oldVersion < 11) {
+            db.execSQL(MangaTable.addDateAdded)
+            db.execSQL(MangaTable.backfillDateAdded)
+        }
+        if (oldVersion < 12) {
+            db.execSQL(MangaTable.addNextUpdateCol)
+        }
+        if (oldVersion < 13) {
+            db.execSQL(TrackTable.renameTableToTemp)
+            db.execSQL(TrackTable.createTableQuery)
+            db.execSQL(TrackTable.insertFromTempTable)
+            db.execSQL(TrackTable.dropTempTable)
+        }
+        if (oldVersion < 14) {
+            db.execSQL(ChapterTable.fixDateUploadIfNeeded)
+        }
     }
 
     override fun onConfigure(db: SupportSQLiteDatabase) {

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

@@ -4,11 +4,39 @@ import com.pushtorefresh.storio.sqlite.queries.DeleteQuery
 import com.pushtorefresh.storio.sqlite.queries.RawQuery
 import eu.kanade.tachiyomi.data.database.DbProvider
 import eu.kanade.tachiyomi.data.database.models.History
-import eu.kanade.tachiyomi.data.database.resolvers.HistoryUpsertResolver
+import eu.kanade.tachiyomi.data.database.models.MangaChapterHistory
+import eu.kanade.tachiyomi.data.database.resolvers.HistoryLastReadPutResolver
+import eu.kanade.tachiyomi.data.database.resolvers.MangaChapterHistoryGetResolver
 import eu.kanade.tachiyomi.data.database.tables.HistoryTable
+import java.util.Date
 
 interface HistoryQueries : DbProvider {
 
+    /**
+     * Insert history into database
+     * @param history object containing history information
+     */
+    fun insertHistory(history: History) = db.put().`object`(history).prepare()
+
+    /**
+     * Returns history of recent manga containing last read chapter
+     * @param date recent date range
+     * @param limit the limit of manga to grab
+     * @param offset offset the db by
+     * @param search what to search in the db history
+     */
+    fun getRecentManga(date: Date, limit: Int = 25, offset: Int = 0, search: String = "") = db.get()
+        .listOfObjects(MangaChapterHistory::class.java)
+        .withQuery(
+            RawQuery.builder()
+                .query(getRecentMangasQuery(search))
+                .args(date.time, limit, offset)
+                .observesTables(HistoryTable.TABLE)
+                .build(),
+        )
+        .withGetResolver(MangaChapterHistoryGetResolver.INSTANCE)
+        .prepare()
+
     fun getHistoryByMangaId(mangaId: Long) = db.get()
         .listOfObjects(History::class.java)
         .withQuery(
@@ -36,9 +64,9 @@ interface HistoryQueries : DbProvider {
      * Inserts history object if not yet in database
      * @param history history object
      */
-    fun upsertHistoryLastRead(history: History) = db.put()
+    fun updateHistoryLastRead(history: History) = db.put()
         .`object`(history)
-        .withPutResolver(HistoryUpsertResolver())
+        .withPutResolver(HistoryLastReadPutResolver())
         .prepare()
 
     /**
@@ -46,12 +74,12 @@ interface HistoryQueries : DbProvider {
      * Inserts history object if not yet in database
      * @param historyList history object list
      */
-    fun upsertHistoryLastRead(historyList: List<History>) = db.put()
+    fun updateHistoryLastRead(historyList: List<History>) = db.put()
         .objects(historyList)
-        .withPutResolver(HistoryUpsertResolver())
+        .withPutResolver(HistoryLastReadPutResolver())
         .prepare()
 
-    fun dropHistoryTable() = db.delete()
+    fun deleteHistory() = db.delete()
         .byQuery(
             DeleteQuery.builder()
                 .table(HistoryTable.TABLE)

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

@@ -70,8 +70,7 @@ fun getRecentMangasQuery(search: String = "") =
     SELECT ${Chapter.TABLE}.${Chapter.COL_MANGA_ID},${Chapter.TABLE}.${Chapter.COL_ID} as ${History.COL_CHAPTER_ID}, MAX(${History.TABLE}.${History.COL_LAST_READ}) as ${History.COL_LAST_READ}
     FROM ${Chapter.TABLE} JOIN ${History.TABLE}
     ON ${Chapter.TABLE}.${Chapter.COL_ID} = ${History.TABLE}.${History.COL_CHAPTER_ID}
-    GROUP BY ${Chapter.TABLE}.${Chapter.COL_MANGA_ID}
-    ) AS max_last_read
+    GROUP BY ${Chapter.TABLE}.${Chapter.COL_MANGA_ID}) AS max_last_read
     ON ${Chapter.TABLE}.${Chapter.COL_MANGA_ID} = max_last_read.${Chapter.COL_MANGA_ID}
     WHERE ${History.TABLE}.${History.COL_LAST_READ} > ?
     AND max_last_read.${History.COL_CHAPTER_ID} = ${History.TABLE}.${History.COL_CHAPTER_ID}

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

@@ -11,7 +11,7 @@ import eu.kanade.tachiyomi.data.database.mappers.HistoryPutResolver
 import eu.kanade.tachiyomi.data.database.models.History
 import eu.kanade.tachiyomi.data.database.tables.HistoryTable
 
-class HistoryUpsertResolver : HistoryPutResolver() {
+class HistoryLastReadPutResolver : HistoryPutResolver() {
 
     /**
      * Updates last_read time of chapter

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/CategoryTable.kt

@@ -11,4 +11,13 @@ object CategoryTable {
     const val COL_ORDER = "sort"
 
     const val COL_FLAGS = "flags"
+
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_NAME TEXT NOT NULL,
+            $COL_ORDER INTEGER NOT NULL,
+            $COL_FLAGS INTEGER NOT NULL
+            )"""
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/ChapterTable.kt

@@ -27,4 +27,42 @@ object ChapterTable {
     const val COL_CHAPTER_NUMBER = "chapter_number"
 
     const val COL_SOURCE_ORDER = "source_order"
+
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_MANGA_ID INTEGER NOT NULL,
+            $COL_URL TEXT NOT NULL,
+            $COL_NAME TEXT NOT NULL,
+            $COL_SCANLATOR TEXT,
+            $COL_READ BOOLEAN NOT NULL,
+            $COL_BOOKMARK BOOLEAN NOT NULL,
+            $COL_LAST_PAGE_READ INT NOT NULL,
+            $COL_CHAPTER_NUMBER FLOAT NOT NULL,
+            $COL_SOURCE_ORDER INTEGER NOT NULL,
+            $COL_DATE_FETCH LONG NOT NULL,
+            $COL_DATE_UPLOAD LONG NOT NULL,
+            FOREIGN KEY($COL_MANGA_ID) REFERENCES ${MangaTable.TABLE} (${MangaTable.COL_ID})
+            ON DELETE CASCADE
+            )"""
+
+    val createMangaIdIndexQuery: String
+        get() = "CREATE INDEX ${TABLE}_${COL_MANGA_ID}_index ON $TABLE($COL_MANGA_ID)"
+
+    val createUnreadChaptersIndexQuery: String
+        get() = "CREATE INDEX ${TABLE}_unread_by_manga_index ON $TABLE($COL_MANGA_ID, $COL_READ) " +
+            "WHERE $COL_READ = 0"
+
+    val sourceOrderUpdateQuery: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_SOURCE_ORDER INTEGER DEFAULT 0"
+
+    val bookmarkUpdateQuery: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_BOOKMARK BOOLEAN DEFAULT FALSE"
+
+    val addScanlator: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_SCANLATOR TEXT DEFAULT NULL"
+
+    val fixDateUploadIfNeeded: String
+        get() = "UPDATE $TABLE SET $COL_DATE_UPLOAD = $COL_DATE_FETCH WHERE $COL_DATE_UPLOAD = 0"
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/HistoryTable.kt

@@ -26,4 +26,24 @@ object HistoryTable {
      * Time read column name
      */
     const val COL_TIME_READ = "${TABLE}_time_read"
+
+    /**
+     * query to create history table
+     */
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_CHAPTER_ID INTEGER NOT NULL UNIQUE,
+            $COL_LAST_READ LONG,
+            $COL_TIME_READ LONG,
+            FOREIGN KEY($COL_CHAPTER_ID) REFERENCES ${ChapterTable.TABLE} (${ChapterTable.COL_ID})
+            ON DELETE CASCADE
+            )"""
+
+    /**
+     * query to index history chapter id
+     */
+    val createChapterIdIndexQuery: String
+        get() = "CREATE INDEX ${TABLE}_${COL_CHAPTER_ID}_index ON $TABLE($COL_CHAPTER_ID)"
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/MangaCategoryTable.kt

@@ -9,4 +9,16 @@ object MangaCategoryTable {
     const val COL_MANGA_ID = "manga_id"
 
     const val COL_CATEGORY_ID = "category_id"
+
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_MANGA_ID INTEGER NOT NULL,
+            $COL_CATEGORY_ID INTEGER NOT NULL,
+            FOREIGN KEY($COL_CATEGORY_ID) REFERENCES ${CategoryTable.TABLE} (${CategoryTable.COL_ID})
+            ON DELETE CASCADE,
+            FOREIGN KEY($COL_MANGA_ID) REFERENCES ${MangaTable.TABLE} (${MangaTable.COL_ID})
+            ON DELETE CASCADE
+            )"""
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/MangaTable.kt

@@ -47,4 +47,53 @@ object MangaTable {
     const val COMPUTED_COL_UNREAD_COUNT = "unread_count"
 
     const val COMPUTED_COL_READ_COUNT = "read_count"
+
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_SOURCE INTEGER NOT NULL,
+            $COL_URL TEXT NOT NULL,
+            $COL_ARTIST TEXT,
+            $COL_AUTHOR TEXT,
+            $COL_DESCRIPTION TEXT,
+            $COL_GENRE TEXT,
+            $COL_TITLE TEXT NOT NULL,
+            $COL_STATUS INTEGER NOT NULL,
+            $COL_THUMBNAIL_URL TEXT,
+            $COL_FAVORITE INTEGER NOT NULL,
+            $COL_LAST_UPDATE LONG,
+            $COL_NEXT_UPDATE LONG,
+            $COL_INITIALIZED BOOLEAN NOT NULL,
+            $COL_VIEWER INTEGER NOT NULL,
+            $COL_CHAPTER_FLAGS INTEGER NOT NULL,
+            $COL_COVER_LAST_MODIFIED LONG NOT NULL,
+            $COL_DATE_ADDED LONG NOT NULL
+            )"""
+
+    val createUrlIndexQuery: String
+        get() = "CREATE INDEX ${TABLE}_${COL_URL}_index ON $TABLE($COL_URL)"
+
+    val createLibraryIndexQuery: String
+        get() = "CREATE INDEX library_${COL_FAVORITE}_index ON $TABLE($COL_FAVORITE) " +
+            "WHERE $COL_FAVORITE = 1"
+
+    val addCoverLastModified: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_COVER_LAST_MODIFIED LONG NOT NULL DEFAULT 0"
+
+    val addDateAdded: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_DATE_ADDED LONG NOT NULL DEFAULT 0"
+
+    /**
+     * Used with addDateAdded to populate it with the oldest chapter fetch date.
+     */
+    val backfillDateAdded: String
+        get() = "UPDATE $TABLE SET $COL_DATE_ADDED = " +
+            "(SELECT MIN(${ChapterTable.COL_DATE_FETCH}) " +
+            "FROM $TABLE INNER JOIN ${ChapterTable.TABLE} " +
+            "ON $TABLE.$COL_ID = ${ChapterTable.TABLE}.${ChapterTable.COL_MANGA_ID} " +
+            "GROUP BY $TABLE.$COL_ID)"
+
+    val addNextUpdateCol: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_NEXT_UPDATE LONG DEFAULT 0"
 }

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/TrackTable.kt

@@ -30,6 +30,43 @@ object TrackTable {
 
     const val COL_FINISH_DATE = "finish_date"
 
+    val createTableQuery: String
+        get() =
+            """CREATE TABLE $TABLE(
+            $COL_ID INTEGER NOT NULL PRIMARY KEY,
+            $COL_MANGA_ID INTEGER NOT NULL,
+            $COL_SYNC_ID INTEGER NOT NULL,
+            $COL_MEDIA_ID INTEGER NOT NULL,
+            $COL_LIBRARY_ID INTEGER,
+            $COL_TITLE TEXT NOT NULL,
+            $COL_LAST_CHAPTER_READ REAL NOT NULL,
+            $COL_TOTAL_CHAPTERS INTEGER NOT NULL,
+            $COL_STATUS INTEGER NOT NULL,
+            $COL_SCORE FLOAT NOT NULL,
+            $COL_TRACKING_URL TEXT NOT NULL,
+            $COL_START_DATE LONG NOT NULL,
+            $COL_FINISH_DATE LONG NOT NULL,
+            UNIQUE ($COL_MANGA_ID, $COL_SYNC_ID) ON CONFLICT REPLACE,
+            FOREIGN KEY($COL_MANGA_ID) REFERENCES ${MangaTable.TABLE} (${MangaTable.COL_ID})
+            ON DELETE CASCADE
+            )"""
+
+    val addTrackingUrl: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_TRACKING_URL TEXT DEFAULT ''"
+
+    val addLibraryId: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_LIBRARY_ID INTEGER NULL"
+
+    val addStartDate: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_START_DATE LONG NOT NULL DEFAULT 0"
+
+    val addFinishDate: String
+        get() = "ALTER TABLE $TABLE ADD COLUMN $COL_FINISH_DATE LONG NOT NULL DEFAULT 0"
+
+    val renameTableToTemp: String
+        get() =
+            "ALTER TABLE $TABLE RENAME TO ${TABLE}_tmp"
+
     val insertFromTempTable: String
         get() =
             """
@@ -37,4 +74,7 @@ object TrackTable {
             |SELECT $COL_ID,$COL_MANGA_ID,$COL_SYNC_ID,$COL_MEDIA_ID,$COL_LIBRARY_ID,$COL_TITLE,$COL_LAST_CHAPTER_READ,$COL_TOTAL_CHAPTERS,$COL_STATUS,$COL_SCORE,$COL_TRACKING_URL,$COL_START_DATE,$COL_FINISH_DATE
             |FROM ${TABLE}_tmp
             """.trimMargin()
+
+    val dropTempTable: String
+        get() = "DROP TABLE ${TABLE}_tmp"
 }

app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt

@@ -166,7 +166,7 @@ class NotificationReceiver : BroadcastReceiver() {
      * @param chapterId id of chapter
      */
     private fun openChapter(context: Context, mangaId: Long, chapterId: Long) {
-        val db = Injekt.get<DatabaseHelper>()
+        val db = DatabaseHelper(context)
         val manga = db.getManga(mangaId).executeAsBlocking()
         val chapter = db.getChapter(chapterId).executeAsBlocking()
         if (manga != null && chapter != null) {

app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt

@@ -7,7 +7,6 @@ import androidx.core.content.edit
 import androidx.core.net.toUri
 import androidx.preference.PreferenceManager
 import com.fredporciuncula.flow.preferences.FlowSharedPreferences
-import eu.kanade.tachiyomi.BuildConfig
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.track.TrackService
@@ -19,6 +18,7 @@ import eu.kanade.tachiyomi.ui.library.setting.SortModeSetting
 import eu.kanade.tachiyomi.ui.reader.setting.OrientationType
 import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType
 import eu.kanade.tachiyomi.util.system.DeviceUtil
+import eu.kanade.tachiyomi.util.system.isDevFlavor
 import eu.kanade.tachiyomi.widget.ExtendedNavigationView
 import java.io.File
 import java.text.DateFormat
@@ -26,7 +26,6 @@ import java.text.SimpleDateFormat
 import java.util.Locale
 import eu.kanade.tachiyomi.data.preference.PreferenceKeys as Keys
 import eu.kanade.tachiyomi.data.preference.PreferenceValues as Values
-import eu.kanade.tachiyomi.util.system.isDevFlavor
 
 class PreferencesHelper(val context: Context) {