Improve TDD caching

nightscout · Jan 23, 2025 · 5b80a0b · 5b80a0b
1 parent 6481454
commit 5b80a0b
Show file tree

Hide file tree

Showing 7 changed files with 73 additions and 17 deletions.
diff --git a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/db/PersistenceLayer.kt b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/db/PersistenceLayer.kt
@@ -1263,9 +1263,9 @@ interface PersistenceLayer {
     fun getCalculatedTotalDailyDose(timestamp: Long): TDD?
 
     /**
-     * Insert new record to database
+     * Insert or update record
      */
-    fun insertTotalDailyDose(totalDailyDose: TDD)
+    fun insertOrUpdateCachedTotalDailyDose(totalDailyDose: TDD): Single<TransactionResult<TDD>>
 
     /**
      * Insert or update if exists record

diff --git a/database/impl/src/main/kotlin/app/aaps/database/AppRepository.kt b/database/impl/src/main/kotlin/app/aaps/database/AppRepository.kt
@@ -715,10 +715,6 @@ class AppRepository @Inject internal constructor(
         database.totalDailyDoseDao.findByTimestamp(timestamp, InterfaceIDs.PumpType.CACHE)
             .subscribeOn(Schedulers.io())
 
-    fun insertTotalDailyDose(tdd: TotalDailyDose) {
-        Schedulers.io().scheduleDirect { database.totalDailyDoseDao.insert(tdd) }
-    }
-
     // OFFLINE EVENT
     fun findOfflineEventByNSId(nsId: String): OfflineEvent? =
         database.offlineEventDao.findByNSId(nsId)

diff --git a/database/impl/src/main/kotlin/app/aaps/database/daos/TotalDailyDoseDao.kt b/database/impl/src/main/kotlin/app/aaps/database/daos/TotalDailyDoseDao.kt
@@ -27,7 +27,10 @@ internal interface TotalDailyDoseDao : TraceableDao<TotalDailyDose> {
     fun findByPumpIds(pumpId: Long, pumpType: InterfaceIDs.PumpType, pumpSerial: String): TotalDailyDose?
 
     @Query("SELECT * FROM $TABLE_TOTAL_DAILY_DOSES WHERE unlikely(timestamp = :timestamp) AND likely(pumpType = :pumpType) AND likely(pumpSerial = :pumpSerial) AND likely(referenceId IS NULL)")
-    fun findByPumpTimestamp(timestamp: Long, pumpType: InterfaceIDs.PumpType, pumpSerial: String): TotalDailyDose?
+    fun findByPumpTimestamp(timestamp: Long, pumpType: InterfaceIDs.PumpType?, pumpSerial: String?): TotalDailyDose?
+
+    @Query("SELECT * FROM $TABLE_TOTAL_DAILY_DOSES WHERE unlikely(timestamp = :timestamp) AND likely(pumpType = :pumpType) AND likely(referenceId IS NULL) ORDER BY id DESC")
+    fun findByPumpTimestamp(timestamp: Long, pumpType: InterfaceIDs.PumpType?): TotalDailyDose?
 
     @Query("SELECT * FROM $TABLE_TOTAL_DAILY_DOSES WHERE unlikely(timestamp = :timestamp) AND likely(pumpType = :pumpType) AND likely(referenceId IS NULL)")
     fun findByTimestamp(timestamp: Long, pumpType: InterfaceIDs.PumpType): Maybe<TotalDailyDose>

diff --git a/...in/kotlin/app/aaps/database/transactions/InsertOrUpdateCachedTotalDailyDoseTransaction.kt b/...in/kotlin/app/aaps/database/transactions/InsertOrUpdateCachedTotalDailyDoseTransaction.kt
@@ -0,0 +1,38 @@
+package app.aaps.database.transactions
+
+import app.aaps.database.entities.TotalDailyDose
+import app.aaps.database.entities.embedments.InterfaceIDs
+
+/**
+ * Creates or updates the TotalDailyDose from data caching
+ */
+class InsertOrUpdateCachedTotalDailyDoseTransaction(
+    private val tdd: TotalDailyDose
+) : Transaction<InsertOrUpdateCachedTotalDailyDoseTransaction.TransactionResult>() {
+
+    override fun run(): TransactionResult {
+        val result = TransactionResult()
+        var current: TotalDailyDose? = null
+        // search by timestamp
+        current = database.totalDailyDoseDao.findByPumpTimestamp(tdd.timestamp, InterfaceIDs.PumpType.CACHE)
+        if (current == null) {
+            database.totalDailyDoseDao.insertNewEntry(tdd)
+            result.inserted.add(tdd)
+        } else {
+            current.basalAmount = tdd.basalAmount
+            current.bolusAmount = tdd.bolusAmount
+            current.totalAmount = tdd.totalAmount
+            current.carbs = tdd.carbs
+            database.totalDailyDoseDao.updateExistingEntry(current)
+            result.updated.add(current)
+        }
+
+        return result
+    }
+
+    class TransactionResult {
+
+        val inserted = mutableListOf<TotalDailyDose>()
+        val updated = mutableListOf<TotalDailyDose>()
+    }
+}
diff --git a/.../impl/src/main/kotlin/app/aaps/database/transactions/SyncPumpTotalDailyDoseTransaction.kt b/.../impl/src/main/kotlin/app/aaps/database/transactions/SyncPumpTotalDailyDoseTransaction.kt
@@ -21,7 +21,7 @@ class SyncPumpTotalDailyDoseTransaction(
         }
         // search by timestamp
         if (current == null) {
-            current = database.totalDailyDoseDao.findByPumpTimestamp(tdd.timestamp, tdd.interfaceIDs.pumpType!!, tdd.interfaceIDs.pumpSerial!!)
+            current = database.totalDailyDoseDao.findByPumpTimestamp(tdd.timestamp, tdd.interfaceIDs.pumpType, tdd.interfaceIDs.pumpSerial)
         }
         if (current == null) {
             database.totalDailyDoseDao.insertNewEntry(tdd)

diff --git a/database/persistence/src/main/kotlin/app/aaps/database/persistence/PersistenceLayerImpl.kt b/database/persistence/src/main/kotlin/app/aaps/database/persistence/PersistenceLayerImpl.kt
@@ -47,6 +47,7 @@ import app.aaps.database.transactions.InsertIfNewByTimestampTherapyEventTransact
 import app.aaps.database.transactions.InsertOrUpdateApsResultTransaction
 import app.aaps.database.transactions.InsertOrUpdateBolusCalculatorResultTransaction
 import app.aaps.database.transactions.InsertOrUpdateBolusTransaction
+import app.aaps.database.transactions.InsertOrUpdateCachedTotalDailyDoseTransaction
 import app.aaps.database.transactions.InsertOrUpdateCarbsTransaction
 import app.aaps.database.transactions.InsertOrUpdateHeartRateTransaction
 import app.aaps.database.transactions.InsertOrUpdateProfileSwitch
@@ -1709,10 +1710,21 @@ class PersistenceLayerImpl @Inject constructor(
     override fun getCalculatedTotalDailyDose(timestamp: Long): TDD? =
         repository.getCalculatedTotalDailyDose(timestamp).map { it.fromDb() }.blockingGet()
 
-    override fun insertTotalDailyDose(totalDailyDose: TDD) {
-        repository.insertTotalDailyDose(totalDailyDose.toDb())
-        aapsLogger.debug(LTag.DATABASE, "Inserted TDD $totalDailyDose")
-    }
+    override fun insertOrUpdateCachedTotalDailyDose(totalDailyDose: TDD): Single<PersistenceLayer.TransactionResult<TDD>> =
+        repository.runTransactionForResult(InsertOrUpdateCachedTotalDailyDoseTransaction(totalDailyDose.toDb()))
+            .doOnError { aapsLogger.error(LTag.DATABASE, "Error while saving TotalDailyDose $it") }
+            .map { result ->
+                val transactionResult = PersistenceLayer.TransactionResult<TDD>()
+                result.inserted.forEach {
+                    aapsLogger.debug(LTag.DATABASE, "Inserted TotalDailyDose ${dateUtil.dateString(it.timestamp)} $it")
+                    transactionResult.inserted.add(it.fromDb())
+                }
+                result.updated.forEach {
+                    aapsLogger.debug(LTag.DATABASE, "Updated TotalDailyDose ${dateUtil.dateString(it.timestamp)} $it")
+                    transactionResult.updated.add(it.fromDb())
+                }
+                transactionResult
+            }
 
     override fun insertOrUpdateTotalDailyDose(totalDailyDose: TDD): Single<PersistenceLayer.TransactionResult<TDD>> =
         repository.runTransactionForResult(SyncPumpTotalDailyDoseTransaction(totalDailyDose.toDb()))

diff --git a/implementation/src/main/kotlin/app/aaps/implementation/stats/TddCalculatorImpl.kt b/implementation/src/main/kotlin/app/aaps/implementation/stats/TddCalculatorImpl.kt
@@ -49,18 +49,24 @@ class TddCalculatorImpl @Inject constructor(
             .plusDays(days)
             .toInstant().toEpochMilli()
 
+        aapsLogger.debug(LTag.DATABASE, "Calculating TotalDailyDose from ${dateUtil.dateString(startTime)} to ${dateUtil.dateString(endTime)}")
+
         val result = LongSparseArray<TDD>()
         // Try to load cached values
         while (startTime < endTime) {
-            persistenceLayer.getCalculatedTotalDailyDose(startTime)?.let { result.put(startTime, it) } ?: break
-            //startTime += stepSize
-            startTime = MidnightTime.calc(startTime + T.hours(27).msecs()) // be sure we find correct midnight
+            aapsLogger.debug(LTag.DATABASE, "Looking for cached TotalDailyDose for ${dateUtil.dateString(startTime)}")
+            persistenceLayer.getCalculatedTotalDailyDose(startTime)?.let {
+                result.put(startTime, it)
+                aapsLogger.debug(LTag.DATABASE, "Loaded cached TotalDailyDose for ${dateUtil.dateString(it.timestamp)} $it")
+            } ?: break
+            startTime = MidnightTime.calc(startTime + T.hours(27).msecs()) // be sure we find correct midnight during DST change
         }
 
         if (endTime > startTime) {
             var midnight = startTime
             while (midnight < endTime) {
                 val tdd = calculateInterval(midnight, midnight + T.hours(24).msecs(), allowMissingData = false)
+                aapsLogger.debug(LTag.DATABASE, "Calculated TotalDailyDose for ${dateUtil.dateString(midnight)} $tdd")
                 if (tdd != null) result.put(midnight, tdd)
                 midnight = MidnightTime.calc(midnight + T.hours(27).msecs()) // be sure we find correct midnight
             }
@@ -69,8 +75,9 @@ class TddCalculatorImpl @Inject constructor(
             val tdd = result.valueAt(i)
             if (tdd.ids.pumpType != PumpType.CACHE) {
                 tdd.ids.pumpType = PumpType.CACHE
-                aapsLogger.debug(LTag.CORE, "Storing TDD ${tdd.timestamp}")
-                persistenceLayer.insertTotalDailyDose(tdd)
+                persistenceLayer.insertOrUpdateCachedTotalDailyDose(tdd).subscribe()
+            } else {
+                aapsLogger.debug(LTag.DATABASE, "Skipping storing TotalDailyDose for ${dateUtil.dateString(tdd.timestamp)}")
             }
         }
         if (result.size.toLong() == days || allowMissingDays) return result