Client Reset for collections in mixed / nested collections

src/realm/dictionary.cpp

@@ -800,23 +800,16 @@ bool Dictionary::replace_link(ObjLink old_link, ObjLink replace_link)
     return false;
 }
 
-void Dictionary::remove_backlinks(CascadeState& state) const
+bool Dictionary::remove_backlinks(CascadeState& state) const
 {
     size_t sz = size();
+    bool recurse = false;
     for (size_t ndx = 0; ndx < sz; ndx++) {
-        auto val = m_values->get(ndx);
-        if (val.is_type(type_TypedLink)) {
-            Base::remove_backlink(m_col_key, val.get_link(), state);
-        }
-        else if (val.is_type(type_Dictionary)) {
-            auto key = do_get_key(ndx);
-            get_dictionary(key.get_string())->remove_backlinks(state);
-        }
-        else if (val.is_type(type_List)) {
-            auto key = do_get_key(ndx);
-            get_list(key.get_string())->remove_backlinks(state);
+        if (clear_backlink(ndx, state)) {
+            recurse = true;
         }
     }
+    return recurse;
 }
 
 size_t Dictionary::find_first(Mixed value) const
@@ -827,16 +820,12 @@ size_t Dictionary::find_first(Mixed value) const
 void Dictionary::clear()
 {
     if (size() > 0) {
-        Replication* repl = get_replication();
-        bool recurse = false;
-        CascadeState cascade_state(CascadeState::Mode::Strong);
-        if (repl) {
+        if (Replication* repl = get_replication()) {
             repl->dictionary_clear(*this);
         }
-        for (auto&& elem : *this) {
-            if (clear_backlink(elem.second, cascade_state))
-                recurse = true;
-        }
+        CascadeState cascade_state(CascadeState::Mode::Strong);
+        bool recurse = remove_backlinks(cascade_state);
+
         // Just destroy the whole cluster
         m_dictionary_top->destroy_deep();
         m_dictionary_top.reset();
@@ -958,10 +947,9 @@ Mixed Dictionary::do_get(size_t ndx) const
 
 void Dictionary::do_erase(size_t ndx, Mixed key)
 {
-    auto old_value = m_values->get(ndx);
-
     CascadeState cascade_state(CascadeState::Mode::Strong);
-    bool recurse = clear_backlink(old_value, cascade_state);
+    bool recurse = clear_backlink(ndx, cascade_state);
+
     if (recurse)
         _impl::TableFriend::remove_recursive(*get_table_unchecked(), cascade_state); // Throws
 
@@ -971,7 +959,6 @@ void Dictionary::do_erase(size_t ndx, Mixed key)
 
     m_keys->erase(ndx);
     m_values->erase(ndx);
-
     bump_content_version();
 }
 
@@ -996,11 +983,20 @@ std::pair<Mixed, Mixed> Dictionary::do_get_pair(size_t ndx) const
     return {do_get_key(ndx), do_get(ndx)};
 }
 
-bool Dictionary::clear_backlink(Mixed value, CascadeState& state) const
+bool Dictionary::clear_backlink(size_t ndx, CascadeState& state) const
 {
+    auto value = m_values->get(ndx);
     if (value.is_type(type_TypedLink)) {
         return Base::remove_backlink(m_col_key, value.get_link(), state);
     }
+    if (value.is_type(type_Dictionary)) {
+        auto key = do_get_key(ndx);
+        return get_dictionary(key.get_string())->remove_backlinks(state);
+    }
+    if (value.is_type(type_List)) {
+        auto key = do_get_key(ndx);
+        return get_list(key.get_string())->remove_backlinks(state);
+    }
     return false;
 }
 

src/realm/dictionary.hpp

@@ -137,7 +137,7 @@ class Dictionary final : public CollectionBaseImpl<DictionaryBase>, public Colle
     void nullify(size_t);
     bool nullify(ObjLink target_link);
     bool replace_link(ObjLink old_link, ObjLink replace_link);
-    void remove_backlinks(CascadeState& state) const;
+    bool remove_backlinks(CascadeState& state) const;
     size_t find_first(Mixed value) const;
 
     void clear() final;
@@ -242,7 +242,7 @@ class Dictionary final : public CollectionBaseImpl<DictionaryBase>, public Colle
     size_t do_find_key(Mixed key) const noexcept;
     std::pair<size_t, Mixed> find_impl(Mixed key) const noexcept;
     std::pair<Mixed, Mixed> do_get_pair(size_t ndx) const;
-    bool clear_backlink(Mixed value, CascadeState& state) const;
+    bool clear_backlink(size_t ndx, CascadeState& state) const;
     void align_indices(std::vector<size_t>& indices) const;
     void swap_content(Array& fields1, Array& fields2, size_t index1, size_t index2);
 

src/realm/list.cpp

@@ -418,9 +418,14 @@ void Lst<Mixed>::clear()
         if (Replication* repl = Base::get_replication()) {
             repl->list_clear(*this);
         }
-        size_t ndx = size();
-        while (ndx--) {
-            do_remove(ndx);
+        CascadeState state;
+        bool recurse = remove_backlinks(state);
+
+        m_tree->clear();
+
+        if (recurse) {
+            auto table = get_table_unchecked();
+            _impl::TableFriend::remove_recursive(*table, state); // Throws
         }
         bump_content_version();
     }
@@ -573,34 +578,14 @@ void Lst<Mixed>::do_insert(size_t ndx, Mixed value)
 
 void Lst<Mixed>::do_remove(size_t ndx)
 {
-    Mixed old_value = m_tree->get(ndx);
-    if (old_value.is_type(type_TypedLink, type_Dictionary, type_List)) {
-
-        bool recurse = false;
-        CascadeState state;
-        if (old_value.is_type(type_TypedLink)) {
-            auto old_link = old_value.get<ObjLink>();
-            if (old_link.get_obj_key().is_unresolved()) {
-                state.m_mode = CascadeState::Mode::All;
-            }
-            recurse = Base::remove_backlink(m_col_key, old_link, state);
-        }
-        else if (old_value.is_type(type_List)) {
-            get_list(ndx)->remove_backlinks(state);
-        }
-        else if (old_value.is_type(type_Dictionary)) {
-            get_dictionary(ndx)->remove_backlinks(state);
-        }
+    CascadeState state;
+    bool recurse = clear_backlink(ndx, state);
 
-        m_tree->erase(ndx);
+    m_tree->erase(ndx);
 
-        if (recurse) {
-            auto table = get_table_unchecked();
-            _impl::TableFriend::remove_recursive(*table, state); // Throws
-        }
-    }
-    else {
-        m_tree->erase(ndx);
+    if (recurse) {
+        auto table = get_table_unchecked();
+        _impl::TableFriend::remove_recursive(*table, state); // Throws
     }
 }
 
@@ -822,21 +807,37 @@ bool Lst<Mixed>::replace_link(ObjLink old_link, ObjLink replace_link)
     return false;
 }
 
-void Lst<Mixed>::remove_backlinks(CascadeState& state) const
+bool Lst<Mixed>::clear_backlink(size_t ndx, CascadeState& state) const
 {
-    size_t sz = size();
-    for (size_t ndx = 0; ndx < sz; ndx++) {
-        Mixed val = m_tree->get(ndx);
-        if (val.is_type(type_TypedLink)) {
-            Base::remove_backlink(m_col_key, val.get_link(), state);
+    Mixed value = m_tree->get(ndx);
+    if (value.is_type(type_TypedLink, type_Dictionary, type_List)) {
+        if (value.is_type(type_TypedLink)) {
+            auto link = value.get<ObjLink>();
+            if (link.get_obj_key().is_unresolved()) {
+                state.m_mode = CascadeState::Mode::All;
+            }
+            return Base::remove_backlink(m_col_key, link, state);
         }
-        else if (val.is_type(type_List)) {
-            get_list(ndx)->remove_backlinks(state);
+        else if (value.is_type(type_List)) {
+            return get_list(ndx)->remove_backlinks(state);
         }
-        else if (val.is_type(type_Dictionary)) {
-            get_dictionary(ndx)->remove_backlinks(state);
+        else if (value.is_type(type_Dictionary)) {
+            return get_dictionary(ndx)->remove_backlinks(state);
+        }
+    }
+    return false;
+}
+
+bool Lst<Mixed>::remove_backlinks(CascadeState& state) const
+{
+    size_t sz = size();
+    bool recurse = false;
+    for (size_t ndx = 0; ndx < sz; ndx++) {
+        if (clear_backlink(ndx, state)) {
+            recurse = true;
         }
     }
+    return recurse;
 }
 
 bool Lst<Mixed>::update_if_needed() const

src/realm/list.hpp

@@ -490,7 +490,7 @@ class Lst<Mixed> final : public CollectionBaseImpl<LstBase>, public CollectionPa
 
     bool nullify(ObjLink);
     bool replace_link(ObjLink old_link, ObjLink replace_link);
-    void remove_backlinks(CascadeState& state) const;
+    bool remove_backlinks(CascadeState& state) const;
     TableRef get_table() const noexcept override
     {
         return get_obj().get_table();
@@ -548,6 +548,7 @@ class Lst<Mixed> final : public CollectionBaseImpl<LstBase>, public CollectionPa
 
         return unresolved_to_null(m_tree->get(ndx));
     }
+    bool clear_backlink(size_t ndx, CascadeState& state) const;
 };
 
 // Specialization of Lst<ObjKey>:

src/realm/obj.cpp

@@ -211,6 +211,11 @@ bool Obj::compare_values(Mixed val1, Mixed val2, ColKey ck, Obj other, StringDat
                 Lst<Mixed> lst2(other, other.get_column_key(col_name));
                 return compare_list_in_mixed(lst1, lst2, ck, other, col_name);
             }
+            else if (type == type_Set) {
+                Set<Mixed> set1(*this, ck);
+                Set<Mixed> set2(other, other.get_column_key(col_name));
+                return set1 == set2;
+            }
             else if (type == type_Dictionary) {
                 Dictionary dict1(*this, ck);
                 Dictionary dict2(other, other.get_column_key(col_name));
@@ -1145,11 +1150,11 @@ Obj& Obj::set<Mixed>(ColKey col_key, Mixed value, bool is_default)
     }
     else if (old_value.is_type(type_Dictionary)) {
         Dictionary dict(*this, col_key);
-        dict.remove_backlinks(state);
+        recurse = dict.remove_backlinks(state);
     }
     else if (old_value.is_type(type_List)) {
         Lst<Mixed> list(*this, col_key);
-        list.remove_backlinks(state);
+        recurse = list.remove_backlinks(state);
     }
 
     if (value.is_type(type_TypedLink)) {
@@ -2028,16 +2033,25 @@ CollectionPtr Obj::get_collection_by_stable_path(const StablePath& path) const
     while (level < path.size()) {
         auto& index = path[level];
         auto get_ref = [&]() -> std::pair<Mixed, PathElement> {
+            Mixed ref;
+            PathElement path_elem;
             if (collection->get_collection_type() == CollectionType::List) {
                 auto list_of_mixed = dynamic_cast<Lst<Mixed>*>(collection.get());
                 size_t ndx = list_of_mixed->find_index(index);
-                return {list_of_mixed->get(ndx), PathElement(ndx)};
+                if (ndx != realm::not_found) {
+                    ref = list_of_mixed->get(ndx);
+                    path_elem = ndx;
+                }
             }
             else {
                 auto dict = dynamic_cast<Dictionary*>(collection.get());
                 size_t ndx = dict->find_index(index);
-                return {dict->get_any(ndx), PathElement(dict->get_key(ndx).get_string())};
+                if (ndx != realm::not_found) {
+                    ref = dict->get_any(ndx);
+                    path_elem = dict->get_key(ndx).get_string();
+                }
             }
+            return {ref, path_elem};
         };
         auto [ref, path_elem] = get_ref();
         if (ref.is_type(type_List)) {