Avoid inserting identical records

Author: BoD

normalized-cache-sqlite/src/commonMain/kotlin/com/apollographql/cache/normalized/sql/SqlNormalizedCache.kt

@@ -173,11 +173,11 @@ class SqlNormalizedCache internal constructor(
           val record = record.withDates(receivedDate = receivedDate, expirationDate = expirationDate)
           val existingRecord = existingRecords[record.key]
           if (existingRecord == null) {
-            recordDatabase.insertOrUpdateRecord(record)
+            recordDatabase.insertOrUpdateRecord(record, deleteFirst = false)
             record.fieldKeys()
           } else {
             val (mergedRecord, changedKeys) = recordMerger.merge(RecordMergerContext(existing = existingRecord, incoming = record, cacheHeaders = cacheHeaders))
-            if (mergedRecord.isNotEmpty()) {
+            if (mergedRecord.isNotEmpty() && mergedRecord != existingRecord) {
               recordDatabase.insertOrUpdateRecord(mergedRecord)
             }
             changedKeys

normalized-cache-sqlite/src/commonMain/kotlin/com/apollographql/cache/normalized/sql/internal/RecordDatabase.kt

@@ -100,8 +100,8 @@ internal class RecordDatabase(
   /**
    * Must be called inside a transaction.
    */
-  suspend fun insertOrUpdateRecord(record: Record) {
-    recordQueries.deleteRecords(listOf(record.key.key))
+  suspend fun insertOrUpdateRecord(record: Record, deleteFirst: Boolean = true) {
+    if (deleteFirst) recordQueries.deleteRecords(listOf(record.key.key))
     val recordBytes = RecordSerializer.serialize(record)
     val updatedDate = currentTimeMillis()
     // Fast path for small records

normalized-cache-sqlite/src/jvmTest/kotlin/com/apollographql/cache/normalized/sql/JvmSqlNormalizedCacheTest.kt

@@ -0,0 +1,93 @@
+package com.apollographql.cache.normalized.sql
+
+import app.cash.sqldelight.db.QueryResult
+import app.cash.sqldelight.db.SqlCursor
+import app.cash.sqldelight.db.SqlDriver
+import app.cash.sqldelight.db.SqlPreparedStatement
+import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
+import com.apollographql.cache.normalized.api.CacheHeaders
+import com.apollographql.cache.normalized.api.CacheKey
+import com.apollographql.cache.normalized.api.DefaultRecordMerger
+import com.apollographql.cache.normalized.api.Record
+import com.apollographql.cache.normalized.sql.internal.RecordDatabase
+import com.apollographql.cache.normalized.testing.runTest
+import java.util.Properties
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class JvmSqlNormalizedCacheTest {
+  @Test
+  fun mergingIdenticalRecordIsANoOp() = runTest {
+    val driver = SpyDriver(JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY, Properties()))
+    val cache = SqlNormalizedCache(RecordDatabase(driver, null))
+    // Initial insert
+    cache.merge(
+        record = Record(
+            key = CacheKey.QUERY_ROOT,
+            fields = mapOf(
+                "a" to "0",
+            ),
+        ),
+        cacheHeaders = CacheHeaders.NONE,
+        recordMerger = DefaultRecordMerger,
+    )
+    var count = driver.count
+
+    // Insert the same record
+    cache.merge(
+        record = Record(
+            key = CacheKey.QUERY_ROOT,
+            fields = mapOf(
+                "a" to "0",
+            ),
+        ),
+        cacheHeaders = CacheHeaders.NONE,
+        recordMerger = DefaultRecordMerger,
+    )
+
+    // Expected 1 select, 0 insert
+    assertEquals(1, driver.count - count)
+    count = driver.count
+
+    // Insert a different record
+    cache.merge(
+        record = Record(
+            key = CacheKey.QUERY_ROOT,
+            fields = mapOf(
+                "a" to "1",
+            ),
+        ),
+        cacheHeaders = CacheHeaders.NONE,
+        recordMerger = DefaultRecordMerger,
+    )
+
+    // Expected 1 select, 1 delete, 1 insert
+    assertEquals(3, driver.count - count)
+
+  }
+}
+
+private class SpyDriver(private val delegate: SqlDriver) : SqlDriver by delegate {
+  var count = 0
+
+  override fun execute(
+      identifier: Int?,
+      sql: String,
+      parameters: Int,
+      binders: (SqlPreparedStatement.() -> Unit)?,
+  ): QueryResult<Long> {
+    count++
+    return delegate.execute(identifier, sql, parameters, binders)
+  }
+
+  override fun <R> executeQuery(
+      identifier: Int?,
+      sql: String,
+      mapper: (SqlCursor) -> QueryResult<R>,
+      parameters: Int,
+      binders: (SqlPreparedStatement.() -> Unit)?,
+  ): QueryResult<R> {
+    count++
+    return delegate.executeQuery(identifier, sql, mapper, parameters, binders)
+  }
+}

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/api/Record.kt

@@ -57,6 +57,24 @@ class Record(
     return result
   }
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Record) return false
+
+    if (key != other.key) return false
+    if (fields != other.fields) return false
+    if (metadata != other.metadata) return false
+
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result = key.hashCode()
+    result = 31 * result + fields.hashCode()
+    result = 31 * result + metadata.hashCode()
+    return result
+  }
+
   companion object {
     internal fun changedKeys(record1: Record, record2: Record): Set<String> {
       check(record1.key == record2.key) {

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/memory/MemoryCache.kt

@@ -130,8 +130,10 @@ class MemoryCache(
           record.fieldKeys()
         } else {
           val (mergedRecord, changedKeys) = recordMerger.merge(RecordMergerContext(existing = existingRecord, incoming = record, cacheHeaders = cacheHeaders))
-          recordsToInsert.add(mergedRecord)
-          lruCache[record.key] = mergedRecord
+          if (mergedRecord != existingRecord) {
+            recordsToInsert.add(mergedRecord)
+            lruCache[record.key] = mergedRecord
+          }
           changedKeys
         }
       }.toSet()