Add a schema migration that drops the query cache

This is a force fix for potential existence filter mismatches caused by
#1548

The essential problem is that when resuming a query, the server is
allowed to forget deletes. If the number of incorrectly synthesized
deletes matches the number of server-forgotten deletes then the
existence filter can give a false positive, preventing the cache from
self healing.

Dropping the query cache clears any client-side resume token which
prevents a false positive existence filter mismatch.

Note that the remote document cache and mutation queues are unaffected
so any cached documents that do exist will still work while offline

firebase/firebase-js-sdk#1019

Author: wilhuff

Firestore/Example/Tests/Local/FSTLevelDBMigrationsTests.mm

@@ -23,17 +23,22 @@
 #import "Firestore/Source/Local/FSTLevelDB.h"
 #import "Firestore/Source/Local/FSTLevelDBKey.h"
 #import "Firestore/Source/Local/FSTLevelDBMigrations.h"
+#import "Firestore/Source/Local/FSTLevelDBMutationQueue.h"
 #import "Firestore/Source/Local/FSTLevelDBQueryCache.h"
 
 #include "Firestore/core/src/firebase/firestore/util/ordered_code.h"
+#include "Firestore/core/src/firebase/firestore/util/status.h"
+#include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 #include "leveldb/db.h"
 
 #import "Firestore/Example/Tests/Local/FSTPersistenceTestHelpers.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
+using firebase::firestore::FirestoreErrorCode;
 using firebase::firestore::local::LevelDbTransaction;
 using firebase::firestore::util::OrderedCode;
+using firebase::firestore::testutil::Key;
 using leveldb::DB;
 using leveldb::Options;
 using leveldb::Status;
@@ -94,11 +99,7 @@ - (void)testCountsQueries {
     }
     // Add a dummy entry after the targets to make sure the iteration is correctly bounded.
     // Use a table that would sort logically right after that table 'target'.
-    std::string dummyKey;
-    // Magic number that indicates a table name follows. Needed to mimic the prefix to the target
-    // table.
-    OrderedCode::WriteSignedNumIncreasing(&dummyKey, 5);
-    OrderedCode::WriteString(&dummyKey, "targetA");
+    std::string dummyKey = [self dummyKeyForTable:"targetA"];
     transaction.Put(dummyKey, "dummy");
     transaction.Commit();
   }
@@ -112,6 +113,80 @@ - (void)testCountsQueries {
   }
 }
 
+#define ASSERT_NOT_FOUND(transaction, key)                \
+  do {                                                    \
+    std::string unused_result;                            \
+    Status status = transaction.Get(key, &unused_result); \
+    XCTAssertTrue(status.IsNotFound());                   \
+  } while (0)
+
+#define ASSERT_FOUND(transaction, key)                    \
+  do {                                                    \
+    std::string unused_result;                            \
+    Status status = transaction.Get(key, &unused_result); \
+    XCTAssertTrue(status.ok());                           \
+  } while (0)
+
+- (void)testDropsTheQueryCache {
+  NSString *userID = @"user";
+  FSTBatchID batchID = 1;
+  FSTTargetID targetID = 2;
+
+  FSTDocumentKey *key1 = Key("documents/1");
+  FSTDocumentKey *key2 = Key("documents/2");
+
+  std::string targetKeys[] = {
+      [FSTLevelDBTargetKey keyWithTargetID:targetID],
+      [FSTLevelDBTargetDocumentKey keyWithTargetID:targetID documentKey:key1],
+      [FSTLevelDBTargetDocumentKey keyWithTargetID:targetID documentKey:key2],
+      [FSTLevelDBDocumentTargetKey keyWithDocumentKey:key1 targetID:targetID],
+      [FSTLevelDBDocumentTargetKey keyWithDocumentKey:key2 targetID:targetID]};
+
+  std::string preservedKeys[] = {[self dummyKeyForTable:"targetA"],
+                                 [FSTLevelDBMutationQueueKey keyWithUserID:userID],
+                                 [FSTLevelDBMutationKey keyWithUserID:userID batchID:batchID]};
+
+  {
+    // Setup some targets to be counted in the migration.
+    LevelDbTransaction transaction(_db.get(), "testDropsTheQueryCache setup");
+    [FSTLevelDBMigrations runMigrationsWithTransaction:&transaction upToVersion:1];
+
+    for (const std::string &key : targetKeys) {
+      transaction.Put(key, "target");
+    }
+
+    for (const std::string &key : preservedKeys) {
+      transaction.Put(key, "preserved");
+    }
+    transaction.Commit();
+  }
+
+  {
+    LevelDbTransaction transaction(_db.get(), "testDropsTheQueryCache");
+    [FSTLevelDBMigrations runMigrationsWithTransaction:&transaction upToVersion:2];
+
+    for (const std::string &key : targetKeys) {
+      ASSERT_NOT_FOUND(transaction, key);
+    }
+
+    for (const std::string &key : preservedKeys) {
+      ASSERT_FOUND(transaction, key);
+    }
+  }
+}
+
+/**
+ * Creates the name of a dummy entry to make sure the iteration is correctly bounded.
+ */
+- (std::string)dummyKeyForTable:(const char *)tableName {
+  std::string dummyKey;
+  // Magic number that indicates a table name follows. Needed to mimic the prefix to the target
+  // table.
+  OrderedCode::WriteSignedNumIncreasing(&dummyKey, 5);
+  OrderedCode::WriteString(&dummyKey, tableName);
+  return dummyKey;
+}
+
 @end
 
 NS_ASSUME_NONNULL_END

Firestore/Source/Local/FSTLevelDBMigrations.h

@@ -38,6 +38,12 @@ typedef int32_t FSTLevelDBSchemaVersion;
  */
 + (void)runMigrationsWithTransaction:(firebase::firestore::local::LevelDbTransaction *)transaction;
 
+/**
+ * Runs any migrations needed to bring the given database up to the given schema version
+ */
++ (void)runMigrationsWithTransaction:(firebase::firestore::local::LevelDbTransaction *)transaction
+                         upToVersion:(FSTLevelDBSchemaVersion)version;
+
 @end
 
 NS_ASSUME_NONNULL_END

Firestore/Source/Local/FSTLevelDBMigrations.mm

@@ -24,16 +24,16 @@
 
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 #include "absl/base/macros.h"
+#include "absl/memory/memory.h"
 #include "absl/strings/match.h"
 #include "leveldb/write_batch.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
 // Current version of the schema defined in this file.
-static FSTLevelDBSchemaVersion kSchemaVersion = 2;
+static FSTLevelDBSchemaVersion kSchemaVersion = 3;
 
 using firebase::firestore::local::LevelDbTransaction;
-using leveldb::DB;
 using leveldb::Iterator;
 using leveldb::Status;
 using leveldb::Slice;
@@ -87,6 +87,49 @@ static void AddTargetCount(LevelDbTransaction *transaction) {
   transaction->Put([FSTLevelDBTargetGlobalKey key], targetGlobal);
 }
 
+/**
+ * A class representing all migrations to prepare the LevelDB database for use.
+ *
+ * TODO(wilhuff): All the migrations should really be a part of this but to minimize the scope of
+ * this change for now it's constrained to just the new one.
+ */
+class LevelDbSchema {
+ public:
+  explicit LevelDbSchema(leveldb::DB *db) : db_{db} {
+  }
+
+  void DropQueryCache();
+
+ private:
+  void DeleteEverythingWithPrefix(const std::string &prefix);
+
+  leveldb::DB *db_;
+  std::unique_ptr<LevelDbTransaction> transaction_;
+};
+
+void LevelDbSchema::DropQueryCache() {
+  transaction_ = absl::make_unique<LevelDbTransaction>(db_, "Drop Query Cache");
+
+  DeleteEverythingWithPrefix([FSTLevelDBTargetKey keyPrefix]);
+  DeleteEverythingWithPrefix([FSTLevelDBDocumentTargetKey keyPrefix]);
+  DeleteEverythingWithPrefix([FSTLevelDBTargetDocumentKey keyPrefix]);
+
+  transaction_->Commit();
+}
+
+void LevelDbSchema::DeleteEverythingWithPrefix(const std::string &prefix) {
+  LevelDbTransaction reader(db_, "Reader");
+  auto it = reader.NewIterator();
+
+  for (it->Seek(prefix); it->Valid() && absl::StartsWith(it->key(), prefix); it->Next()) {
+    if (transaction_->changed_keys() >= 1000) {
+      transaction_->Commit();
+      transaction_ = absl::make_unique<LevelDbTransaction>(db_, "Drop Query Cache");
+    }
+    transaction_->Delete(it->key());
+  }
+}
+
 @implementation FSTLevelDBMigrations
 
 + (FSTLevelDBSchemaVersion)schemaVersionWithTransaction:
@@ -102,22 +145,37 @@ + (FSTLevelDBSchemaVersion)schemaVersionWithTransaction:
 }
 
 + (void)runMigrationsWithTransaction:(firebase::firestore::local::LevelDbTransaction *)transaction {
+  [self runMigrationsWithTransaction:transaction upToVersion:kSchemaVersion];
+}
+
++ (void)runMigrationsWithTransaction:(firebase::firestore::local::LevelDbTransaction *)transaction
+                         upToVersion:(FSTLevelDBSchemaVersion)upToVersion {
   FSTLevelDBSchemaVersion currentVersion = [self schemaVersionWithTransaction:transaction];
   // Each case in this switch statement intentionally falls through. This lets us
   // start at the current schema version and apply any migrations that have not yet
   // been applied, to bring us up to current, as defined by the kSchemaVersion constant.
   switch (currentVersion) {
     case 0:
+      if (upToVersion < 0) break;
       EnsureTargetGlobal(transaction);
       ABSL_FALLTHROUGH_INTENDED;
     case 1:
       // We're now guaranteed that the target global exists. We can safely add a count to it.
+      if (upToVersion < 1) break;
       AddTargetCount(transaction);
       ABSL_FALLTHROUGH_INTENDED;
-    default:
-      if (currentVersion < kSchemaVersion) {
-        SaveVersion(kSchemaVersion, transaction);
+    case 2:
+      if (upToVersion < 2) break;
+      if (currentVersion != 0) {
+        LevelDbSchema schema{transaction->database()};
+        schema.DropQueryCache();
       }
+      ABSL_FALLTHROUGH_INTENDED;
+    default:
+      break;
+  }
+  if (currentVersion < upToVersion) {
+    SaveVersion(upToVersion, transaction);
   }
 }
 

Firestore/core/src/firebase/firestore/local/leveldb_transaction.h

@@ -144,6 +144,14 @@ class LevelDbTransaction {
    */
   static const leveldb::WriteOptions& DefaultWriteOptions();
 
+  leveldb::DB* database() const {
+    return db_;
+  }
+
+  size_t changed_keys() {
+    return mutations_.size() + deletions_.size();
+  }
+
   /**
    * Remove the database entry (if any) for "key".  It is not an error if "key"
    * did not exist in the database.