2386

Committed 04 Jun 2024 11:40PM UTC coverage: 90.844% (-0.003%) from 90.847%

Build # 2386

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Merge pull request #7734 from realm/tg/create-object-repl

RCORE-2152 Don't emit transaction log instructions for mutations on newly-created objects

Run Details

101840 of 180236 branches covered (56.5%)

358 of 362 new or added lines in 6 files covered. (98.9%)

98 existing lines in 19 files now uncovered.

214786 of 236434 relevant lines covered (90.84%)

5684022.63 hits per line

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

80.89

/src/realm/replication.cpp

/*************************************************************************
 *
 * Copyright 2016 Realm Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************/

#include <realm/replication.hpp>

#include <realm/list.hpp>
#include <realm/path.hpp>
#include <iostream>

using namespace realm;
using namespace realm::util;
using LogLevel = util::Logger::Level;

const char* Replication::history_type_name(int type)
{
    switch (type) {
        case hist_None:
            return "None";
        case hist_OutOfRealm:
            return "Local out of Realm";
        case hist_InRealm:
            return "Local in-Realm";
        case hist_SyncClient:
            return "SyncClient";
        case hist_SyncServer:
            return "SyncServer";
        default:
            return "Unknown";
    }
}

void Replication::initialize(DB&)
{
    // Nothing needs to be done here
}

void Replication::do_initiate_transact(Group&, version_type, bool)
{
    char* data = m_stream.get_data();
    size_t size = m_stream.get_size();
    m_encoder.set_buffer(data, data + size);
    m_most_recently_created_object.clear();
}

Replication::version_type Replication::prepare_commit(version_type orig_version)
{
    char* data = m_stream.get_data();
    size_t size = m_encoder.write_position() - data;
    version_type new_version = prepare_changeset(data, size, orig_version); // Throws
    return new_version;
}

void Replication::add_class(TableKey table_key, StringData name, Table::Type type)
{
    if (auto logger = would_log(LogLevel::debug)) {
        if (type == Table::Type::Embedded) {
            logger->log(LogCategory::object, LogLevel::debug, "Add %1 class '%2'", type, name);
        }
        else {
            logger->log(LogCategory::object, LogLevel::debug, "Add class '%1'", name);
        }
    }
    unselect_all();
    m_encoder.insert_group_level_table(table_key); // Throws
}

void Replication::add_class_with_primary_key(TableKey tk, StringData name, DataType pk_type, StringData pk_name, bool,
                                             Table::Type table_type)
{
    if (auto logger = would_log(LogLevel::debug)) {
        logger->log(LogCategory::object, LogLevel::debug, "Add %1 class '%2' with primary key property '%3' of %4",
                    table_type, Group::table_name_to_class_name(name), pk_name, pk_type);
    }
    REALM_ASSERT(table_type != Table::Type::Embedded);
    unselect_all();
    m_encoder.insert_group_level_table(tk); // Throws
}

void Replication::erase_class(TableKey tk, StringData table_name, size_t)
{
    if (auto logger = would_log(LogLevel::debug)) {
        logger->log(LogCategory::object, LogLevel::debug, "Remove class '%1'",
                    Group::table_name_to_class_name(table_name));
    }
    unselect_all();
    m_encoder.erase_class(tk); // Throws
}

void Replication::insert_column(const Table* t, ColKey col_key, DataType type, StringData col_name,
                                Table* target_table)
{
    if (auto logger = would_log(LogLevel::debug)) {
        const char* collection_type = "";
        if (col_key.is_collection()) {
            if (col_key.is_list()) {
                collection_type = "list ";
            }
            else if (col_key.is_dictionary()) {
                collection_type = "dictionary ";
            }
            else {
                collection_type = "set ";
            }
        }
        if (target_table) {
            logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Add property '%2' %3linking '%4'",
                        t->get_class_name(), col_name, collection_type, target_table->get_class_name());
        }
        else {
            logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Add property '%2' %3of %4",
                        t->get_class_name(), col_name, collection_type, type);
        }
    }
    select_table(t);                  // Throws
    m_encoder.insert_column(col_key); // Throws
}

void Replication::erase_column(const Table* t, ColKey col_key)
{
    if (auto logger = would_log(LogLevel::debug)) {
        logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Remove property '%2'", t->get_class_name(),
                    t->get_column_name(col_key));
    }
    select_table(t);                 // Throws
    m_encoder.erase_column(col_key); // Throws
}

void Replication::track_new_object(ObjKey key)
{
    m_selected_obj = key;
    m_selected_collection = CollectionId();
    m_newly_created_object = true;

    auto table_index = m_selected_table->get_index_in_group();
    if (table_index >= m_most_recently_created_object.size()) {
        if (table_index >= m_most_recently_created_object.capacity())
            m_most_recently_created_object.reserve(table_index * 2);
        m_most_recently_created_object.resize(table_index + 1);
    }
    m_most_recently_created_object[table_index] = m_selected_obj;
}

void Replication::create_object(const Table* t, GlobalKey id)
{
    if (auto logger = would_log(LogLevel::debug)) {
        logger->log(LogCategory::object, LogLevel::debug, "Create object '%1'", t->get_class_name());
    }
    select_table(t);                              // Throws
    m_encoder.create_object(id.get_local_key(0)); // Throws
    track_new_object(id.get_local_key(0));        // Throws
}

void Replication::create_object_with_primary_key(const Table* t, ObjKey key, Mixed pk)
{
    if (auto logger = would_log(LogLevel::debug)) {
        logger->log(LogCategory::object, LogLevel::debug, "Create object '%1' with primary key %2",
                    t->get_class_name(), pk);
    }
    select_table(t);              // Throws
    m_encoder.create_object(key); // Throws
    track_new_object(key);
}

void Replication::create_linked_object(const Table* t, ObjKey key)
{
    select_table(t);       // Throws
    track_new_object(key); // Throws
    // Does not need to encode anything as embedded tables can't be observed
}

void Replication::remove_object(const Table* t, ObjKey key)
{
    if (auto logger = would_log(LogLevel::debug)) {
        if (t->is_embedded()) {
            logger->log(LogCategory::object, LogLevel::debug, "Remove embedded object '%1'", t->get_class_name());
        }
        else if (t->get_primary_key_column()) {
            logger->log(LogCategory::object, LogLevel::debug, "Remove object '%1' with primary key %2",
                        t->get_class_name(), t->get_primary_key(key));
        }
        else {
            logger->log(LogCategory::object, LogLevel::debug, "Remove object '%1'[%2]", t->get_class_name(), key);
        }
    }
    select_table(t);              // Throws
    m_encoder.remove_object(key); // Throws
}

void Replication::do_select_table(const Table* table)
{
    m_encoder.select_table(table->get_key()); // Throws
    m_selected_table = table;
    m_selected_collection = CollectionId();
    m_selected_obj = ObjKey();
}

void Replication::do_select_obj(ObjKey key)
{
    m_selected_obj = key;
    m_selected_collection = CollectionId();

    auto table_index = m_selected_table->get_index_in_group();
    if (table_index < m_most_recently_created_object.size()) {
        m_newly_created_object = m_most_recently_created_object[table_index] == key;
    }
    else {
        m_newly_created_object = false;
    }

    if (auto logger = would_log(LogLevel::debug)) {
        auto class_name = m_selected_table->get_class_name();
        if (m_selected_table->get_primary_key_column()) {
            auto pk = m_selected_table->get_primary_key(key);
            logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with primary key %2", class_name,
                        pk);
        }
        else if (m_selected_table->is_embedded()) {
            auto obj = m_selected_table->get_object(key);
            logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with path '%2'", class_name,
                        obj.get_id());
        }
        else {
            logger->log(LogCategory::object, LogLevel::debug, "Mutating anonymous object '%1'[%2]", class_name, key);
        }
    }
}

void Replication::do_select_collection(const CollectionBase& coll)
{
    select_table(coll.get_table().unchecked_ptr());
    ColKey col_key = coll.get_col_key();
    ObjKey key = coll.get_owner_key();
    auto path = coll.get_stable_path();

    if (select_obj(key)) {
        m_encoder.select_collection(col_key, key, path); // Throws
    }
    m_selected_collection = CollectionId(coll.get_table()->get_key(), key, std::move(path));
}

void Replication::do_set(const Table* t, ColKey col_key, ObjKey key, _impl::Instruction variant)
{
    if (variant != _impl::Instruction::instr_SetDefault) {
        select_table(t); // Throws
        if (select_obj(key)) {
            m_encoder.modify_object(col_key, key); // Throws
        }
    }
}

void Replication::set(const Table* t, ColKey col_key, ObjKey key, Mixed value, _impl::Instruction variant)
{
    do_set(t, col_key, key, variant); // Throws
    if (auto logger = would_log(LogLevel::trace)) {
        if (col_key.get_type() == col_type_Link && value.is_type(type_Link)) {
            auto target_table = t->get_opposite_table(col_key);
            if (target_table->is_embedded()) {
                logger->log(LogCategory::object, LogLevel::trace, "   Creating embedded object '%1' in '%2'",
                            target_table->get_class_name(), t->get_column_name(col_key));
            }
            else if (target_table->get_primary_key_column()) {
                auto link = value.get<ObjKey>();
                auto pk = target_table->get_primary_key(link);
                logger->log(LogCategory::object, LogLevel::trace,
                            "   Linking object '%1' with primary key %2 from '%3'", target_table->get_class_name(),
                            pk, t->get_column_name(col_key));
            }
            else {
                logger->log(LogCategory::object, LogLevel::trace, "   Linking object '%1'[%2] from '%3'",
                            target_table->get_class_name(), key, t->get_column_name(col_key));
            }
        }
        else {
            logger->log(LogCategory::object, LogLevel::trace, "   Set '%1' to %2", t->get_column_name(col_key),
                        value.to_string(util::Logger::max_width_of_value));
        }
    }
}

void Replication::nullify_link(const Table* t, ColKey col_key, ObjKey key)
{
    select_table(t); // Throws
    if (select_obj(key)) {
        m_encoder.modify_object(col_key, key); // Throws
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Nullify '%1'", t->get_column_name(col_key));
    }
}

void Replication::add_int(const Table* t, ColKey col_key, ObjKey key, int_fast64_t value)
{
    do_set(t, col_key, key); // Throws
    if (auto logger = get_logger()) {
        logger->log(LogCategory::object, LogLevel::trace, "   Adding %1 to '%2'", value, t->get_column_name(col_key));
    }
}

Path Replication::get_prop_name(Path&& path) const
{
    auto col_key = path[0].get_col_key();
    auto prop_name = m_selected_table->get_column_name(col_key);
    path[0] = PathElement(prop_name);
    return std::move(path);
}

void Replication::log_collection_operation(const char* operation, const CollectionBase& collection, Mixed value,
                                           Mixed index) const
{
    auto logger = would_log(LogLevel::trace);
    if (REALM_LIKELY(!logger))
        return;

    auto path = collection.get_short_path();
    auto col_key = path[0].get_col_key();
    auto prop_name = m_selected_table->get_column_name(col_key);
    path[0] = PathElement(prop_name);
    std::string position;
    if (!index.is_null()) {
        position = util::format(" at position %1", index);
    }
    if (Table::is_link_type(col_key.get_type()) && value.is_type(type_Link)) {
        auto target_table = m_selected_table->get_opposite_table(col_key);
        if (target_table->is_embedded()) {
            logger->log(LogCategory::object, LogLevel::trace, "   %1 embedded object '%2' in %3%4 ", operation,
                        target_table->get_class_name(), path, position);
        }
        else if (target_table->get_primary_key_column()) {
            auto link = value.get<ObjKey>();
            auto pk = target_table->get_primary_key(link);
            logger->log(LogCategory::object, LogLevel::trace, "   %1 object '%2' with primary key %3 in %4%5",
                        operation, target_table->get_class_name(), pk, path, position);
        }
        else {
            auto link = value.get<ObjKey>();
            logger->log(LogCategory::object, LogLevel::trace, "   %1 object '%2'[%3] in %4%5", operation,
                        target_table->get_class_name(), link, path, position);
        }
    }
    else {
        logger->log(LogCategory::object, LogLevel::trace, "   %1 %2 in %3%4", operation,
                    value.to_string(util::Logger::max_width_of_value), path, position);
    }
}

void Replication::list_insert(const CollectionBase& list, size_t list_ndx, Mixed value, size_t)
{
    if (select_collection(list)) {                                   // Throws
        m_encoder.collection_insert(list.translate_index(list_ndx)); // Throws
    }
    log_collection_operation("Insert", list, value, int64_t(list_ndx));
}

void Replication::list_set(const CollectionBase& list, size_t list_ndx, Mixed value)
{
    if (select_collection(list)) {                                // Throws
        m_encoder.collection_set(list.translate_index(list_ndx)); // Throws
    }
    log_collection_operation("Set", list, value, int64_t(list_ndx));
}

void Replication::list_erase(const CollectionBase& list, size_t link_ndx)
{
    if (select_collection(list)) {                                  // Throws
        m_encoder.collection_erase(list.translate_index(link_ndx)); // Throws
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Erase '%1' at position %2",
                    get_prop_name(list.get_short_path()), link_ndx);
    }
}

void Replication::list_move(const CollectionBase& list, size_t from_link_ndx, size_t to_link_ndx)
{
    if (select_collection(list)) {                                                                         // Throws
        m_encoder.collection_move(list.translate_index(from_link_ndx), list.translate_index(to_link_ndx)); // Throws
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Move %1 to %2 in '%3'", from_link_ndx, to_link_ndx,
                    get_prop_name(list.get_short_path()));
    }
}

void Replication::set_insert(const CollectionBase& set, size_t set_ndx, Mixed value)
{
    Replication::list_insert(set, set_ndx, value, 0); // Throws
}

void Replication::set_erase(const CollectionBase& set, size_t set_ndx, Mixed)
{
    Replication::list_erase(set, set_ndx); // Throws
}

void Replication::set_clear(const CollectionBase& set)
{
    Replication::list_clear(set); // Throws
}

void Replication::list_clear(const CollectionBase& list)
{
    if (select_collection(list)) {               // Throws
        m_encoder.collection_clear(list.size()); // Throws
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'", get_prop_name(list.get_short_path()));
    }
}

void Replication::link_list_nullify(const Lst<ObjKey>& list, size_t link_ndx)
{
    if (select_collection(list)) { // Throws
        m_encoder.collection_erase(link_ndx);
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Nullify '%1' position %2",
                    m_selected_table->get_column_name(list.get_col_key()), link_ndx);
    }
}

void Replication::dictionary_insert(const CollectionBase& dict, size_t ndx, Mixed key, Mixed value)
{
    if (select_collection(dict)) { // Throws
        m_encoder.collection_insert(ndx);
    }
    log_collection_operation("Insert", dict, value, key);
}

void Replication::dictionary_set(const CollectionBase& dict, size_t ndx, Mixed key, Mixed value)
{
    if (select_collection(dict)) { // Throws
        m_encoder.collection_set(ndx);
    }
    log_collection_operation("Set", dict, value, key);
}

void Replication::dictionary_erase(const CollectionBase& dict, size_t ndx, Mixed key)
{
    if (select_collection(dict)) { // Throws
        m_encoder.collection_erase(ndx);
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Erase %1 from '%2'", key,
                    get_prop_name(dict.get_short_path()));
    }
}

void Replication::dictionary_clear(const CollectionBase& dict)
{
    if (select_collection(dict)) { // Throws
        m_encoder.collection_clear(dict.size());
    }
    if (auto logger = would_log(LogLevel::trace)) {
        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'", get_prop_name(dict.get_short_path()));
    }
}

1	/*************************************************************************
2	*
3	* Copyright 2016 Realm Inc.
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	**************************************************************************/
18
19	#include <realm/replication.hpp>
20
21	#include <realm/list.hpp>
22	#include <realm/path.hpp>
23	#include <iostream>
24
25	using namespace realm;
26	using namespace realm::util;
27	using LogLevel = util::Logger::Level;
28
29	const char* Replication::history_type_name(int type)
30	{	18✔
31	switch (type) {	18✔
32	case hist_None:	✔
33	return "None";	×
34	case hist_OutOfRealm:	✔
35	return "Local out of Realm";	×
36	case hist_InRealm:	12✔
37	return "Local in-Realm";	12✔
38	case hist_SyncClient:	6✔
39	return "SyncClient";	6✔
40	case hist_SyncServer:	✔
41	return "SyncServer";	×
42	default:	✔
43	return "Unknown";	×
44	}	18✔
45	}	18✔
46
47	void Replication::initialize(DB&)
48	{	97,500✔
49	// Nothing needs to be done here
50	}	97,500✔
51
52	void Replication::do_initiate_transact(Group&, version_type, bool)
53	{	626,622✔
54	char* data = m_stream.get_data();	626,622✔
55	size_t size = m_stream.get_size();	626,622✔
56	m_encoder.set_buffer(data, data + size);	626,622✔
57	m_most_recently_created_object.clear();	626,622✔
58	}	626,622✔
59
60	Replication::version_type Replication::prepare_commit(version_type orig_version)
61	{	600,492✔
62	char* data = m_stream.get_data();	600,492✔
63	size_t size = m_encoder.write_position() - data;	600,492✔
64	version_type new_version = prepare_changeset(data, size, orig_version); // Throws	600,492✔
65	return new_version;	600,492✔
66	}	600,492✔
67
68	void Replication::add_class(TableKey table_key, StringData name, Table::Type type)
69	{	164,217✔
70	if (auto logger = would_log(LogLevel::debug)) {	164,217✔
71	if (type == Table::Type::Embedded) {	27,960✔
72	logger->log(LogCategory::object, LogLevel::debug, "Add %1 class '%2'", type, name);	3,282✔
73	}	3,282✔
74	else {	24,678✔
75	logger->log(LogCategory::object, LogLevel::debug, "Add class '%1'", name);	24,678✔
76	}	24,678✔
77	}	27,960✔
78	unselect_all();	164,217✔
79	m_encoder.insert_group_level_table(table_key); // Throws	164,217✔
80	}	164,217✔
81
82	void Replication::add_class_with_primary_key(TableKey tk, StringData name, DataType pk_type, StringData pk_name, bool,
83	Table::Type table_type)
84	{	108,867✔
85	if (auto logger = would_log(LogLevel::debug)) {	108,867✔
86	logger->log(LogCategory::object, LogLevel::debug, "Add %1 class '%2' with primary key property '%3' of %4",	73,980✔
87	table_type, Group::table_name_to_class_name(name), pk_name, pk_type);	73,980✔
88	}	73,980✔
89	REALM_ASSERT(table_type != Table::Type::Embedded);	108,867✔
90	unselect_all();	108,867✔
91	m_encoder.insert_group_level_table(tk); // Throws	108,867✔
92	}	108,867✔
93
94	void Replication::erase_class(TableKey tk, StringData table_name, size_t)
95	{	1,425✔
96	if (auto logger = would_log(LogLevel::debug)) {	1,425✔
97	logger->log(LogCategory::object, LogLevel::debug, "Remove class '%1'",	×
98	Group::table_name_to_class_name(table_name));	×
99	}	×
100	unselect_all();	1,425✔
101	m_encoder.erase_class(tk); // Throws	1,425✔
102	}	1,425✔
103
104	void Replication::insert_column(const Table* t, ColKey col_key, DataType type, StringData col_name,
105	Table* target_table)
106	{	563,394✔
107	if (auto logger = would_log(LogLevel::debug)) {	563,394✔
108	const char* collection_type = "";	286,455✔
109	if (col_key.is_collection()) {	286,455✔
110	if (col_key.is_list()) {	107,802✔
111	collection_type = "list ";	39,066✔
112	}	39,066✔
113	else if (col_key.is_dictionary()) {	68,736✔
114	collection_type = "dictionary ";	35,298✔
115	}	35,298✔
116	else {	33,438✔
117	collection_type = "set ";	33,438✔
118	}	33,438✔
119	}	107,802✔
120	if (target_table) {	286,455✔
121	logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Add property '%2' %3linking '%4'",	15,114✔
122	t->get_class_name(), col_name, collection_type, target_table->get_class_name());	15,114✔
123	}	15,114✔
124	else {	271,341✔
125	logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Add property '%2' %3of %4",	271,341✔
126	t->get_class_name(), col_name, collection_type, type);	271,341✔
127	}	271,341✔
128	}	286,455✔
129	select_table(t); // Throws	563,394✔
130	m_encoder.insert_column(col_key); // Throws	563,394✔
131	}	563,394✔
132
133	void Replication::erase_column(const Table* t, ColKey col_key)
134	{	4,212✔
135	if (auto logger = would_log(LogLevel::debug)) {	4,212✔
136	logger->log(LogCategory::object, LogLevel::debug, "On class '%1': Remove property '%2'", t->get_class_name(),	60✔
137	t->get_column_name(col_key));	60✔
138	}	60✔
139	select_table(t); // Throws	4,212✔
140	m_encoder.erase_column(col_key); // Throws	4,212✔
141	}	4,212✔
142
143	void Replication::track_new_object(ObjKey key)
144	{	4,652,430✔
145	m_selected_obj = key;	4,652,430✔
146	m_selected_collection = CollectionId();	4,652,430✔
147	m_newly_created_object = true;	4,652,430✔
148
149	auto table_index = m_selected_table->get_index_in_group();	4,652,430✔
150	if (table_index >= m_most_recently_created_object.size()) {	4,652,430✔
151	if (table_index >= m_most_recently_created_object.capacity())	266,052✔
152	m_most_recently_created_object.reserve(table_index * 2);	151,746✔
153	m_most_recently_created_object.resize(table_index + 1);	266,052✔
154	}	266,052✔
155	m_most_recently_created_object[table_index] = m_selected_obj;	4,652,430✔
156	}	4,652,430✔
157
158	void Replication::create_object(const Table* t, GlobalKey id)
159	{	4,298,769✔
160	if (auto logger = would_log(LogLevel::debug)) {	4,298,769✔
161	logger->log(LogCategory::object, LogLevel::debug, "Create object '%1'", t->get_class_name());	25,938✔
162	}	25,938✔
163	select_table(t); // Throws	4,298,769✔
164	m_encoder.create_object(id.get_local_key(0)); // Throws	4,298,769✔
165	track_new_object(id.get_local_key(0)); // Throws	4,298,769✔
166	}	4,298,769✔
167
168	void Replication::create_object_with_primary_key(const Table* t, ObjKey key, Mixed pk)
169	{	317,946✔
170	if (auto logger = would_log(LogLevel::debug)) {	317,946✔
171	logger->log(LogCategory::object, LogLevel::debug, "Create object '%1' with primary key %2",	118,881✔
172	t->get_class_name(), pk);	118,881✔
173	}	118,881✔
174	select_table(t); // Throws	317,946✔
175	m_encoder.create_object(key); // Throws	317,946✔
176	track_new_object(key);	317,946✔
177	}	317,946✔
178
179	void Replication::create_linked_object(const Table* t, ObjKey key)
180	{	35,430✔
181	select_table(t); // Throws	35,430✔
182	track_new_object(key); // Throws	35,430✔
183	// Does not need to encode anything as embedded tables can't be observed
184	}	35,430✔
185
186	void Replication::remove_object(const Table* t, ObjKey key)
187	{	4,915,101✔
188	if (auto logger = would_log(LogLevel::debug)) {	4,915,101✔
189	if (t->is_embedded()) {	7,500✔
190	logger->log(LogCategory::object, LogLevel::debug, "Remove embedded object '%1'", t->get_class_name());	3,651✔
191	}	3,651✔
192	else if (t->get_primary_key_column()) {	3,849✔
193	logger->log(LogCategory::object, LogLevel::debug, "Remove object '%1' with primary key %2",	3,672✔
194	t->get_class_name(), t->get_primary_key(key));	3,672✔
195	}	3,672✔
196	else {	177✔
197	logger->log(LogCategory::object, LogLevel::debug, "Remove object '%1'[%2]", t->get_class_name(), key);	177✔
198	}	177✔
199	}	7,500✔
200	select_table(t); // Throws	4,915,101✔
201	m_encoder.remove_object(key); // Throws	4,915,101✔
202	}	4,915,101✔
203
204	void Replication::do_select_table(const Table* table)
205	{	962,790✔
206	m_encoder.select_table(table->get_key()); // Throws	962,790✔
207	m_selected_table = table;	962,790✔
208	m_selected_collection = CollectionId();	962,790✔
209	m_selected_obj = ObjKey();	962,790✔
210	}	962,790✔
211
212	void Replication::do_select_obj(ObjKey key)
213	{	9,442,245✔
214	m_selected_obj = key;	9,442,245✔
215	m_selected_collection = CollectionId();	9,442,245✔
216
217	auto table_index = m_selected_table->get_index_in_group();	9,442,245✔
218	if (table_index < m_most_recently_created_object.size()) {	9,442,245✔
219	m_newly_created_object = m_most_recently_created_object[table_index] == key;	998,154✔
220	}	998,154✔
221	else {	8,444,091✔
222	m_newly_created_object = false;	8,444,091✔
223	}	8,444,091✔
224
225	if (auto logger = would_log(LogLevel::debug)) {	9,442,245✔
226	auto class_name = m_selected_table->get_class_name();	115,314✔
227	if (m_selected_table->get_primary_key_column()) {	115,314✔
228	auto pk = m_selected_table->get_primary_key(key);	62,607✔
229	logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with primary key %2", class_name,	62,607✔
230	pk);	62,607✔
231	}	62,607✔
232	else if (m_selected_table->is_embedded()) {	52,707✔
233	auto obj = m_selected_table->get_object(key);	27,777✔
234	logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with path '%2'", class_name,	27,777✔
235	obj.get_id());	27,777✔
236	}	27,777✔
237	else {	24,930✔
238	logger->log(LogCategory::object, LogLevel::debug, "Mutating anonymous object '%1'[%2]", class_name, key);	24,930✔
239	}	24,930✔
240	}	115,314✔
241	}	9,442,245✔
242
243	void Replication::do_select_collection(const CollectionBase& coll)
244	{	247,746✔
245	select_table(coll.get_table().unchecked_ptr());	247,746✔
246	ColKey col_key = coll.get_col_key();	247,746✔
247	ObjKey key = coll.get_owner_key();	247,746✔
248	auto path = coll.get_stable_path();	247,746✔
249
250	if (select_obj(key)) {	247,746✔
251	m_encoder.select_collection(col_key, key, path); // Throws	141,333✔
252	}	141,333✔
253	m_selected_collection = CollectionId(coll.get_table()->get_key(), key, std::move(path));	247,746✔
254	}	247,746✔
255
256	void Replication::do_set(const Table* t, ColKey col_key, ObjKey key, _impl::Instruction variant)
257	{	16,396,680✔
258	if (variant != _impl::Instruction::instr_SetDefault) {	16,396,680✔
259	select_table(t); // Throws	16,396,278✔
260	if (select_obj(key)) {	16,396,278✔
261	m_encoder.modify_object(col_key, key); // Throws	11,307,834✔
262	}	11,307,834✔
263	}	16,396,278✔
264	}	16,396,680✔
265
266	void Replication::set(const Table* t, ColKey col_key, ObjKey key, Mixed value, _impl::Instruction variant)
267	{	16,387,080✔
268	do_set(t, col_key, key, variant); // Throws	16,387,080✔
269	if (auto logger = would_log(LogLevel::trace)) {	16,387,080✔
270	if (col_key.get_type() == col_type_Link && value.is_type(type_Link)) {	30!
271	auto target_table = t->get_opposite_table(col_key);	×
272	if (target_table->is_embedded()) {	×
273	logger->log(LogCategory::object, LogLevel::trace, " Creating embedded object '%1' in '%2'",	×
274	target_table->get_class_name(), t->get_column_name(col_key));	×
275	}	×
276	else if (target_table->get_primary_key_column()) {	×
277	auto link = value.get<ObjKey>();	×
278	auto pk = target_table->get_primary_key(link);	×
279	logger->log(LogCategory::object, LogLevel::trace,	×
280	" Linking object '%1' with primary key %2 from '%3'", target_table->get_class_name(),	×
281	pk, t->get_column_name(col_key));	×
282	}	×
283	else {	×
284	logger->log(LogCategory::object, LogLevel::trace, " Linking object '%1'[%2] from '%3'",	×
285	target_table->get_class_name(), key, t->get_column_name(col_key));	×
286	}	×
287	}	×
288	else {	30✔
289	logger->log(LogCategory::object, LogLevel::trace, " Set '%1' to %2", t->get_column_name(col_key),	30✔
290	value.to_string(util::Logger::max_width_of_value));	30✔
291	}	30✔
292	}	30✔
293	}	16,387,080✔
294
295	void Replication::nullify_link(const Table* t, ColKey col_key, ObjKey key)
296	{	771✔
297	select_table(t); // Throws	771✔
298	if (select_obj(key)) {	771✔
299	m_encoder.modify_object(col_key, key); // Throws	753✔
300	}	753✔
301	if (auto logger = would_log(LogLevel::trace)) {	771✔
302	logger->log(LogCategory::object, LogLevel::trace, " Nullify '%1'", t->get_column_name(col_key));	×
303	}	×
304	}	771✔
305
306	void Replication::add_int(const Table* t, ColKey col_key, ObjKey key, int_fast64_t value)
307	{	8,523✔
308	do_set(t, col_key, key); // Throws	8,523✔
309	if (auto logger = get_logger()) {	8,523✔
310	logger->log(LogCategory::object, LogLevel::trace, " Adding %1 to '%2'", value, t->get_column_name(col_key));	93✔
311	}	93✔
312	}	8,523✔
313
314	Path Replication::get_prop_name(Path&& path) const
UNCOV 315	{	×
316	auto col_key = path[0].get_col_key();	×
317	auto prop_name = m_selected_table->get_column_name(col_key);	×
318	path[0] = PathElement(prop_name);	×
319	return std::move(path);	×
320	}	×
321
322	void Replication::log_collection_operation(const char* operation, const CollectionBase& collection, Mixed value,
323	Mixed index) const
324	{	1,416,072✔
325	auto logger = would_log(LogLevel::trace);	1,416,072✔
326	if (REALM_LIKELY(!logger))	1,416,072✔
327	return;	1,416,063✔
328
329	auto path = collection.get_short_path();	9✔
330	auto col_key = path[0].get_col_key();	9✔
331	auto prop_name = m_selected_table->get_column_name(col_key);	9✔
332	path[0] = PathElement(prop_name);	9✔
333	std::string position;	9✔
334	if (!index.is_null()) {	12✔
335	position = util::format(" at position %1", index);	12✔
336	}	12✔
337	if (Table::is_link_type(col_key.get_type()) && value.is_type(type_Link)) {	9!
338	auto target_table = m_selected_table->get_opposite_table(col_key);	×
339	if (target_table->is_embedded()) {	×
340	logger->log(LogCategory::object, LogLevel::trace, " %1 embedded object '%2' in %3%4 ", operation,	×
341	target_table->get_class_name(), path, position);	×
342	}	×
343	else if (target_table->get_primary_key_column()) {	×
344	auto link = value.get<ObjKey>();	×
345	auto pk = target_table->get_primary_key(link);	×
346	logger->log(LogCategory::object, LogLevel::trace, " %1 object '%2' with primary key %3 in %4%5",	×
347	operation, target_table->get_class_name(), pk, path, position);	×
348	}	×
349	else {	×
350	auto link = value.get<ObjKey>();	×
351	logger->log(LogCategory::object, LogLevel::trace, " %1 object '%2'[%3] in %4%5", operation,	×
352	target_table->get_class_name(), link, path, position);	×
353	}	×
354	}	×
355	else {	9✔
356	logger->log(LogCategory::object, LogLevel::trace, " %1 %2 in %3%4", operation,	9✔
357	value.to_string(util::Logger::max_width_of_value), path, position);	9✔
358	}	9✔
359	}	9✔
360
361	void Replication::list_insert(const CollectionBase& list, size_t list_ndx, Mixed value, size_t)
362	{	1,266,906✔
363	if (select_collection(list)) { // Throws	1,266,906✔
364	m_encoder.collection_insert(list.translate_index(list_ndx)); // Throws	394,272✔
365	}	394,272✔
366	log_collection_operation("Insert", list, value, int64_t(list_ndx));	1,266,906✔
367	}	1,266,906✔
368
369	void Replication::list_set(const CollectionBase& list, size_t list_ndx, Mixed value)
370	{	49,530✔
371	if (select_collection(list)) { // Throws	49,530✔
372	m_encoder.collection_set(list.translate_index(list_ndx)); // Throws	33,969✔
373	}	33,969✔
374	log_collection_operation("Set", list, value, int64_t(list_ndx));	49,530✔
375	}	49,530✔
376
377	void Replication::list_erase(const CollectionBase& list, size_t link_ndx)
378	{	212,052✔
379	if (select_collection(list)) { // Throws	212,052✔
380	m_encoder.collection_erase(list.translate_index(link_ndx)); // Throws	75,675✔
381	}	75,675✔
382	if (auto logger = would_log(LogLevel::trace)) {	212,052✔
UNCOV 383	logger->log(LogCategory::object, LogLevel::trace, " Erase '%1' at position %2",	×
384	get_prop_name(list.get_short_path()), link_ndx);	×
385	}	×
386	}	212,052✔
387
388	void Replication::list_move(const CollectionBase& list, size_t from_link_ndx, size_t to_link_ndx)
389	{	1,746✔
390	if (select_collection(list)) { // Throws	1,746✔
391	m_encoder.collection_move(list.translate_index(from_link_ndx), list.translate_index(to_link_ndx)); // Throws	960✔
392	}	960✔
393	if (auto logger = would_log(LogLevel::trace)) {	1,746✔
394	logger->log(LogCategory::object, LogLevel::trace, " Move %1 to %2 in '%3'", from_link_ndx, to_link_ndx,	×
395	get_prop_name(list.get_short_path()));	×
396	}	×
397	}	1,746✔
398
399	void Replication::set_insert(const CollectionBase& set, size_t set_ndx, Mixed value)
400	{	63,321✔
401	Replication::list_insert(set, set_ndx, value, 0); // Throws	63,321✔
402	}	63,321✔
403
404	void Replication::set_erase(const CollectionBase& set, size_t set_ndx, Mixed)
405	{	12,522✔
406	Replication::list_erase(set, set_ndx); // Throws	12,522✔
407	}	12,522✔
408
409	void Replication::set_clear(const CollectionBase& set)
410	{	2,418✔
411	Replication::list_clear(set); // Throws	2,418✔
412	}	2,418✔
413
414	void Replication::list_clear(const CollectionBase& list)
415	{	5,337✔
416	if (select_collection(list)) { // Throws	5,337✔
417	m_encoder.collection_clear(list.size()); // Throws	3,891✔
418	}	3,891✔
419	if (auto logger = would_log(LogLevel::trace)) {	5,337✔
420	logger->log(LogCategory::object, LogLevel::trace, " Clear '%1'", get_prop_name(list.get_short_path()));	×
421	}	×
422	}	5,337✔
423
424	void Replication::link_list_nullify(const Lst<ObjKey>& list, size_t link_ndx)
425	{	2,136✔
426	if (select_collection(list)) { // Throws	2,136✔
427	m_encoder.collection_erase(link_ndx);	1,956✔
428	}	1,956✔
429	if (auto logger = would_log(LogLevel::trace)) {	2,136✔
430	logger->log(LogCategory::object, LogLevel::trace, " Nullify '%1' position %2",	×
431	m_selected_table->get_column_name(list.get_col_key()), link_ndx);	×
432	}	×
433	}	2,136✔
434
435	void Replication::dictionary_insert(const CollectionBase& dict, size_t ndx, Mixed key, Mixed value)
436	{	89,847✔
437	if (select_collection(dict)) { // Throws	89,847✔
438	m_encoder.collection_insert(ndx);	45,867✔
439	}	45,867✔
440	log_collection_operation("Insert", dict, value, key);	89,847✔
441	}	89,847✔
442
443	void Replication::dictionary_set(const CollectionBase& dict, size_t ndx, Mixed key, Mixed value)
444	{	9,831✔
445	if (select_collection(dict)) { // Throws	9,831✔
446	m_encoder.collection_set(ndx);	8,274✔
447	}	8,274✔
448	log_collection_operation("Set", dict, value, key);	9,831✔
449	}	9,831✔
450
451	void Replication::dictionary_erase(const CollectionBase& dict, size_t ndx, Mixed key)
452	{	12,471✔
453	if (select_collection(dict)) { // Throws	12,471✔
454	m_encoder.collection_erase(ndx);	11,505✔
455	}	11,505✔
456	if (auto logger = would_log(LogLevel::trace)) {	12,471✔
457	logger->log(LogCategory::object, LogLevel::trace, " Erase %1 from '%2'", key,	×
458	get_prop_name(dict.get_short_path()));	×
459	}	×
460	}	12,471✔
461
462	void Replication::dictionary_clear(const CollectionBase& dict)
463	{	2,646✔
464	if (select_collection(dict)) { // Throws	2,646✔
465	m_encoder.collection_clear(dict.size());	2,532✔
466	}	2,532✔
467	if (auto logger = would_log(LogLevel::trace)) {	2,646✔
468	logger->log(LogCategory::object, LogLevel::trace, " Clear '%1'", get_prop_name(dict.get_short_path()));	×
469	}	×
470	}	2,646✔

realm / realm-core / 2386

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