Complete implementation of C++ MutationBatch (#3672)

* Implement the rest of MutationBatch

* Teach LocalSerializer about base_mutations

Author: wilhuff

Firestore/core/src/firebase/firestore/local/local_serializer.cc

@@ -257,15 +257,25 @@ firestore_client_WriteBatch LocalSerializer::EncodeMutationBatch(
   firestore_client_WriteBatch result{};
 
   result.batch_id = mutation_batch.batch_id();
-  pb_size_t count = CheckedSize(mutation_batch.mutations().size());
+
+  pb_size_t count = CheckedSize(mutation_batch.base_mutations().size());
+  result.base_writes_count = count;
+  result.base_writes = MakeArray<google_firestore_v1_Write>(count);
+  int i = 0;
+  for (const auto& mutation : mutation_batch.base_mutations()) {
+    result.base_writes[i] = rpc_serializer_.EncodeMutation(mutation);
+    i++;
+  }
+
+  count = CheckedSize(mutation_batch.mutations().size());
   result.writes_count = count;
   result.writes = MakeArray<google_firestore_v1_Write>(count);
-  int i = 0;
+  i = 0;
   for (const auto& mutation : mutation_batch.mutations()) {
-    HARD_ASSERT(mutation.is_valid(), "Invalid mutation encountered.");
     result.writes[i] = rpc_serializer_.EncodeMutation(mutation);
     i++;
   }
+
   result.local_write_time =
       rpc_serializer_.EncodeTimestamp(mutation_batch.local_write_time());
 
@@ -277,13 +287,21 @@ MutationBatch LocalSerializer::DecodeMutationBatch(
   int batch_id = proto.batch_id;
   Timestamp local_write_time =
       rpc_serializer_.DecodeTimestamp(reader, proto.local_write_time);
+
+  std::vector<Mutation> base_mutations;
+  for (size_t i = 0; i < proto.base_writes_count; i++) {
+    base_mutations.push_back(
+        rpc_serializer_.DecodeMutation(reader, proto.base_writes[i]));
+  }
+
   std::vector<Mutation> mutations;
   for (size_t i = 0; i < proto.writes_count; i++) {
     mutations.push_back(
         rpc_serializer_.DecodeMutation(reader, proto.writes[i]));
   }
 
-  return MutationBatch(batch_id, local_write_time, std::move(mutations));
+  return MutationBatch(batch_id, local_write_time, std::move(base_mutations),
+                       std::move(mutations));
 }
 
 }  // namespace local

Firestore/core/src/firebase/firestore/model/CMakeLists.txt

@@ -44,6 +44,8 @@ cc_library(
     mutation.h
     mutation_batch.cc
     mutation_batch.h
+    mutation_batch_result.cc
+    mutation_batch_result.h
     no_document.cc
     no_document.h
     patch_mutation.cc

Firestore/core/src/firebase/firestore/model/mutation.cc

@@ -18,18 +18,31 @@
 
 #include <cstdlib>
 #include <ostream>
+#include <sstream>
 #include <utility>
 
 #include "Firestore/core/src/firebase/firestore/model/document.h"
 #include "Firestore/core/src/firebase/firestore/model/field_path.h"
 #include "Firestore/core/src/firebase/firestore/model/field_value.h"
 #include "Firestore/core/src/firebase/firestore/model/no_document.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "Firestore/core/src/firebase/firestore/util/to_string.h"
+#include "absl/strings/str_cat.h"
 
 namespace firebase {
 namespace firestore {
 namespace model {
 
+std::string MutationResult::ToString() const {
+  return absl::StrCat(
+      "MutationResult(version=", version_.ToString(),
+      ", transform_results=", util::ToString(transform_results_), ")");
+}
+
+std::ostream& operator<<(std::ostream& os, const MutationResult& result) {
+  return os << result.ToString();
+}
+
 Mutation::Rep::Rep(DocumentKey&& key, Precondition&& precondition)
     : key_(std::move(key)), precondition_(std::move(precondition)) {
 }

Firestore/core/src/firebase/firestore/model/mutation.h

@@ -78,6 +78,11 @@ class MutationResult {
     return transform_results_;
   }
 
+  std::string ToString() const;
+
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const MutationResult& result);
+
  private:
   SnapshotVersion version_;
   absl::optional<const std::vector<FieldValue>> transform_results_;

Firestore/core/src/firebase/firestore/model/mutation_batch.cc

@@ -19,6 +19,7 @@
 #include <ostream>
 #include <utility>
 
+#include "Firestore/core/src/firebase/firestore/model/mutation_batch_result.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 #include "Firestore/core/src/firebase/firestore/util/to_string.h"
 
@@ -28,23 +29,109 @@ namespace model {
 
 MutationBatch::MutationBatch(int batch_id,
                              Timestamp local_write_time,
-                             std::vector<Mutation>&& mutations)
+                             std::vector<Mutation> base_mutations,
+                             std::vector<Mutation> mutations)
     : batch_id_(batch_id),
       local_write_time_(std::move(local_write_time)),
+      base_mutations_(std::move(base_mutations)),
       mutations_(std::move(mutations)) {
   HARD_ASSERT(!mutations_.empty(), "Cannot create an empty mutation batch");
 }
 
+absl::optional<MaybeDocument> MutationBatch::ApplyToRemoteDocument(
+    absl::optional<MaybeDocument> maybe_doc,
+    const DocumentKey& document_key,
+    const MutationBatchResult& mutation_batch_result) {
+  HARD_ASSERT(!maybe_doc || maybe_doc->key() == document_key,
+              "ApplyTo: key %s doesn't match maybe_doc key %s",
+              document_key.ToString(), maybe_doc->key().ToString());
+
+  const auto& mutation_results = mutation_batch_result.mutation_results();
+  HARD_ASSERT(mutation_results.size() == mutations_.size(),
+              "Mismatch between mutations length (%s) and results length (%s)",
+              mutations_.size(), mutation_results.size());
+
+  for (size_t i = 0; i < mutations_.size(); i++) {
+    const Mutation& mutation = mutations_[i];
+    const MutationResult& mutation_result = mutation_results[i];
+    if (mutation.key() == document_key) {
+      maybe_doc = mutation.ApplyToRemoteDocument(maybe_doc, mutation_result);
+    }
+  }
+  return maybe_doc;
+}
+
+absl::optional<MaybeDocument> MutationBatch::ApplyToLocalDocument(
+    absl::optional<MaybeDocument> maybe_doc, const DocumentKey& document_key) {
+  HARD_ASSERT(!maybe_doc || maybe_doc->key() == document_key,
+              "key %s doesn't match maybe_doc key %s", document_key.ToString(),
+              maybe_doc->key().ToString());
+
+  // First, apply the base state. This allows us to apply non-idempotent
+  // transform against a consistent set of values.
+  for (const Mutation& mutation : base_mutations_) {
+    if (mutation.key() == document_key) {
+      maybe_doc =
+          mutation.ApplyToLocalView(maybe_doc, maybe_doc, local_write_time_);
+    }
+  }
+
+  absl::optional<MaybeDocument> base_doc = maybe_doc;
+
+  // Second, apply all user-provided mutations.
+  for (const Mutation& mutation : mutations_) {
+    if (mutation.key() == document_key) {
+      maybe_doc =
+          mutation.ApplyToLocalView(maybe_doc, base_doc, local_write_time_);
+    }
+  }
+  return maybe_doc;
+}
+
+MaybeDocumentMap MutationBatch::ApplyToLocalDocumentSet(
+    const MaybeDocumentMap& document_set) {
+  // TODO(mrschmidt): This implementation is O(n^2). If we iterate through the
+  // mutations first (as done in `applyToLocalDocument:documentKey:`), we can
+  // reduce the complexity to O(n).
+
+  MaybeDocumentMap mutated_documents = document_set;
+  for (const Mutation& mutation : mutations_) {
+    const DocumentKey& key = mutation.key();
+
+    absl::optional<MaybeDocument> previous_document =
+        mutated_documents.get(key);
+    absl::optional<MaybeDocument> mutated_document =
+        ApplyToLocalDocument(std::move(previous_document), key);
+    if (mutated_document) {
+      mutated_documents = mutated_documents.insert(key, *mutated_document);
+    }
+  }
+  return mutated_documents;
+}
+
+DocumentKeySet MutationBatch::keys() const {
+  DocumentKeySet set;
+  for (const Mutation& mutation : mutations_) {
+    set = set.insert(mutation.key());
+  }
+  return set;
+}
+
 bool operator==(const MutationBatch& lhs, const MutationBatch& rhs) {
   return lhs.batch_id() == rhs.batch_id() &&
          lhs.local_write_time() == rhs.local_write_time() &&
+         lhs.base_mutations() == rhs.base_mutations() &&
          lhs.mutations() == rhs.mutations();
 }
 
+std::string MutationBatch::ToString() const {
+  return absl::StrCat("MutationBatch(id=", batch_id_,
+                      ", local_write_time=", local_write_time_.ToString(),
+                      ", mutations=", util::ToString(mutations_), ")");
+}
+
 std::ostream& operator<<(std::ostream& os, const MutationBatch& batch) {
-  return os << "MutationBatch(id=" << batch.batch_id_
-            << ", local_write_time=" << batch.local_write_time_
-            << ", mutations=" << util::ToString(batch.mutations_) << ")";
+  return os << batch.ToString();
 }
 
 }  // namespace model

Firestore/core/src/firebase/firestore/model/mutation_batch.h

@@ -19,19 +19,24 @@
 
 #include <iosfwd>
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
+#include "Firestore/core/src/firebase/firestore/model/document_key_set.h"
+#include "Firestore/core/src/firebase/firestore/model/document_map.h"
 #include "Firestore/core/src/firebase/firestore/model/mutation.h"
 #include "Firestore/core/src/firebase/firestore/model/types.h"
 
 namespace firebase {
 namespace firestore {
 namespace model {
 
+class MutationBatchResult;
+
 /**
- * A BatchID that was searched for and not found or a batch ID value known to be
- * before all known batches.
+ * A BatchID that was searched for and not found or a batch ID value known to
+ * be before all known batches.
  *
  * BatchId values from the local store are non-negative so this value is before
  * all batches.
@@ -48,8 +53,8 @@ constexpr BatchId kBatchIdUnknown = -1;
 class MutationBatch {
  public:
   /**
-   * A batch ID that was searched for and not found or a batch ID value known to
-   * be before all known batches.
+   * A batch ID that was searched for and not found or a batch ID value known
+   * to be before all known batches.
    *
    * Batch ID values from the local store are non-negative so this value is
    * before all batches.
@@ -58,12 +63,10 @@ class MutationBatch {
 
   MutationBatch(int batch_id,
                 Timestamp local_write_time,
-                std::vector<Mutation>&& mutations);
-
-  // TODO(rsgowman): Port ApplyToRemoteDocument()
-  // TODO(rsgowman): Port ApplyToLocalView()
-  // TODO(rsgowman): Port GetKeys()
+                std::vector<Mutation> base_mutations,
+                std::vector<Mutation> mutations);
 
+  /** The unique ID of this mutation batch. */
   int batch_id() const {
     return batch_id_;
   }
@@ -76,17 +79,76 @@ class MutationBatch {
     return local_write_time_;
   }
 
+  /**
+   * Mutations that are used to populate the base values when this mutation is
+   * applied locally. This can be used to locally overwrite values that are
+   * persisted in the remote document cache. Base mutations are never sent to
+   * the backend.
+   */
+  const std::vector<Mutation>& base_mutations() const {
+    return base_mutations_;
+  }
+
+  /**
+   * The user-provided mutations in this mutation batch. User-provided
+   * mutations are applied both locally and remotely on the backend.
+   */
   const std::vector<Mutation>& mutations() const {
     return mutations_;
   }
 
+  /**
+   * Applies all the mutations in this MutationBatch to the specified document
+   * to create a new remote document.
+   *
+   * @param maybe_doc The document to which to apply mutations or nullopt if
+   *     there's no existing document.
+   * @param document_key The key of the document to apply mutations to.
+   * @param mutation_batch_result The result of applying the MutationBatch to
+   *     the backend.
+   */
+  absl::optional<MaybeDocument> ApplyToRemoteDocument(
+      absl::optional<MaybeDocument> maybe_doc,
+      const DocumentKey& document_key,
+      const MutationBatchResult& mutation_batch_result);
+
+  /**
+   * Estimates the latency compensated view of all the mutations in this batch
+   * applied to the given MaybeDocument.
+   *
+   * Unlike ApplyToRemoteDocument, this method is used before the mutation has
+   * been committed and so it's possible that the mutation is operating on a
+   * locally non-existent document and may produce a non-existent document.
+   *
+   * @param maybe_doc The document to which to apply mutations or nullopt if
+   *     there's no existing document.
+   * @param document_key The key of the document to apply mutations to.
+   */
+  absl::optional<MaybeDocument> ApplyToLocalDocument(
+      absl::optional<MaybeDocument> maybe_doc, const DocumentKey& document_key);
+
+  /**
+   * Computes the local view for all provided documents given the mutations in
+   * this batch.
+   */
+  MaybeDocumentMap ApplyToLocalDocumentSet(
+      const MaybeDocumentMap& document_set);
+
+  /**
+   * Returns the set of unique keys referenced by all mutations in the batch.
+   */
+  DocumentKeySet keys() const;
+
   friend bool operator==(const MutationBatch& lhs, const MutationBatch& rhs);
 
+  std::string ToString() const;
+
   friend std::ostream& operator<<(std::ostream& os, const MutationBatch& batch);
 
  private:
   int batch_id_;
   const Timestamp local_write_time_;
+  std::vector<Mutation> base_mutations_;
   std::vector<Mutation> mutations_;
 };