Firebase cpp: Avoid potentially expensive copy of write tree for every write tree update

PiperOrigin-RevId: 278462144

Author: markchandler

database/src/desktop/core/compound_write.cc

@@ -60,8 +60,15 @@ CompoundWrite CompoundWrite::EmptyWrite() { return CompoundWrite(); }
 
 CompoundWrite CompoundWrite::AddWrite(const Path& path,
                                       const Optional<Variant>& variant) const {
+  CompoundWrite target = *this;
+  target.AddWriteInline(path, variant);
+  return target;
+}
+
+void CompoundWrite::AddWriteInline(const Path& path,
+                                   const Optional<Variant>& variant) {
   if (path.empty()) {
-    return CompoundWrite(Tree<Variant>(variant));
+    *this = CompoundWrite(Tree<Variant>(variant));
   } else {
     Optional<Path> root_most_path = write_tree_.FindRootMostPathWithValue(path);
     if (root_most_path.has_value()) {
@@ -78,18 +85,13 @@ CompoundWrite CompoundWrite::AddWrite(const Path& path,
       if (!relative_path->empty() && IsPriorityKey(back) &&
           VariantIsEmpty(VariantGetChild(value, relative_path->GetParent()))) {
         // Ignore priority updates on empty variants
-        return *this;
       } else {
-        CompoundWrite result = *this;
         Variant updated_variant = *value;
         VariantUpdateChild(&updated_variant, *relative_path, *variant);
-        result.write_tree_.SetValueAt(*root_most_path, updated_variant);
-        return result;
+        write_tree_.SetValueAt(*root_most_path, updated_variant);
       }
     } else {
-      CompoundWrite result = *this;
-      result.write_tree_.SetValueAt(path, variant);
-      return result;
+      write_tree_.SetValueAt(path, variant);
     }
   }
 }
@@ -109,6 +111,20 @@ CompoundWrite CompoundWrite::AddWrite(const std::string& key,
   return AddWrite(Path(key), Optional<Variant>(value));
 }
 
+void CompoundWrite::AddWriteInline(const Path& path, const Variant& value) {
+  AddWriteInline(path, Optional<Variant>(value));
+}
+
+void CompoundWrite::AddWriteInline(const std::string& key,
+                                   const Optional<Variant>& value) {
+  AddWriteInline(Path(key), value);
+}
+
+void CompoundWrite::AddWriteInline(const std::string& key,
+                                   const Variant& value) {
+  AddWriteInline(Path(key), Optional<Variant>(value));
+}
+
 CompoundWrite CompoundWrite::AddWrites(const Path& path,
                                        const CompoundWrite& updates) const {
   return updates.write_tree_.Fold(
@@ -118,6 +134,15 @@ CompoundWrite CompoundWrite::AddWrites(const Path& path,
       });
 }
 
+void CompoundWrite::AddWritesInline(const Path& path,
+                                    const CompoundWrite& updates) {
+  updates.write_tree_.Fold(
+      0, [&path, this](Path relative_path, Variant value, int) {
+        AddWriteInline(path.GetChild(relative_path), Optional<Variant>(value));
+        return 0;
+      });
+}
+
 CompoundWrite CompoundWrite::RemoveWrite(const Path& path) const {
   if (path.empty()) {
     return CompoundWrite();
@@ -133,6 +158,18 @@ CompoundWrite CompoundWrite::RemoveWrite(const Path& path) const {
   return CompoundWrite();
 }
 
+void CompoundWrite::RemoveWriteInline(const Path& path) {
+  if (path.empty()) {
+    *this = CompoundWrite();
+  } else {
+    Tree<Variant>* subtree = write_tree_.GetChild(path);
+    if (subtree) {
+      subtree->children().clear();
+      subtree->value().reset();
+    }
+  }
+}
+
 bool CompoundWrite::HasCompleteWrite(const Path& path) const {
   return GetCompleteVariant(path).has_value();
 }

database/src/desktop/core/compound_write.h

@@ -66,17 +66,32 @@ class CompoundWrite {
                          const Optional<Variant>& value) const;
   CompoundWrite AddWrite(const std::string& key, const Variant& value) const;
 
+  // Incorperate the new value to write at the given path.
+  void AddWriteInline(const Path& path, const Optional<Variant>& variant);
+  void AddWriteInline(const Path& path, const Variant& value);
+  void AddWriteInline(const std::string& key,
+    const Optional<Variant>& value);
+  void AddWriteInline(const std::string& key, const Variant& value);
+
   // Create a new CompoundWrite that incorperates all of the writes in the given
   // CompoundWrite at the given path.
   CompoundWrite AddWrites(const Path& path, const CompoundWrite& updates) const;
 
+  // Incorperate all of the writes in the given CompoundWrite at the given path.
+  void AddWritesInline(const Path& path, const CompoundWrite& updates);
+
   // Will remove a write at the given path and deeper paths. This will not
   // modify a write at a higher location, which must be removed by calling this
   // method with that path.
   //
   // Returns the new WriteCompound with the removed path
   CompoundWrite RemoveWrite(const Path& path) const;
 
+  // Will remove a write at the given path and deeper paths. This will not
+  // modify a write at a higher location, which must be removed by calling this
+  // method with that path.
+  void RemoveWriteInline(const Path& path);
+
   // Returns whether this CompoundWrite will fully overwrite a node at a given
   // location and can therefore be considered "complete".
   bool HasCompleteWrite(const Path& path) const;

database/src/desktop/core/write_tree.cc

@@ -40,7 +40,7 @@ void WriteTree::AddOverwrite(const Path& path, const Variant& snap,
   all_writes_.push_back(
       UserWriteRecord(write_id, path, snap, visibility == kOverwriteVisible));
   if (visibility == kOverwriteVisible) {
-    visible_writes_ = visible_writes_.AddWrite(path, snap);
+    visible_writes_.AddWriteInline(path, snap);
   }
   last_write_id_ = write_id;
 }
@@ -51,7 +51,7 @@ void WriteTree::AddMerge(const Path& path,
   // Stacking an older write on top of newer ones.
   FIREBASE_DEV_ASSERT(write_id > last_write_id_);
   all_writes_.push_back(UserWriteRecord(write_id, path, changed_children));
-  visible_writes_ = visible_writes_.AddWrites(path, changed_children);
+  visible_writes_.AddWritesInline(path, changed_children);
   last_write_id_ = write_id;
 }
 
@@ -116,12 +116,11 @@ bool WriteTree::RemoveWrite(WriteId write_id) {
     // There's no shadowing.  We can safely just remove the write(s) from
     // visible_writes_.
     if (write_to_remove.is_overwrite) {
-      visible_writes_ = visible_writes_.RemoveWrite(write_to_remove.path);
+      visible_writes_.RemoveWriteInline(write_to_remove.path);
     } else {
       for (auto& entry : write_to_remove.merge.write_tree().children()) {
         Path path(entry.first);
-        visible_writes_ =
-            visible_writes_.RemoveWrite(write_to_remove.path.GetChild(path));
+        visible_writes_.RemoveWriteInline(write_to_remove.path.GetChild(path));
       }
     }
     return true;