QueryIn support, channel cache query grouped

app/src/androidTest/java/com/futo/platformplayer/ManagedDBStoreTests.kt

 package com.futo.platformplayer
 
 import androidx.test.platform.app.InstrumentationRegistry
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.stores.db.ManagedDBDescriptor
 import com.futo.platformplayer.stores.db.ManagedDBStore
 import com.futo.platformplayer.testing.DBTOs
@@ -288,6 +289,24 @@ class ManagedDBStoreTests {
             Assert.assertEquals(34, results.size);
         }
     }
+    @Test
+    fun queryIn() {
+        val ids = mutableListOf<String>()
+        testQuery(1100, { i, testObject ->
+            testObject.someNum = i;
+            ids.add(testObject.someStr);
+        }) {
+            val pager = it.queryInPager(DBTOs.TestIndex::someString, ids.take(1000), 65);
+            val list = mutableListOf<Any>();
+            list.addAll(pager.getResults());
+            while(pager.hasMorePages())
+            {
+                pager.nextPage();
+                list.addAll(pager.getResults());
+            }
+            Assert.assertEquals(1000, list.size);
+        }
+    }
 
 
     private fun testQuery(items: Int, modifier: (Int, DBTOs.TestObject)->Unit, testing: (ManagedDBStore<DBTOs.TestIndex, DBTOs.TestObject, DBTOs.DB, DBTOs.DBDAO>)->Unit) {

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/SubscriptionsFeedFragment.kt

@@ -40,6 +40,8 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import java.time.OffsetDateTime
+import kotlin.system.measureTimeMillis
+import kotlin.time.measureTime
 
 class SubscriptionsFeedFragment : MainFragment() {
     override val isMainView : Boolean = true;
@@ -309,9 +311,12 @@ class SubscriptionsFeedFragment : MainFragment() {
 
         private fun loadCache() {
             fragment.lifecycleScope.launch(Dispatchers.IO) {
+                val cachePager: IPager<IPlatformContent>;
                 Logger.i(TAG, "Subscriptions retrieving cache");
-                val cachePager = StateCache.instance.getSubscriptionCachePager();
-                Logger.i(TAG, "Subscriptions retrieved cache");
+                val time = measureTimeMillis {
+                    cachePager = StateCache.instance.getSubscriptionCachePager();
+                }
+                Logger.i(TAG, "Subscriptions retrieved cache (${time}ms)");
 
                 withContext(Dispatchers.Main) {
                     val results = cachePager.getResults();

app/src/main/java/com/futo/platformplayer/states/StateCache.kt

@@ -39,11 +39,22 @@ class StateCache {
     }
 
     fun getChannelCachePager(channelUrl: String): IPager<IPlatformContent> {
-        return _subscriptionCache.queryPager(DBSubscriptionCache.Index::channelUrl, channelUrl, 20) {
-            if(it.objOrNull?.contentType == ContentType.POST)
-                Logger.i(TAG, "FOUND CACHED POST\n (${it.objOrNull?.name})");
-            it.obj;
+        val result: IPager<IPlatformContent>;
+        val time = measureTimeMillis {
+            result = _subscriptionCache.queryPager(DBSubscriptionCache.Index::channelUrl, channelUrl, 20) {
+                it.obj;
+            }
+        }
+        return result;
+    }
+    fun getAllChannelCachePager(channelUrls: List<String>): IPager<IPlatformContent> {
+        val result: IPager<IPlatformContent>;
+        val time = measureTimeMillis {
+            result = _subscriptionCache.queryInPager(DBSubscriptionCache.Index::channelUrl, channelUrls, 20) {
+                it.obj;
+            }
         }
+        return result;
     }
     fun getChannelCachePager(channelUrls: List<String>): IPager<IPlatformContent> {
         val pagers = MultiChronoContentPager(channelUrls.map { _subscriptionCache.queryPager(DBSubscriptionCache.Index::channelUrl, it, 20) {
@@ -64,12 +75,20 @@ class StateCache {
         }.flatten().distinct();
 
         Logger.i(TAG, "Subscriptions CachePager get pagers");
-        val pagers = allUrls.parallelStream()
-            .map { getChannelCachePager(it) }
-            .asSequence()
-            .toList();
+        val pagers: List<IPager<IPlatformContent>>;
+
+        val timeCacheRetrieving = measureTimeMillis {
+            pagers = listOf(getAllChannelCachePager(allUrls));
+
+                /*allUrls.parallelStream()
+                .map {
+                    getChannelCachePager(it)
+                }
+                .asSequence()
+                .toList();*/
+        }
 
-        Logger.i(TAG, "Subscriptions CachePager compiling");
+        Logger.i(TAG, "Subscriptions CachePager compiling (retrieved in ${timeCacheRetrieving}ms)");
         val pager = MultiChronoContentPager(pagers, false, 20);
         pager.initialize();
         Logger.i(TAG, "Subscriptions CachePager compiled");

app/src/main/java/com/futo/platformplayer/stores/db/ManagedDBStore.kt

@@ -265,6 +265,7 @@ class ManagedDBStore<I: ManagedDBIndex<T>, T, D: ManagedDBDatabase<T, I, DA>, DA
         return deserializeIndexes(dbDaoBase.getMultiple(query));
     }
 
+
     fun queryLikePage(field: KProperty<*>, obj: String, page: Int, pageSize: Int): List<I> = queryLikePage(validateFieldName(field), obj, page, pageSize);
     fun queryLikePage(field: String, obj: String, page: Int, pageSize: Int): List<I> {
         val queryStr = "SELECT * FROM ${descriptor.table_name} WHERE ${field} LIKE ? ${_orderSQL} LIMIT ? OFFSET ?";
@@ -289,6 +290,38 @@ class ManagedDBStore<I: ManagedDBIndex<T>, T, D: ManagedDBDatabase<T, I, DA>, DA
         });
     }
 
+
+    fun queryInPage(field: KProperty<*>, obj: List<String>, page: Int, pageSize: Int): List<I> = queryInPage(validateFieldName(field), obj, page, pageSize);
+    fun queryInPage(field: String, obj: List<String>, page: Int, pageSize: Int): List<I> {
+        val queryStr = "SELECT * FROM ${descriptor.table_name} WHERE ${field} IN (${obj.joinToString(",") { "?" }}) ${_orderSQL} LIMIT ? OFFSET ?";
+        val query = SimpleSQLiteQuery(queryStr, (obj + arrayOf(pageSize, page * pageSize)).toTypedArray());
+        return deserializeIndexes(dbDaoBase.getMultiple(query));
+    }
+    fun queryInObjectPage(field: String, obj: List<String>, page: Int, pageSize: Int): List<T> {
+        return convertObjects(queryInPage(field, obj, page, pageSize));
+    }
+    fun queryInPager(field: KProperty<*>, obj: List<String>, pageSize: Int): IPager<I> = queryInPager(validateFieldName(field), obj, pageSize);
+    fun queryInPager(field: String, obj: List<String>, pageSize: Int): IPager<I> {
+        return AdhocPager({
+            Logger.i("ManagedDBStore", "Next Page [query: ${obj}](${it}) ${pageSize}");
+            queryInPage(field, obj, it - 1, pageSize);
+        });
+    }
+    fun queryInObjectPager(field: KProperty<*>, obj: List<String>, pageSize: Int): IPager<T> = queryInObjectPager(validateFieldName(field), obj, pageSize);
+    fun queryInObjectPager(field: String, obj: List<String>, pageSize: Int): IPager<T> {
+        return AdhocPager({
+            Logger.i("ManagedDBStore", "Next Page [query: ${obj}](${it}) ${pageSize}");
+            queryInObjectPage(field, obj, it - 1, pageSize);
+        });
+    }
+
+    fun <X> queryInPager(field: KProperty<*>, obj: List<String>, pageSize: Int, convert: (I)->X): IPager<X> = queryInPager(validateFieldName(field), obj, pageSize, convert);
+    fun <X> queryInPager(field: String, obj: List<String>, pageSize: Int, convert: (I)->X): IPager<X> {
+        return AdhocPager({
+            queryInPage(field, obj, it - 1, pageSize).map(convert);
+        });
+    }
+
     fun queryLikePager(field: KProperty<*>, obj: String, pageSize: Int): IPager<I> = queryLikePager(validateFieldName(field), obj, pageSize);
     fun queryLikePager(field: String, obj: String, pageSize: Int): IPager<I> {
         return AdhocPager({