jorgen.edelbo_429

Committed 19 Sep 2024 12:04PM UTC coverage: 91.112% (+0.03%) from 91.081%

Build # jorgen.edelbo_429

Build Type

Pull #8029

Evergreen

Committed by

jedelbo

Commit Message

Fix comparison function for ConditionType

The function should ensure strict weak ordering. According to the current one
 {1, 0} == {0, 1} and {0, 1} == {2, 1}
but
 {1, 0} < {2, 1}

It is not possible to construct a failing test as the outcome very much depends
on how the runtime types are laid out.

Pull Request Pull Request #8029: RCORE:2259: Fix comparison function for ConditionType

Run Details

102804 of 181476 branches covered (56.65%)

1 of 1 new or added line in 1 file covered. (100.0%)

27 existing lines in 9 files now uncovered.

217201 of 238389 relevant lines covered (91.11%)

6231200.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.47

/src/realm/sync/noinst/changeset_index.cpp

#include <realm/sync/noinst/changeset_index.hpp>
#include <realm/sync/object_id.hpp>

#include <iterator> // std::distance, std::advance

using namespace realm::sync;

namespace realm {
namespace _impl {

#if REALM_DEBUG
static bool compare_ranges(const Changeset::Range& left, const Changeset::Range& right)
{
    return left.begin < right.begin;
}

template <class InputIterator>
static bool check_ranges(InputIterator begin, InputIterator end)
{
    if (!std::is_sorted(begin, end, compare_ranges))
        return false;

    // Check that there are no overlaps
    if (begin != end) {
        auto last_end = begin->end;
        for (auto i = begin + 1; i != end; ++i) {
            if (last_end > i->begin)
                return false;
            last_end = i->end;
        }
    }
    return true;
}

static bool check_ranges(const ChangesetIndex::Ranges& ranges)
{
    for (auto& pair : ranges) {
        if (!check_ranges(pair.second.begin(), pair.second.end()))
            return false;
    }
    return true;
}
#endif // REALM_DEBUG


void ChangesetIndex::clear() noexcept
{
    m_object_instructions.clear();
    m_schema_instructions.clear();
    m_conflict_groups_owner.clear();
    m_num_conflict_groups = 0;
}


void ChangesetIndex::scan_changeset(Changeset& changeset)
{
    if (m_contains_destructive_schema_changes)
        return;

#if defined(REALM_DEBUG) // LCOV_EXCL_START
    for (auto& confict_group : m_conflict_groups_owner) {
        // Check that add_changeset() has not been called yet.
        REALM_ASSERT(confict_group.ranges.empty());
    }
#endif // REALM_DEBUG LCOV_EXCL_STOP

    using Instruction = realm::sync::Instruction;

    for (auto it = changeset.begin(); it != changeset.end(); ++it) {
        if (!*it)
            continue;

        const auto& instr = **it;

        if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {
            auto& p = *add_table_instr;
            schema_conflict_group(changeset.get_string(p.table));
        }
        else if (instr.get_if<Instruction::EraseTable>()) {
            m_contains_destructive_schema_changes = true;
            clear();
            return;
        }
        else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {
            auto& p = *add_column_instr;
            StringData table_name = changeset.get_string(p.table);
            ConflictGroup& cg = schema_conflict_group(table_name);
            if (p.type == Instruction::Payload::Type::Link) {
                StringData target_table = changeset.get_string(p.link_target_table);
                ConflictGroup& cg2 = schema_conflict_group(target_table);
                merge_conflict_groups(cg, cg2);
            }
        }
        else if (instr.get_if<Instruction::EraseColumn>()) {
            m_contains_destructive_schema_changes = true;
            clear();
            return;
        }
        else {
            GlobalID ids[2];
            size_t num_ids = get_object_ids_in_instruction(changeset, instr, ids, 2);
            REALM_ASSERT(num_ids >= 1);
            REALM_ASSERT(num_ids <= 2);

            ConflictGroup& cg = object_conflict_group(ids[0]);
            for (size_t i = 1; i < num_ids; ++i) {
                ConflictGroup& cg2 = object_conflict_group(ids[1]);
                merge_conflict_groups(cg, cg2);
            }
        }
    }
}


void ChangesetIndex::merge_conflict_groups(ConflictGroup& into, ConflictGroup& from)
{
    if (&into == &from)
        return;

    if (from.size > into.size) {
        // This is an optimization. The time it takes to merge two conflict
        // groups is proportional to the size of the incoming group (in number
        // of objects touched). If the incoming group is larger, merge the other
        // way.
        merge_conflict_groups(from, into);
        return;
    }

    REALM_ASSERT(into.ranges.empty());
    REALM_ASSERT(from.ranges.empty());

    for (auto& class_name : from.schemas) {
        m_schema_instructions[class_name] = &into;
    }
    into.schemas.insert(into.schemas.end(), from.schemas.begin(), from.schemas.end());

    for (auto& pair : from.objects) {
        auto& objset = into.objects[pair.first];
        auto& objinstr = m_object_instructions[pair.first];
        for (auto& object : pair.second) {
            objinstr[object] = &into;
        }
        objset.insert(objset.end(), pair.second.begin(), pair.second.end());
    }
    into.size += from.size;

    m_conflict_groups_owner.erase(from.self_it);
    --m_num_conflict_groups;
}


void ChangesetIndex::add_changeset(Changeset& log)
{
    if (!log.empty())
        m_everything[&log] = std::vector<Changeset::Range>(1, Changeset::Range{log.begin(), log.end()});

    if (m_contains_destructive_schema_changes)
        return; // Just add to everything.

    using Instruction = realm::sync::Instruction;

    // Iterate over all instructions (skipping tombstones), and add them to the
    // index.
    for (auto it = log.begin(); it != log.end(); ++it) {
        if (!*it)
            continue;

        const auto& instr = **it;

        if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {
            StringData table = log.get_string(add_table_instr->table);
            auto& cg = schema_conflict_group(table);
            add_instruction_at(cg.ranges, log, it);
        }
        else if (instr.get_if<Instruction::EraseTable>()) {
            REALM_TERMINATE("Call scan_changeset() before add_changeset().");
        }
        else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {
            auto& p = *add_column_instr;
            StringData table = log.get_string(p.table);
            auto& cg = schema_conflict_group(table);
            if (p.type == Instruction::Payload::Type::Link) {
                REALM_ASSERT(&cg == &schema_conflict_group(log.get_string(p.link_target_table)));
            }
            add_instruction_at(cg.ranges, log, it);
        }
        else if (instr.get_if<Instruction::EraseColumn>()) {
            REALM_TERMINATE("Call scan_changeset() before add_changeset().");
        }
        else {
            GlobalID ids[2];
            size_t num_ids = get_object_ids_in_instruction(log, instr, ids, 2);
            REALM_ASSERT(num_ids >= 1);
            REALM_ASSERT(num_ids <= 2);

            auto& cg = object_conflict_group(ids[0]);
            for (size_t i = 1; i < num_ids; ++i) {
                REALM_ASSERT(&cg == &object_conflict_group(ids[i]));
            }
            add_instruction_at(cg.ranges, log, it);
        }
    }
}

size_t get_object_ids_in_instruction(const Changeset& changeset, const sync::Instruction& instr,
                                     ChangesetIndex::GlobalID* ids, size_t max_num_ids)
{
    REALM_ASSERT_RELEASE(max_num_ids >= 2);

    using Instruction = realm::sync::Instruction;

    if (auto obj_instr = instr.get_if<Instruction::ObjectInstruction>()) {
        ids[0] = {changeset.get_string(obj_instr->table), changeset.get_key(obj_instr->object)};

        if (auto set_instr = instr.get_if<Instruction::Update>()) {
            auto& p = *set_instr;
            if (p.value.type == Instruction::Payload::Type::Link) {
                ids[1] = {changeset.get_string(p.value.data.link.target_table),
                          changeset.get_key(p.value.data.link.target)};
                return 2;
            }
        }
        else if (auto insert_instr = instr.get_if<Instruction::ArrayInsert>()) {
            auto& p = *insert_instr;
            if (p.value.type == Instruction::Payload::Type::Link) {
                ids[1] = {changeset.get_string(p.value.data.link.target_table),
                          changeset.get_key(p.value.data.link.target)};
                return 2;
            }
        }

        return 1;
    }

    return 0;
}

auto ChangesetIndex::get_schema_changes_for_class(StringData class_name) const -> const Ranges*
{
    return const_cast<ChangesetIndex*>(this)->get_schema_changes_for_class(class_name);
}

auto ChangesetIndex::get_schema_changes_for_class(StringData class_name) -> Ranges*
{
    if (m_contains_destructive_schema_changes)
        return &m_everything;
    auto it = m_schema_instructions.find(class_name);
    if (it == m_schema_instructions.end())
        return &m_empty;
    return &it->second->ranges;
}

auto ChangesetIndex::get_modifications_for_object(GlobalID id) -> Ranges*
{
    if (m_contains_destructive_schema_changes)
        return &m_everything;
    auto it = m_object_instructions.find(id.table_name);
    if (it == m_object_instructions.end())
        return &m_empty;

    auto& object_instructions = it->second;
    auto it2 = object_instructions.find(id.object_id);
    if (it2 == object_instructions.end())
        return &m_empty;
    return &it2->second->ranges;
}

auto ChangesetIndex::get_modifications_for_object(GlobalID id) const -> const Ranges*
{
    return const_cast<ChangesetIndex*>(this)->get_modifications_for_object(id);
}

auto ChangesetIndex::schema_conflict_group(StringData class_name) -> ConflictGroup&
{
    auto& conflict_group = m_schema_instructions[class_name];
    if (conflict_group == nullptr) {
        m_conflict_groups_owner.emplace_back();
        ++m_num_conflict_groups;
        auto new_cg = std::prev(m_conflict_groups_owner.end());
        new_cg->schemas.push_back(class_name);
        new_cg->size = 1;
        new_cg->self_it = new_cg;
        conflict_group = &*new_cg;
    }
    return *conflict_group;
}

auto ChangesetIndex::object_conflict_group(const GlobalID& object_id) -> ConflictGroup&
{
    auto& objects_for_table = m_object_instructions[object_id.table_name];
    auto& conflict_group = objects_for_table[object_id.object_id];
    if (conflict_group == nullptr) {
        m_conflict_groups_owner.emplace_back();
        ++m_num_conflict_groups;
        auto new_cg = std::prev(m_conflict_groups_owner.end());
        new_cg->objects[object_id.table_name].push_back(object_id.object_id);
        new_cg->size = 1;
        new_cg->self_it = new_cg;
        conflict_group = &*new_cg;
    }
    return *conflict_group;
}

auto ChangesetIndex::erase_instruction(RangeIterator pos) -> RangeIterator
{
    Changeset* changeset = pos.m_outer->first;
    pos.check();
    auto new_pos = pos;
    new_pos.m_pos = changeset->erase_stable(pos.m_pos);

    if (new_pos.m_pos >= new_pos.m_inner->end) {
        // erased the last instruction in the range, move to the next range.
        REALM_ASSERT(new_pos.m_inner < new_pos.m_outer->second.end());
        ++new_pos.m_inner;
        if (new_pos.m_inner == new_pos.m_outer->second.end()) {
            REALM_ASSERT(new_pos.m_outer != new_pos.m_ranges->end());
            ++new_pos.m_outer;
            if (new_pos.m_outer == new_pos.m_ranges->end()) {
                return RangeIterator{new_pos.m_ranges, RangeIterator::end_tag{}}; // avoid new_pos.check()
            }
            else {
                new_pos.m_inner = new_pos.m_outer->second.begin();
                REALM_ASSERT(new_pos.m_inner != new_pos.m_outer->second.end());
                new_pos.m_pos = new_pos.m_inner->begin;
            }
        }
        else {
            new_pos.m_pos = new_pos.m_inner->begin;
            REALM_ASSERT(new_pos.m_pos != new_pos.m_inner->end); // empty ranges not allowed
        }
    }
    new_pos.check();
    return new_pos;
}

#if REALM_DEBUG
static std::ostream& operator<<(std::ostream& os, GlobalID gid)
{
    return os << gid.table_name << "/" << format_pk(gid.object_id);
}

void ChangesetIndex::print(std::ostream& os) const
{
    auto print_ranges = [&](auto& subjects, const Ranges& ranges) {
        std::sort(subjects.begin(), subjects.end());
        subjects.erase(std::unique(subjects.begin(), subjects.end()), subjects.end());

        os << "[";
        for (auto it = subjects.begin(); it != subjects.end();) {
            os << *it;
            auto next = it;
            ++next;
            if (next != subjects.end())
                os << ", ";
            it = next;
        }
        os << "]: ";
        for (auto it = ranges.begin(); it != ranges.end();) {
            os << "Changeset" << std::dec << it->first->version << "(";
            for (auto it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
                auto offset = std::distance(it->first->begin(), it2->begin);
                auto length = std::distance(it2->begin, it2->end);
                os << "[" << std::dec << offset << "+" << length << "]";
                if (it2 + 1 != it->second.end())
                    os << ", ";
            }
            os << ")";
            auto next = it;
            ++next;
            if (next != ranges.end())
                os << ", ";
            it = next;
        }
    };

    std::map<Ranges*, std::vector<StringData>> schema_modifications;
    std::map<Ranges*, std::vector<GlobalID>> object_modifications;

    for (auto& pair : m_schema_instructions) {
        schema_modifications[&pair.second->ranges].push_back(pair.first);
    }

    for (auto& pair : m_object_instructions) {
        for (auto& pair2 : pair.second) {
            object_modifications[&pair2.second->ranges].push_back(GlobalID{pair.first, pair2.first});
        }
    }

    if (schema_modifications.size()) {
        os << "SCHEMA MODIFICATIONS:\n";
        for (auto& pair : schema_modifications) {
            print_ranges(pair.second, *pair.first);
            os << "\n";
        }
        os << "\n";
    }

    if (object_modifications.size()) {
        os << "OBJECT MODIFICATIONS:\n";
        for (auto& pair : object_modifications) {
            print_ranges(pair.second, *pair.first);
            os << "\n";
        }
        os << "\n";
    }
}

void ChangesetIndex::verify() const
{
    REALM_ASSERT(m_num_conflict_groups == m_conflict_groups_owner.size());

    // Verify that there are no stray pointers.
    for (auto& pair : m_object_instructions) {
        for (auto& pair2 : pair.second) {
            REALM_ASSERT(&*pair2.second->self_it == pair2.second);
            REALM_ASSERT(std::any_of(m_conflict_groups_owner.begin(), m_conflict_groups_owner.end(), [&](auto& cg) {
                return &cg == pair2.second;
            }));
        }
    }

    for (auto& pair : m_schema_instructions) {
        REALM_ASSERT(&*pair.second->self_it == pair.second);
        REALM_ASSERT(std::any_of(m_conflict_groups_owner.begin(), m_conflict_groups_owner.end(), [&](auto& cg) {
            return &cg == pair.second;
        }));
    }

    // Collect all changesets
    std::vector<Changeset*> changesets;
    for (auto& cg : m_conflict_groups_owner) {
        check_ranges(cg.ranges);

        for (auto& ranges : cg.ranges) {
            changesets.push_back(ranges.first);
        }
    }
    std::sort(changesets.begin(), changesets.end(), std::less<>());
    changesets.erase(std::unique(changesets.begin(), changesets.end()), changesets.end());

    // Run through all instructions in each changeset and check that
    // instructions are correctly covered by the index.
    for (auto changeset : changesets) {
        auto& log = *changeset;

        using Instruction = realm::sync::Instruction;

        // Iterate over all instructions (skipping tombstones), and verify that
        // the index covers any objects mentioned in that instruction.
        for (auto it = log.begin(); it != log.end(); ++it) {
            if (!*it)
                continue;

            const auto& instr = **it;

            if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {
                StringData table = log.get_string(add_table_instr->table);
                auto ranges = *get_schema_changes_for_class(table);
                REALM_ASSERT(ranges_cover(ranges, log, it));
            }
            else if (auto erase_table_instr = instr.get_if<Instruction::EraseTable>()) {
                StringData table = log.get_string(erase_table_instr->table);
                auto ranges = *get_schema_changes_for_class(table);
                REALM_ASSERT(ranges_cover(ranges, log, it));
            }
            else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {
                StringData table = log.get_string(add_column_instr->table);
                auto ranges = *get_schema_changes_for_class(table);
                REALM_ASSERT(ranges_cover(ranges, log, it));
            }
            else if (auto erase_column_instr = instr.get_if<Instruction::EraseColumn>()) {
                StringData table = log.get_string(erase_column_instr->table);
                auto ranges = *get_schema_changes_for_class(table);
                REALM_ASSERT(ranges_cover(ranges, log, it));
            }
            else {
                GlobalID ids[2];
                size_t num_ids = get_object_ids_in_instruction(log, instr, ids, 2);
                REALM_ASSERT(num_ids >= 1);
                REALM_ASSERT(num_ids <= 2);
                auto& ranges_first = *get_modifications_for_object(ids[0]);

                for (size_t i = 0; i < num_ids; ++i) {
                    auto& ranges = *get_modifications_for_object(ids[i]);
                    REALM_ASSERT(&ranges == &ranges_first);
                    REALM_ASSERT(ranges_cover(ranges, log, it));
                }
            }
        }
    }
}

bool ChangesetIndex::ranges_cover(const Ranges& ranges, Changeset& log, Changeset::const_iterator it) const
{
    auto outer = ranges.find(&log);
    if (outer == ranges.end())
        return false;
    for (auto& range : outer->second) {
        if (it >= range.begin && it < range.end)
            return true;
    }
    return false;
}

#endif // REALM_DEBUG

void ChangesetIndex::add_instruction_at(Ranges& ranges, Changeset& changeset, Changeset::iterator pos)
{
    auto& ranges_for_changeset = ranges[&changeset];

    REALM_ASSERT(pos != changeset.end());
    auto next = pos;
    ++next;

    Changeset::Range incoming{pos, next};

    auto cmp = [](const Changeset::Range& range_a, const Changeset::Range& range_b) {
        return range_a.begin < range_b.begin;
    };

    auto it = std::lower_bound(ranges_for_changeset.begin(), ranges_for_changeset.end(), incoming, cmp);

    it = ranges_for_changeset.insert(it, incoming);
    if (it != ranges_for_changeset.begin())
        --it;

    // Merge adjacent overlapping ranges
    while (it + 1 != ranges_for_changeset.end()) {
        auto next_it = it + 1;
        if (it->end >= next_it->begin) {
            it->end = std::max(it->end, next_it->end);
            next_it = ranges_for_changeset.erase(next_it);
            it = next_it - 1;
        }
        else {
            ++it;
        }
    }
}


} // namespace _impl
} // namespace realm

1	#include <realm/sync/noinst/changeset_index.hpp>
2	#include <realm/sync/object_id.hpp>
3
4	#include <iterator> // std::distance, std::advance
5
6	using namespace realm::sync;
7
8	namespace realm {
9	namespace _impl {
10
11	#if REALM_DEBUG
12	static bool compare_ranges(const Changeset::Range& left, const Changeset::Range& right)
13	{	3,444✔
14	return left.begin < right.begin;	3,444✔
15	}	3,444✔
16
17	template <class InputIterator>
18	static bool check_ranges(InputIterator begin, InputIterator end)
19	{	80,932✔
20	if (!std::is_sorted(begin, end, compare_ranges))	80,932✔
21	return false;	×
22
23	// Check that there are no overlaps
24	if (begin != end) {	80,934✔
25	auto last_end = begin->end;	80,928✔
26	for (auto i = begin + 1; i != end; ++i) {	84,372✔
27	if (last_end > i->begin)	3,444✔
28	return false;	×
29	last_end = i->end;	3,444✔
30	}	3,444✔
31	}	80,928✔
32	return true;	80,932✔
33	}	80,932✔
34
35	static bool check_ranges(const ChangesetIndex::Ranges& ranges)
36	{	336,970✔
37	for (auto& pair : ranges) {	336,970✔
38	if (!check_ranges(pair.second.begin(), pair.second.end()))	80,934✔
39	return false;	×
40	}	80,934✔
41	return true;	336,970✔
42	}	336,970✔
43	#endif // REALM_DEBUG
44
45
46	void ChangesetIndex::clear() noexcept
47	{	4,804✔
48	m_object_instructions.clear();	4,804✔
49	m_schema_instructions.clear();	4,804✔
50	m_conflict_groups_owner.clear();	4,804✔
51	m_num_conflict_groups = 0;	4,804✔
52	}	4,804✔
53
54
55	void ChangesetIndex::scan_changeset(Changeset& changeset)
56	{	717,788✔
57	if (m_contains_destructive_schema_changes)	717,788✔
58	return;	74,850✔
59
60	#if defined(REALM_DEBUG) // LCOV_EXCL_START	642,938✔
61	for (auto& confict_group : m_conflict_groups_owner) {	7,846,662✔
62	// Check that add_changeset() has not been called yet.
63	REALM_ASSERT(confict_group.ranges.empty());	7,846,662✔
64	}	7,846,662✔
65	#endif // REALM_DEBUG LCOV_EXCL_STOP	642,938✔
66
67	using Instruction = realm::sync::Instruction;	642,938✔
68
69	for (auto it = changeset.begin(); it != changeset.end(); ++it) {	1,385,008✔
70	if (!*it)	746,874✔
71	continue;	4,864✔
72
73	const auto& instr = **it;	742,010✔
74
75	if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {	742,010✔
76	auto& p = *add_table_instr;	16,396✔
77	schema_conflict_group(changeset.get_string(p.table));	16,396✔
78	}	16,396✔
79	else if (instr.get_if<Instruction::EraseTable>()) {	725,614✔
80	m_contains_destructive_schema_changes = true;	4,804✔
81	clear();	4,804✔
82	return;	4,804✔
83	}	4,804✔
84	else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {	720,810✔
85	auto& p = *add_column_instr;	40,084✔
86	StringData table_name = changeset.get_string(p.table);	40,084✔
87	ConflictGroup& cg = schema_conflict_group(table_name);	40,084✔
88	if (p.type == Instruction::Payload::Type::Link) {	40,084✔
89	StringData target_table = changeset.get_string(p.link_target_table);	4,564✔
90	ConflictGroup& cg2 = schema_conflict_group(target_table);	4,564✔
91	merge_conflict_groups(cg, cg2);	4,564✔
92	}	4,564✔
93	}	40,084✔
94	else if (instr.get_if<Instruction::EraseColumn>()) {	680,726✔
95	m_contains_destructive_schema_changes = true;	×
96	clear();	×
97	return;	×
98	}	×
99	else {	680,726✔
100	GlobalID ids[2];	680,726✔
101	size_t num_ids = get_object_ids_in_instruction(changeset, instr, ids, 2);	680,726✔
102	REALM_ASSERT(num_ids >= 1);	680,726✔
103	REALM_ASSERT(num_ids <= 2);	680,726✔
104
105	ConflictGroup& cg = object_conflict_group(ids[0]);	680,726✔
106	for (size_t i = 1; i < num_ids; ++i) {	681,082✔
107	ConflictGroup& cg2 = object_conflict_group(ids[1]);	356✔
108	merge_conflict_groups(cg, cg2);	356✔
109	}	356✔
110	}	680,726✔
111	}	742,010✔
112	}	642,938✔
113
114
115	void ChangesetIndex::merge_conflict_groups(ConflictGroup& into, ConflictGroup& from)
116	{	4,936✔
117	if (&into == &from)	4,936✔
118	return;	3,252✔
119
120	if (from.size > into.size) {	1,684✔
121	// This is an optimization. The time it takes to merge two conflict
122	// groups is proportional to the size of the incoming group (in number
123	// of objects touched). If the incoming group is larger, merge the other
124	// way.
125	merge_conflict_groups(from, into);	16✔
126	return;	16✔
127	}	16✔
128
129	REALM_ASSERT(into.ranges.empty());	1,668✔
130	REALM_ASSERT(from.ranges.empty());	1,668✔
131
132	for (auto& class_name : from.schemas) {	1,668✔
133	m_schema_instructions[class_name] = &into;	1,344✔
134	}	1,344✔
135	into.schemas.insert(into.schemas.end(), from.schemas.begin(), from.schemas.end());	1,668✔
136
137	for (auto& pair : from.objects) {	1,668✔
138	auto& objset = into.objects[pair.first];	324✔
139	auto& objinstr = m_object_instructions[pair.first];	324✔
140	for (auto& object : pair.second) {	324✔
141	objinstr[object] = &into;	324✔
142	}	324✔
143	objset.insert(objset.end(), pair.second.begin(), pair.second.end());	324✔
144	}	324✔
145	into.size += from.size;	1,668✔
146
147	m_conflict_groups_owner.erase(from.self_it);	1,668✔
148	--m_num_conflict_groups;	1,668✔
149	}	1,668✔
150
151
152	void ChangesetIndex::add_changeset(Changeset& log)
153	{	73,092✔
154	if (!log.empty())	73,092✔
155	m_everything[&log] = std::vector<Changeset::Range>(1, Changeset::Range{log.begin(), log.end()});	67,474✔
156
157	if (m_contains_destructive_schema_changes)	73,092✔
158	return; // Just add to everything.	4,804✔
159
160	using Instruction = realm::sync::Instruction;	68,288✔
161
162	// Iterate over all instructions (skipping tombstones), and add them to the
163	// index.
164	for (auto it = log.begin(); it != log.end(); ++it) {	197,072✔
165	if (!*it)	128,784✔
166	continue;	×
167
168	const auto& instr = **it;	128,784✔
169
170	if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {	128,784✔
171	StringData table = log.get_string(add_table_instr->table);	4,560✔
172	auto& cg = schema_conflict_group(table);	4,560✔
173	add_instruction_at(cg.ranges, log, it);	4,560✔
174	}	4,560✔
175	else if (instr.get_if<Instruction::EraseTable>()) {	124,224✔
176	REALM_TERMINATE("Call scan_changeset() before add_changeset().");
177	}	×
178	else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {	124,224✔
179	auto& p = *add_column_instr;	11,152✔
180	StringData table = log.get_string(p.table);	11,152✔
181	auto& cg = schema_conflict_group(table);	11,152✔
182	if (p.type == Instruction::Payload::Type::Link) {	11,152✔
183	REALM_ASSERT(&cg == &schema_conflict_group(log.get_string(p.link_target_table)));	2,282✔
184	}	2,282✔
185	add_instruction_at(cg.ranges, log, it);	11,152✔
186	}	11,152✔
187	else if (instr.get_if<Instruction::EraseColumn>()) {	113,072✔
188	REALM_TERMINATE("Call scan_changeset() before add_changeset().");
189	}	×
190	else {	113,072✔
191	GlobalID ids[2];	113,072✔
192	size_t num_ids = get_object_ids_in_instruction(log, instr, ids, 2);	113,072✔
193	REALM_ASSERT(num_ids >= 1);	113,072✔
194	REALM_ASSERT(num_ids <= 2);	113,072✔
195
196	auto& cg = object_conflict_group(ids[0]);	113,072✔
197	for (size_t i = 1; i < num_ids; ++i) {	113,280✔
198	REALM_ASSERT(&cg == &object_conflict_group(ids[i]));	208✔
199	}	208✔
200	add_instruction_at(cg.ranges, log, it);	113,072✔
201	}	113,072✔
202	}	128,784✔
203	}	68,288✔
204
205	size_t get_object_ids_in_instruction(const Changeset& changeset, const sync::Instruction& instr,
206	ChangesetIndex::GlobalID* ids, size_t max_num_ids)
207	{	1,528,070✔
208	REALM_ASSERT_RELEASE(max_num_ids >= 2);	1,528,070✔
209
210	using Instruction = realm::sync::Instruction;	1,528,070✔
211
212	if (auto obj_instr = instr.get_if<Instruction::ObjectInstruction>()) {	1,528,070✔
213	ids[0] = {changeset.get_string(obj_instr->table), changeset.get_key(obj_instr->object)};	1,527,406✔
214
215	if (auto set_instr = instr.get_if<Instruction::Update>()) {	1,527,406✔
216	auto& p = *set_instr;	828,670✔
217	if (p.value.type == Instruction::Payload::Type::Link) {	828,670✔
218	ids[1] = {changeset.get_string(p.value.data.link.target_table),	268✔
219	changeset.get_key(p.value.data.link.target)};	268✔
220	return 2;	268✔
221	}	268✔
222	}	828,670✔
223	else if (auto insert_instr = instr.get_if<Instruction::ArrayInsert>()) {	698,736✔
224	auto& p = *insert_instr;	85,548✔
225	if (p.value.type == Instruction::Payload::Type::Link) {	85,548✔
226	ids[1] = {changeset.get_string(p.value.data.link.target_table),	636✔
227	changeset.get_key(p.value.data.link.target)};	636✔
228	return 2;	636✔
229	}	636✔
230	}	85,548✔
231
232	return 1;	1,526,502✔
233	}	1,527,406✔
234
235	return 0;	664✔
236	}	1,528,070✔
237
238	auto ChangesetIndex::get_schema_changes_for_class(StringData class_name) const -> const Ranges*
239	{	1,020✔
240	return const_cast<ChangesetIndex*>(this)->get_schema_changes_for_class(class_name);	1,020✔
241	}	1,020✔
242
243	auto ChangesetIndex::get_schema_changes_for_class(StringData class_name) -> Ranges*
244	{	1,020✔
245	if (m_contains_destructive_schema_changes)	1,020✔
246	return &m_everything;	×
247	auto it = m_schema_instructions.find(class_name);	1,020✔
248	if (it == m_schema_instructions.end())	1,020✔
249	return &m_empty;	×
250	return &it->second->ranges;	1,020✔
251	}	1,020✔
252
253	auto ChangesetIndex::get_modifications_for_object(GlobalID id) -> Ranges*
254	{	841,916✔
255	if (m_contains_destructive_schema_changes)	841,916✔
256	return &m_everything;	131,664✔
257	auto it = m_object_instructions.find(id.table_name);	710,252✔
258	if (it == m_object_instructions.end())	710,252✔
259	return &m_empty;	×
260
261	auto& object_instructions = it->second;	710,252✔
262	auto it2 = object_instructions.find(id.object_id);	710,252✔
263	if (it2 == object_instructions.end())	710,252✔
264	return &m_empty;	×
265	return &it2->second->ranges;	710,252✔
266	}	710,252✔
267
268	auto ChangesetIndex::get_modifications_for_object(GlobalID id) const -> const Ranges*
269	{	214,278✔
270	return const_cast<ChangesetIndex*>(this)->get_modifications_for_object(id);	214,278✔
271	}	214,278✔
272
273	auto ChangesetIndex::schema_conflict_group(StringData class_name) -> ConflictGroup&
274	{	79,038✔
275	auto& conflict_group = m_schema_instructions[class_name];	79,038✔
276	if (conflict_group == nullptr) {	79,038✔
277	m_conflict_groups_owner.emplace_back();	26,140✔
278	++m_num_conflict_groups;	26,140✔
279	auto new_cg = std::prev(m_conflict_groups_owner.end());	26,140✔
280	new_cg->schemas.push_back(class_name);	26,140✔
281	new_cg->size = 1;	26,140✔
282	new_cg->self_it = new_cg;	26,140✔
283	conflict_group = &*new_cg;	26,140✔
284	}	26,140✔
285	return *conflict_group;	79,038✔
286	}	79,038✔
287
288	auto ChangesetIndex::object_conflict_group(const GlobalID& object_id) -> ConflictGroup&
289	{	794,152✔
290	auto& objects_for_table = m_object_instructions[object_id.table_name];	794,152✔
291	auto& conflict_group = objects_for_table[object_id.object_id];	794,152✔
292	if (conflict_group == nullptr) {	794,152✔
293	m_conflict_groups_owner.emplace_back();	366,720✔
294	++m_num_conflict_groups;	366,720✔
295	auto new_cg = std::prev(m_conflict_groups_owner.end());	366,720✔
296	new_cg->objects[object_id.table_name].push_back(object_id.object_id);	366,720✔
297	new_cg->size = 1;	366,720✔
298	new_cg->self_it = new_cg;	366,720✔
299	conflict_group = &*new_cg;	366,720✔
300	}	366,720✔
301	return *conflict_group;	794,152✔
302	}	794,152✔
303
304	auto ChangesetIndex::erase_instruction(RangeIterator pos) -> RangeIterator
305	{	21,870✔
306	Changeset* changeset = pos.m_outer->first;	21,870✔
307	pos.check();	21,870✔
308	auto new_pos = pos;	21,870✔
309	new_pos.m_pos = changeset->erase_stable(pos.m_pos);	21,870✔
310
311	if (new_pos.m_pos >= new_pos.m_inner->end) {	21,870✔
312	// erased the last instruction in the range, move to the next range.
313	REALM_ASSERT(new_pos.m_inner < new_pos.m_outer->second.end());	10,290✔
314	++new_pos.m_inner;	10,290✔
315	if (new_pos.m_inner == new_pos.m_outer->second.end()) {	10,290✔
316	REALM_ASSERT(new_pos.m_outer != new_pos.m_ranges->end());	10,282✔
317	++new_pos.m_outer;	10,282✔
318	if (new_pos.m_outer == new_pos.m_ranges->end()) {	10,282✔
319	return RangeIterator{new_pos.m_ranges, RangeIterator::end_tag{}}; // avoid new_pos.check()	9,004✔
320	}	9,004✔
321	else {	1,278✔
322	new_pos.m_inner = new_pos.m_outer->second.begin();	1,278✔
323	REALM_ASSERT(new_pos.m_inner != new_pos.m_outer->second.end());	1,278✔
324	new_pos.m_pos = new_pos.m_inner->begin;	1,278✔
325	}	1,278✔
326	}	10,282✔
327	else {	8✔
328	new_pos.m_pos = new_pos.m_inner->begin;	8✔
329	REALM_ASSERT(new_pos.m_pos != new_pos.m_inner->end); // empty ranges not allowed	8✔
330	}	8✔
331	}	10,290✔
332	new_pos.check();	12,866✔
333	return new_pos;	12,866✔
334	}	21,870✔
335
336	#if REALM_DEBUG
337	static std::ostream& operator<<(std::ostream& os, GlobalID gid)
338	{	×
339	return os << gid.table_name << "/" << format_pk(gid.object_id);	×
340	}	×
341
342	void ChangesetIndex::print(std::ostream& os) const
343	{	×
344	auto print_ranges = [&](auto& subjects, const Ranges& ranges) {	×
345	std::sort(subjects.begin(), subjects.end());	×
346	subjects.erase(std::unique(subjects.begin(), subjects.end()), subjects.end());	×
347
348	os << "[";	×
349	for (auto it = subjects.begin(); it != subjects.end();) {	×
350	os << *it;	×
351	auto next = it;	×
352	++next;	×
353	if (next != subjects.end())	×
354	os << ", ";	×
355	it = next;	×
356	}	×
357	os << "]: ";	×
358	for (auto it = ranges.begin(); it != ranges.end();) {	×
359	os << "Changeset" << std::dec << it->first->version << "(";	×
360	for (auto it2 = it->second.begin(); it2 != it->second.end(); ++it2) {	×
361	auto offset = std::distance(it->first->begin(), it2->begin);	×
362	auto length = std::distance(it2->begin, it2->end);	×
363	os << "[" << std::dec << offset << "+" << length << "]";	×
364	if (it2 + 1 != it->second.end())	×
365	os << ", ";	×
366	}	×
367	os << ")";	×
368	auto next = it;	×
369	++next;	×
370	if (next != ranges.end())	×
371	os << ", ";	×
372	it = next;	×
373	}	×
374	};	×
375
376	std::map<Ranges*, std::vector<StringData>> schema_modifications;	×
377	std::map<Ranges*, std::vector<GlobalID>> object_modifications;	×
378
379	for (auto& pair : m_schema_instructions) {	×
380	schema_modifications[&pair.second->ranges].push_back(pair.first);	×
381	}	×
382
383	for (auto& pair : m_object_instructions) {	×
384	for (auto& pair2 : pair.second) {	×
385	object_modifications[&pair2.second->ranges].push_back(GlobalID{pair.first, pair2.first});	×
386	}	×
387	}	×
388
389	if (schema_modifications.size()) {	×
390	os << "SCHEMA MODIFICATIONS:\n";	×
391	for (auto& pair : schema_modifications) {	×
392	print_ranges(pair.second, *pair.first);	×
393	os << "\n";	×
394	}	×
395	os << "\n";	×
396	}	×
397
398	if (object_modifications.size()) {	×
399	os << "OBJECT MODIFICATIONS:\n";	×
400	for (auto& pair : object_modifications) {	×
401	print_ranges(pair.second, *pair.first);	×
402	os << "\n";	×
403	}	×
404	os << "\n";	×
405	}	×
406	}	×
407
408	void ChangesetIndex::verify() const
409	{	50,892✔
410	REALM_ASSERT(m_num_conflict_groups == m_conflict_groups_owner.size());	50,892✔
411
412	// Verify that there are no stray pointers.
413	for (auto& pair : m_object_instructions) {	94,054✔
414	for (auto& pair2 : pair.second) {	318,024✔
415	REALM_ASSERT(&*pair2.second->self_it == pair2.second);	318,024✔
416	REALM_ASSERT(std::any_of(m_conflict_groups_owner.begin(), m_conflict_groups_owner.end(), [&](auto& cg) {	318,024✔
417	return &cg == pair2.second;	318,024✔
418	}));	318,024✔
419	}	318,024✔
420	}	94,054✔
421
422	for (auto& pair : m_schema_instructions) {	50,892✔
423	REALM_ASSERT(&*pair.second->self_it == pair.second);	20,588✔
424	REALM_ASSERT(std::any_of(m_conflict_groups_owner.begin(), m_conflict_groups_owner.end(), [&](auto& cg) {	20,588✔
425	return &cg == pair.second;	20,588✔
426	}));	20,588✔
427	}	20,588✔
428
429	// Collect all changesets
430	std::vector<Changeset*> changesets;	50,892✔
431	for (auto& cg : m_conflict_groups_owner) {	336,978✔
432	check_ranges(cg.ranges);	336,978✔
433
434	for (auto& ranges : cg.ranges) {	336,978✔
435	changesets.push_back(ranges.first);	80,934✔
436	}	80,934✔
437	}	336,978✔
438	std::sort(changesets.begin(), changesets.end(), std::less<>());	50,892✔
439	changesets.erase(std::unique(changesets.begin(), changesets.end()), changesets.end());	50,892✔
440
441	// Run through all instructions in each changeset and check that
442	// instructions are correctly covered by the index.
443	for (auto changeset : changesets) {	64,046✔
444	auto& log = *changeset;	64,046✔
445
446	using Instruction = realm::sync::Instruction;	64,046✔
447
448	// Iterate over all instructions (skipping tombstones), and verify that
449	// the index covers any objects mentioned in that instruction.
450	for (auto it = log.begin(); it != log.end(); ++it) {	192,700✔
451	if (!*it)	128,654✔
452	continue;	20,582✔
453
454	const auto& instr = **it;	108,072✔
455
456	if (auto add_table_instr = instr.get_if<Instruction::AddTable>()) {	108,072✔
457	StringData table = log.get_string(add_table_instr->table);	372✔
458	auto ranges = *get_schema_changes_for_class(table);	372✔
459	REALM_ASSERT(ranges_cover(ranges, log, it));	372✔
460	}	372✔
461	else if (auto erase_table_instr = instr.get_if<Instruction::EraseTable>()) {	107,700✔
462	StringData table = log.get_string(erase_table_instr->table);	×
463	auto ranges = *get_schema_changes_for_class(table);	×
464	REALM_ASSERT(ranges_cover(ranges, log, it));	×
465	}	×
466	else if (auto add_column_instr = instr.get_if<Instruction::AddColumn>()) {	107,700✔
467	StringData table = log.get_string(add_column_instr->table);	648✔
468	auto ranges = *get_schema_changes_for_class(table);	648✔
469	REALM_ASSERT(ranges_cover(ranges, log, it));	648✔
470	}	648✔
471	else if (auto erase_column_instr = instr.get_if<Instruction::EraseColumn>()) {	107,052✔
472	StringData table = log.get_string(erase_column_instr->table);	×
473	auto ranges = *get_schema_changes_for_class(table);	×
474	REALM_ASSERT(ranges_cover(ranges, log, it));	×
475	}	×
476	else {	107,052✔
477	GlobalID ids[2];	107,052✔
478	size_t num_ids = get_object_ids_in_instruction(log, instr, ids, 2);	107,052✔
479	REALM_ASSERT(num_ids >= 1);	107,052✔
480	REALM_ASSERT(num_ids <= 2);	107,052✔
481	auto& ranges_first = *get_modifications_for_object(ids[0]);	107,052✔
482
483	for (size_t i = 0; i < num_ids; ++i) {	214,292✔
484	auto& ranges = *get_modifications_for_object(ids[i]);	107,240✔
485	REALM_ASSERT(&ranges == &ranges_first);	107,240✔
486	REALM_ASSERT(ranges_cover(ranges, log, it));	107,240✔
487	}	107,240✔
488	}	107,052✔
489	}	108,072✔
490	}	64,046✔
491	}	50,892✔
492
493	bool ChangesetIndex::ranges_cover(const Ranges& ranges, Changeset& log, Changeset::const_iterator it) const
494	{	108,262✔
495	auto outer = ranges.find(&log);	108,262✔
496	if (outer == ranges.end())	108,262✔
497	return false;	×
498	for (auto& range : outer->second) {	111,684✔
499	if (it >= range.begin && it < range.end)	111,684✔
500	return true;	108,262✔
501	}	111,684✔
UNCOV 502	return false;	×
503	}	108,262✔
504
505	#endif // REALM_DEBUG
506
507	void ChangesetIndex::add_instruction_at(Ranges& ranges, Changeset& changeset, Changeset::iterator pos)
508	{	128,796✔
509	auto& ranges_for_changeset = ranges[&changeset];	128,796✔
510
511	REALM_ASSERT(pos != changeset.end());	128,796✔
512	auto next = pos;	128,796✔
513	++next;	128,796✔
514
515	Changeset::Range incoming{pos, next};	128,796✔
516
517	auto cmp = [](const Changeset::Range& range_a, const Changeset::Range& range_b) {	128,796✔
518	return range_a.begin < range_b.begin;	48,578✔
519	};	48,578✔
520
521	auto it = std::lower_bound(ranges_for_changeset.begin(), ranges_for_changeset.end(), incoming, cmp);	128,796✔
522
523	it = ranges_for_changeset.insert(it, incoming);	128,796✔
524	if (it != ranges_for_changeset.begin())	128,796✔
525	--it;	47,806✔
526
527	// Merge adjacent overlapping ranges
528	while (it + 1 != ranges_for_changeset.end()) {	176,602✔
529	auto next_it = it + 1;	47,806✔
530	if (it->end >= next_it->begin) {	47,806✔
531	it->end = std::max(it->end, next_it->end);	44,362✔
532	next_it = ranges_for_changeset.erase(next_it);	44,362✔
533	it = next_it - 1;	44,362✔
534	}	44,362✔
535	else {	3,444✔
536	++it;	3,444✔
537	}	3,444✔
538	}	47,806✔
539	}	128,796✔
540
541
542	} // namespace _impl
543	} // namespace realm

realm / realm-core / jorgen.edelbo_429

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous