github_pull_request_314032

Committed 07 Mar 2025 05:25PM UTC coverage: 91.11% (-0.03%) from 91.143%

Build # github_pull_request_314032

Build Type

Pull #8075

Evergreen

Committed by

web-flow

Commit Message

Bump axios and cmake-js

Bumps [axios](https://github.com/axios/axios) to 1.8.2 and updates ancestor dependency [cmake-js](https://github.com/cmake-js/cmake-js). These dependencies need to be updated together.


Updates `axios` from 0.21.4 to 1.8.2
- [Release notes](https://github.com/axios/axios/releases)
- [Changelog](https://github.com/axios/axios/blob/v1.x/CHANGELOG.md)
- [Commits](https://github.com/axios/axios/compare/v0.21.4...v1.8.2)

Updates `cmake-js` from 6.3.2 to 7.3.0
- [Release notes](https://github.com/cmake-js/cmake-js/releases)
- [Changelog](https://github.com/cmake-js/cmake-js/blob/master/changelog.md)
- [Commits](https://github.com/cmake-js/cmake-js/compare/v6.3.2...v7.3.0)

---
updated-dependencies:
- dependency-name: axios
  dependency-type: indirect
- dependency-name: cmake-js
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #8075: Bump axios and cmake-js

Coverage Stats

102712 of 181548 branches covered (56.58%)

217414 of 238627 relevant lines covered (91.11%)

5992215.16 hits per line

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

88.03

/src/realm/array_string.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/array_string.hpp>
#include <realm/spec.hpp>
#include <realm/mixed.hpp>

using namespace realm;

ArrayString::ArrayString(Allocator& a)
    : m_alloc(a)
{
    m_arr = new (&m_storage) ArrayStringShort(a, true);
}

void ArrayString::create()
{
    static_cast<ArrayStringShort*>(m_arr)->create();
}

void ArrayString::init_from_mem(MemRef mem) noexcept
{
    char* header = mem.get_addr();

    ArrayParent* parent = m_arr->get_parent();
    size_t ndx_in_parent = m_arr->get_ndx_in_parent();

    bool long_strings = Array::get_hasrefs_from_header(header);
    if (!long_strings) {
        // Small strings
        bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;
        if (is_small) {
            auto arr = new (&m_storage) ArrayStringShort(m_alloc, m_nullable);
            arr->init_from_mem(mem);
            m_type = Type::small_strings;
        }
        else {
            auto arr = new (&m_storage) Array(m_alloc);
            arr->init_from_mem(mem);
            m_string_enum_values = std::make_unique<ArrayString>(m_alloc);
            ArrayParent* p;
            REALM_ASSERT(m_spec != nullptr);
            REALM_ASSERT(m_col_ndx != realm::npos);
            ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);
            m_string_enum_values->init_from_ref(r);
            m_string_enum_values->set_parent(p, m_col_ndx);
            m_type = Type::enum_strings;
        }
    }
    else {
        bool is_big = Array::get_context_flag_from_header(header);
        if (!is_big) {
            auto arr = new (&m_storage) ArraySmallBlobs(m_alloc);
            arr->init_from_mem(mem);
            m_type = Type::medium_strings;
        }
        else {
            auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, m_nullable);
            arr->init_from_mem(mem);
            m_type = Type::big_strings;
        }
    }
    m_arr->set_parent(parent, ndx_in_parent);
}

void ArrayString::init_from_parent()
{
    ref_type ref = m_arr->get_ref_from_parent();
    init_from_ref(ref);
}

void ArrayString::destroy() noexcept
{
    if (m_arr->is_attached()) {
        Array::destroy_deep(m_arr->get_ref(), m_alloc);
        detach();
    }
}

void ArrayString::detach() noexcept
{
    m_arr->detach();
    // Make sure the object is in a state like right after construction
    // Next call must be to create()
    m_arr = new (&m_storage) ArrayStringShort(m_alloc, true);
    m_type = Type::small_strings;
}

size_t ArrayString::size() const
{
    switch (m_type) {
        case Type::small_strings:
            return static_cast<ArrayStringShort*>(m_arr)->size();
        case Type::medium_strings:
            return static_cast<ArraySmallBlobs*>(m_arr)->size();
        case Type::big_strings:
            return static_cast<ArrayBigBlobs*>(m_arr)->size();
        case Type::enum_strings:
            return static_cast<Array*>(m_arr)->size();
    }
    return {};
}

void ArrayString::add(StringData value)
{
    switch (upgrade_leaf(value.size())) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->add(value);
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->add_string(value);
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->add_string(value);
            break;
        case Type::enum_strings: {
            auto a = static_cast<Array*>(m_arr);
            size_t ndx = a->size();
            a->add(0);
            set(ndx, value);
            break;
        }
    }
}

void ArrayString::set(size_t ndx, StringData value)
{
    switch (upgrade_leaf(value.size())) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);
            break;
        case Type::enum_strings: {
            size_t sz = m_string_enum_values->size();
            size_t res = m_string_enum_values->find_first(value, 0, sz);
            if (res == realm::not_found) {
                m_string_enum_values->add(value);
                res = sz;
            }
            static_cast<Array*>(m_arr)->set(ndx, res);
            break;
        }
    }
}

void ArrayString::insert(size_t ndx, StringData value)
{
    switch (upgrade_leaf(value.size())) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);
            break;
        case Type::enum_strings: {
            static_cast<Array*>(m_arr)->insert(ndx, 0);
            set(ndx, value);
        }
    }
}

StringData ArrayString::get(size_t ndx) const
{
    switch (m_type) {
        case Type::small_strings:
            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);
        case Type::medium_strings:
            return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);
        case Type::big_strings:
            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);
        case Type::enum_strings: {
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
            return m_string_enum_values->get(index);
        }
    }
    return {};
}

StringData ArrayString::get_legacy(size_t ndx) const
{
    switch (m_type) {
        case Type::small_strings:
            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);
        case Type::medium_strings:
            return static_cast<ArraySmallBlobs*>(m_arr)->get_string_legacy(ndx);
        case Type::big_strings:
            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);
        case Type::enum_strings: {
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
            return m_string_enum_values->get(index);
        }
    }
    return {};
}

Mixed ArrayString::get_any(size_t ndx) const
{
    return Mixed(get(ndx));
}

bool ArrayString::is_null(size_t ndx) const
{
    switch (m_type) {
        case Type::small_strings:
            return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);
        case Type::medium_strings:
            return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);
        case Type::big_strings:
            return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);
        case Type::enum_strings: {
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
            return m_string_enum_values->is_null(index);
        }
    }
    return {};
}

void ArrayString::erase(size_t ndx)
{
    switch (m_type) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->erase(ndx);
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);
            break;
        case Type::enum_strings:
            static_cast<Array*>(m_arr)->erase(ndx);
            break;
    }
}

void ArrayString::move(ArrayString& dst, size_t ndx)
{
    size_t sz = size();
    for (size_t i = ndx; i < sz; i++) {
        dst.add(get(i));
    }

    switch (m_type) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->truncate(ndx);
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->truncate(ndx);
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->truncate(ndx);
            break;
        case Type::enum_strings:
            // this operation will never be called for enumerated columns
            REALM_UNREACHABLE();
            break;
    }
}

void ArrayString::clear()
{
    switch (m_type) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->clear();
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->clear();
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->clear();
            break;
        case Type::enum_strings:
            static_cast<Array*>(m_arr)->clear();
            break;
    }
}

size_t ArrayString::find_first(StringData value, size_t begin, size_t end) const noexcept
{
    switch (m_type) {
        case Type::small_strings:
            return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);
        case Type::medium_strings: {
            BinaryData as_binary(value.data(), value.size());
            return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
            break;
        }
        case Type::big_strings: {
            BinaryData as_binary(value.data(), value.size());
            return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
            break;
        }
        case Type::enum_strings: {
            size_t sz = m_string_enum_values->size();
            size_t res = m_string_enum_values->find_first(value, 0, sz);
            if (res != realm::not_found) {
                return static_cast<Array*>(m_arr)->find_first(res, begin, end);
            }
            break;
        }
    }
    return not_found;
}

namespace {

template <class T>
inline StringData get_string(const T* arr, size_t ndx)
{
    return arr->get_string(ndx);
}

template <>
inline StringData get_string(const ArrayStringShort* arr, size_t ndx)
{
    return arr->get(ndx);
}

template <class T, class U>
size_t lower_bound_string(const T* arr, U value)
{
    size_t i = 0;
    size_t sz = arr->size();
    while (0 < sz) {
        size_t half = sz / 2;
        size_t mid = i + half;
        auto probe = get_string(arr, mid);
        if (probe < value) {
            i = mid + 1;
            sz -= half + 1;
        }
        else {
            sz = half;
        }
    }
    return i;
}
} // namespace

size_t ArrayString::lower_bound(StringData value)
{
    switch (m_type) {
        case Type::small_strings:
            return lower_bound_string(static_cast<ArrayStringShort*>(m_arr), value);
        case Type::medium_strings:
            return lower_bound_string(static_cast<ArraySmallBlobs*>(m_arr), value);
        case Type::big_strings:
            return lower_bound_string(static_cast<ArrayBigBlobs*>(m_arr), value);
        case Type::enum_strings:
            break;
    }
    return realm::npos;
}

ArrayString::Type ArrayString::upgrade_leaf(size_t value_size)
{
    if (m_type == Type::big_strings)
        return Type::big_strings;

    if (m_type == Type::enum_strings)
        return Type::enum_strings;

    if (m_type == Type::medium_strings) {
        if (value_size <= medium_string_max_size)
            return Type::medium_strings;

        // Upgrade root leaf from medium to big strings
        auto string_medium = static_cast<ArraySmallBlobs*>(m_arr);
        ArrayBigBlobs big_blobs(m_alloc, true);
        big_blobs.create(); // Throws

        size_t n = string_medium->size();
        for (size_t i = 0; i < n; i++) {
            big_blobs.add_string(string_medium->get_string(i)); // Throws
        }
        auto parent = string_medium->get_parent();
        auto ndx_in_parent = string_medium->get_ndx_in_parent();
        string_medium->destroy();

        auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, true);
        arr->init_from_mem(big_blobs.get_mem());
        arr->set_parent(parent, ndx_in_parent);
        arr->update_parent();

        m_type = Type::big_strings;
        return Type::big_strings;
    }

    // m_type == Type::small
    if (value_size <= small_string_max_size)
        return Type::small_strings;

    if (value_size <= medium_string_max_size) {
        // Upgrade root leaf from small to medium strings
        auto string_short = static_cast<ArrayStringShort*>(m_arr);
        ArraySmallBlobs string_long(m_alloc);
        string_long.create(); // Throws

        size_t n = string_short->size();
        for (size_t i = 0; i < n; i++) {
            string_long.add_string(string_short->get(i)); // Throws
        }
        auto parent = string_short->get_parent();
        auto ndx_in_parent = string_short->get_ndx_in_parent();
        string_short->destroy();

        auto arr = new (&m_storage) ArraySmallBlobs(m_alloc);
        arr->init_from_mem(string_long.get_mem());
        arr->set_parent(parent, ndx_in_parent);
        arr->update_parent();

        m_type = Type::medium_strings;
    }
    else {
        // Upgrade root leaf from small to big strings
        auto string_short = static_cast<ArrayStringShort*>(m_arr);
        ArrayBigBlobs big_blobs(m_alloc, true);
        big_blobs.create(); // Throws

        size_t n = string_short->size();
        for (size_t i = 0; i < n; i++) {
            big_blobs.add_string(string_short->get(i)); // Throws
        }
        auto parent = string_short->get_parent();
        auto ndx_in_parent = string_short->get_ndx_in_parent();
        string_short->destroy();

        auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, true);
        arr->init_from_mem(big_blobs.get_mem());
        arr->set_parent(parent, ndx_in_parent);
        arr->update_parent();

        m_type = Type::big_strings;
    }

    return m_type;
}

void ArrayString::verify() const
{
#ifdef REALM_DEBUG
    switch (m_type) {
        case Type::small_strings:
            static_cast<ArrayStringShort*>(m_arr)->verify();
            break;
        case Type::medium_strings:
            static_cast<ArraySmallBlobs*>(m_arr)->verify();
            break;
        case Type::big_strings:
            static_cast<ArrayBigBlobs*>(m_arr)->verify();
            break;
        case Type::enum_strings:
            static_cast<Array*>(m_arr)->verify();
            break;
    }
#endif
}

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/array_string.hpp>
20	#include <realm/spec.hpp>
21	#include <realm/mixed.hpp>
22
23	using namespace realm;
24
25	ArrayString::ArrayString(Allocator& a)
26	: m_alloc(a)	9,868,887 ✔
27	{	20,008,956 ✔
28	m_arr = new (&m_storage) ArrayStringShort(a, true);	20,008,956 ✔
29	}	20,008,956 ✔
30
31	void ArrayString::create()
32	{	578,514 ✔
33	static_cast<ArrayStringShort*>(m_arr)->create();	578,514 ✔
34	}	578,514 ✔
35
36	void ArrayString::init_from_mem(MemRef mem) noexcept
37	{	12,903,870 ✔
38	char* header = mem.get_addr();	12,903,870 ✔
39
40	ArrayParent* parent = m_arr->get_parent();	12,903,870 ✔
41	size_t ndx_in_parent = m_arr->get_ndx_in_parent();	12,903,870 ✔
42
43	bool long_strings = Array::get_hasrefs_from_header(header);	12,903,870 ✔
44	if (!long_strings) {	12,903,870 ✔
45	// Small strings
46	bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;	10,100,127 ✔
47	if (is_small) {	10,100,127 ✔
48	auto arr = new (&m_storage) ArrayStringShort(m_alloc, m_nullable);	6,396,081 ✔
49	arr->init_from_mem(mem);	6,396,081 ✔
50	m_type = Type::small_strings;	6,396,081 ✔
51	}	6,396,081 ✔
52	else {	3,704,046 ✔
53	auto arr = new (&m_storage) Array(m_alloc);	3,704,046 ✔
54	arr->init_from_mem(mem);	3,704,046 ✔
55	m_string_enum_values = std::make_unique<ArrayString>(m_alloc);	3,704,046 ✔
56	ArrayParent* p;	3,704,046 ✔
57	REALM_ASSERT(m_spec != nullptr);	3,704,046 ✔
58	REALM_ASSERT(m_col_ndx != realm::npos);	3,704,046 ✔
59	ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);	3,704,046 ✔
60	m_string_enum_values->init_from_ref(r);	3,704,046 ✔
61	m_string_enum_values->set_parent(p, m_col_ndx);	3,704,046 ✔
62	m_type = Type::enum_strings;	3,704,046 ✔
63	}	3,704,046 ✔
64	}	10,100,127 ✔
65	else {	2,803,743 ✔
66	bool is_big = Array::get_context_flag_from_header(header);	2,803,743 ✔
67	if (!is_big) {	2,803,743 ✔
68	auto arr = new (&m_storage) ArraySmallBlobs(m_alloc);	705,102 ✔
69	arr->init_from_mem(mem);	705,102 ✔
70	m_type = Type::medium_strings;	705,102 ✔
71	}	705,102 ✔
72	else {	2,098,641 ✔
73	auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, m_nullable);	2,098,641 ✔
74	arr->init_from_mem(mem);	2,098,641 ✔
75	m_type = Type::big_strings;	2,098,641 ✔
76	}	2,098,641 ✔
77	}	2,803,743 ✔
78	m_arr->set_parent(parent, ndx_in_parent);	12,903,870 ✔
79	}	12,903,870 ✔
80
81	void ArrayString::init_from_parent()
82	{	6,096,561 ✔
83	ref_type ref = m_arr->get_ref_from_parent();	6,096,561 ✔
84	init_from_ref(ref);	6,096,561 ✔
85	}	6,096,561 ✔
86
87	void ArrayString::destroy() noexcept
88	{	1,044 ✔
89	if (m_arr->is_attached()) {	1,044 ✔
90	Array::destroy_deep(m_arr->get_ref(), m_alloc);	468 ✔
91	detach();	468 ✔
92	}	468 ✔
93	}	1,044 ✔
94
95	void ArrayString::detach() noexcept
96	{	4,178,130 ✔
97	m_arr->detach();	4,178,130 ✔
98	// Make sure the object is in a state like right after construction
99	// Next call must be to create()
100	m_arr = new (&m_storage) ArrayStringShort(m_alloc, true);	4,178,130 ✔
101	m_type = Type::small_strings;	4,178,130 ✔
102	}	4,178,130 ✔
103
104	size_t ArrayString::size() const
105	{	16,188,597 ✔
106	switch (m_type) {	16,188,597 ✔
107	case Type::small_strings:	6,909,765 ✔
108	return static_cast<ArrayStringShort*>(m_arr)->size();	6,909,765 ✔
109	case Type::medium_strings:	453,900 ✔
110	return static_cast<ArraySmallBlobs*>(m_arr)->size();	453,900 ✔
111	case Type::big_strings:	8,842,434 ✔
112	return static_cast<ArrayBigBlobs*>(m_arr)->size();	8,842,434 ✔
113	case Type::enum_strings:	246 ✔
114	return static_cast<Array*>(m_arr)->size();	246 ✔
115	}	16,188,597 ✔
116	return {};	×
117	}	16,188,597 ✔
118
119	void ArrayString::add(StringData value)
120	{	453,576 ✔
121	switch (upgrade_leaf(value.size())) {	453,576 ✔
122	case Type::small_strings:	397,188 ✔
123	static_cast<ArrayStringShort*>(m_arr)->add(value);	397,188 ✔
124	break;	397,188 ✔
125	case Type::medium_strings:	28,152 ✔
126	static_cast<ArraySmallBlobs*>(m_arr)->add_string(value);	28,152 ✔
127	break;	28,152 ✔
128	case Type::big_strings:	28,239 ✔
129	static_cast<ArrayBigBlobs*>(m_arr)->add_string(value);	28,239 ✔
130	break;	28,239 ✔
131	case Type::enum_strings: {	✔
132	auto a = static_cast<Array*>(m_arr);	×
133	size_t ndx = a->size();	×
134	a->add(0);	×
135	set(ndx, value);	×
136	break;	×
137	}	×
138	}	453,576 ✔
139	}	453,576 ✔
140
141	void ArrayString::set(size_t ndx, StringData value)
142	{	3,822,777 ✔
143	switch (upgrade_leaf(value.size())) {	3,822,777 ✔
144	case Type::small_strings:	574,833 ✔
145	static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);	574,833 ✔
146	break;	574,833 ✔
147	case Type::medium_strings:	238,650 ✔
148	static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);	238,650 ✔
149	break;	238,650 ✔
150	case Type::big_strings:	385,335 ✔
151	static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);	385,335 ✔
152	break;	385,335 ✔
153	case Type::enum_strings: {	2,625,939 ✔
154	size_t sz = m_string_enum_values->size();	2,625,939 ✔
155	size_t res = m_string_enum_values->find_first(value, 0, sz);	2,625,939 ✔
156	if (res == realm::not_found) {	2,625,939 ✔
157	m_string_enum_values->add(value);	9,681 ✔
158	res = sz;	9,681 ✔
159	}	9,681 ✔
160	static_cast<Array*>(m_arr)->set(ndx, res);	2,625,939 ✔
161	break;	2,625,939 ✔
162	}	×
163	}	3,822,777 ✔
164	}	3,822,777 ✔
165
166	void ArrayString::insert(size_t ndx, StringData value)
167	{	4,446,561 ✔
168	switch (upgrade_leaf(value.size())) {	4,446,561 ✔
169	case Type::small_strings:	1,972,626 ✔
170	static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);	1,972,626 ✔
171	break;	1,972,626 ✔
172	case Type::medium_strings:	295,449 ✔
173	static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);	295,449 ✔
174	break;	295,449 ✔
175	case Type::big_strings:	867,723 ✔
176	static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);	867,723 ✔
177	break;	867,723 ✔
178	case Type::enum_strings: {	1,312,905 ✔
179	static_cast<Array*>(m_arr)->insert(ndx, 0);	1,312,905 ✔
180	set(ndx, value);	1,312,905 ✔
181	}	1,312,905 ✔
182	}	4,446,561 ✔
183	}	4,446,561 ✔
184
185	StringData ArrayString::get(size_t ndx) const
186	{	20,722,704 ✔
187	switch (m_type) {	20,722,704 ✔
188	case Type::small_strings:	11,048,871 ✔
189	return static_cast<ArrayStringShort*>(m_arr)->get(ndx);	11,048,871 ✔
190	case Type::medium_strings:	899,313 ✔
191	return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);	899,313 ✔
192	case Type::big_strings:	7,636,089 ✔
193	return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);	7,636,089 ✔
194	case Type::enum_strings: {	1,145,961 ✔
195	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	1,145,961 ✔
196	return m_string_enum_values->get(index);	1,145,961 ✔
197	}	×
198	}	20,722,704 ✔
199	return {};	×
200	}	20,722,704 ✔
201
202	StringData ArrayString::get_legacy(size_t ndx) const
203	{	×
204	switch (m_type) {	×
205	case Type::small_strings:	×
206	return static_cast<ArrayStringShort*>(m_arr)->get(ndx);	×
207	case Type::medium_strings:	×
208	return static_cast<ArraySmallBlobs*>(m_arr)->get_string_legacy(ndx);	×
209	case Type::big_strings:	×
210	return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);	×
211	case Type::enum_strings: {	×
212	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	×
213	return m_string_enum_values->get(index);	×
214	}	×
215	}	×
216	return {};	×
217	}	×
218
219	Mixed ArrayString::get_any(size_t ndx) const
220	{	132,858 ✔
221	return Mixed(get(ndx));	132,858 ✔
222	}	132,858 ✔
223
224	bool ArrayString::is_null(size_t ndx) const
225	{	3,831,873 ✔
226	switch (m_type) {	3,831,873 ✔
227	case Type::small_strings:	503,457 ✔
228	return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);	503,457 ✔
229	case Type::medium_strings:	13,131 ✔
230	return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);	13,131 ✔
231	case Type::big_strings:	3,315,327 ✔
232	return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);	3,315,327 ✔
233	case Type::enum_strings: {	✔
234	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	×
235	return m_string_enum_values->is_null(index);	×
236	}	×
237	}	3,831,873 ✔
238	return {};	×
239	}	3,831,873 ✔
240
241	void ArrayString::erase(size_t ndx)
242	{	480,540 ✔
243	switch (m_type) {	480,540 ✔
244	case Type::small_strings:	388,560 ✔
245	static_cast<ArrayStringShort*>(m_arr)->erase(ndx);	388,560 ✔
246	break;	388,560 ✔
247	case Type::medium_strings:	57,255 ✔
248	static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);	57,255 ✔
249	break;	57,255 ✔
250	case Type::big_strings:	26,394 ✔
251	static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);	26,394 ✔
252	break;	26,394 ✔
253	case Type::enum_strings:	8,403 ✔
254	static_cast<Array*>(m_arr)->erase(ndx);	8,403 ✔
255	break;	8,403 ✔
256	}	480,540 ✔
257	}	480,540 ✔
258
259	void ArrayString::move(ArrayString& dst, size_t ndx)
260	{	1,074 ✔
261	size_t sz = size();	1,074 ✔
262	for (size_t i = ndx; i < sz; i++) {	116,478 ✔
263	dst.add(get(i));	115,404 ✔
264	}	115,404 ✔
265
266	switch (m_type) {	1,074 ✔
267	case Type::small_strings:	1,008 ✔
268	static_cast<ArrayStringShort*>(m_arr)->truncate(ndx);	1,008 ✔
269	break;	1,008 ✔
270	case Type::medium_strings:	60 ✔
271	static_cast<ArraySmallBlobs*>(m_arr)->truncate(ndx);	60 ✔
272	break;	60 ✔
273	case Type::big_strings:	6 ✔
274	static_cast<ArrayBigBlobs*>(m_arr)->truncate(ndx);	6 ✔
275	break;	6 ✔
276	case Type::enum_strings:	✔
277	// this operation will never be called for enumerated columns
278	REALM_UNREACHABLE();
279	break;	×
280	}	1,074 ✔
281	}	1,074 ✔
282
283	void ArrayString::clear()
284	{	354 ✔
285	switch (m_type) {	354 ✔
286	case Type::small_strings:	300 ✔
287	static_cast<ArrayStringShort*>(m_arr)->clear();	300 ✔
288	break;	300 ✔
289	case Type::medium_strings:	6 ✔
290	static_cast<ArraySmallBlobs*>(m_arr)->clear();	6 ✔
291	break;	6 ✔
292	case Type::big_strings:	48 ✔
293	static_cast<ArrayBigBlobs*>(m_arr)->clear();	48 ✔
294	break;	48 ✔
295	case Type::enum_strings:	✔
296	static_cast<Array*>(m_arr)->clear();	×
297	break;	×
298	}	354 ✔
299	}	354 ✔
300
301	size_t ArrayString::find_first(StringData value, size_t begin, size_t end) const noexcept
302	{	4,126,422 ✔
303	switch (m_type) {	4,126,422 ✔
304	case Type::small_strings:	3,150,024 ✔
305	return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);	3,150,024 ✔
306	case Type::medium_strings: {	125,586 ✔
307	BinaryData as_binary(value.data(), value.size());	125,586 ✔
308	return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);	125,586 ✔
309	break;	×
310	}	×
311	case Type::big_strings: {	254,166 ✔
312	BinaryData as_binary(value.data(), value.size());	254,166 ✔
313	return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);	254,166 ✔
314	break;	×
315	}	×
316	case Type::enum_strings: {	596,733 ✔
317	size_t sz = m_string_enum_values->size();	596,733 ✔
318	size_t res = m_string_enum_values->find_first(value, 0, sz);	596,733 ✔
319	if (res != realm::not_found) {	596,733 ✔
320	return static_cast<Array*>(m_arr)->find_first(res, begin, end);	596,733 ✔
321	}	596,733 ✔
322	break;	×
323	}	596,733 ✔
324	}	4,126,422 ✔
325	return not_found;	×
326	}	4,126,422 ✔
327
328	namespace {
329
330	template <class T>
331	inline StringData get_string(const T* arr, size_t ndx)
332	{	437,337 ✔
333	return arr->get_string(ndx);	437,337 ✔
334	}	437,337 ✔
335
336	template <>
337	inline StringData get_string(const ArrayStringShort* arr, size_t ndx)
338	{	93,696 ✔
339	return arr->get(ndx);	93,696 ✔
340	}	93,696 ✔
341
342	template <class T, class U>
343	size_t lower_bound_string(const T* arr, U value)
344	{	234,912 ✔
345	size_t i = 0;	234,912 ✔
346	size_t sz = arr->size();	234,912 ✔
347	while (0 < sz) {	765,945 ✔
348	size_t half = sz / 2;	531,033 ✔
349	size_t mid = i + half;	531,033 ✔
350	auto probe = get_string(arr, mid);	531,033 ✔
351	if (probe < value) {	531,033 ✔
352	i = mid + 1;	190,959 ✔
353	sz -= half + 1;	190,959 ✔
354	}	190,959 ✔
355	else {	340,074 ✔
356	sz = half;	340,074 ✔
357	}	340,074 ✔
358	}	531,033 ✔
359	return i;	234,912 ✔
360	}	234,912 ✔
361	} // namespace
362
363	size_t ArrayString::lower_bound(StringData value)
364	{	234,912 ✔
365	switch (m_type) {	234,912 ✔
366	case Type::small_strings:	58,434 ✔
367	return lower_bound_string(static_cast<ArrayStringShort*>(m_arr), value);	58,434 ✔
368	case Type::medium_strings:	68,418 ✔
369	return lower_bound_string(static_cast<ArraySmallBlobs*>(m_arr), value);	68,418 ✔
370	case Type::big_strings:	108,060 ✔
371	return lower_bound_string(static_cast<ArrayBigBlobs*>(m_arr), value);	108,060 ✔
372	case Type::enum_strings:	✔
373	break;	×
374	}	234,912 ✔
375	return realm::npos;	×
376	}	234,912 ✔
377
378	ArrayString::Type ArrayString::upgrade_leaf(size_t value_size)
379	{	8,715,978 ✔
380	if (m_type == Type::big_strings)	8,715,978 ✔
381	return Type::big_strings;	1,260,528 ✔
382
383	if (m_type == Type::enum_strings)	7,455,450 ✔
384	return Type::enum_strings;	3,938,835 ✔
385
386	if (m_type == Type::medium_strings) {	3,516,615 ✔
387	if (value_size <= medium_string_max_size)	532,695 ✔
388	return Type::medium_strings;	532,170 ✔
389
390	// Upgrade root leaf from medium to big strings
391	auto string_medium = static_cast<ArraySmallBlobs*>(m_arr);	525 ✔
392	ArrayBigBlobs big_blobs(m_alloc, true);	525 ✔
393	big_blobs.create(); // Throws	525 ✔
394
395	size_t n = string_medium->size();	525 ✔
396	for (size_t i = 0; i < n; i++) {	9,930 ✔
397	big_blobs.add_string(string_medium->get_string(i)); // Throws	9,405 ✔
398	}	9,405 ✔
399	auto parent = string_medium->get_parent();	525 ✔
400	auto ndx_in_parent = string_medium->get_ndx_in_parent();	525 ✔
401	string_medium->destroy();	525 ✔
402
403	auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, true);	525 ✔
404	arr->init_from_mem(big_blobs.get_mem());	525 ✔
405	arr->set_parent(parent, ndx_in_parent);	525 ✔
406	arr->update_parent();	525 ✔
407
408	m_type = Type::big_strings;	525 ✔
409	return Type::big_strings;	525 ✔
410	}	532,695 ✔
411
412	// m_type == Type::small
413	if (value_size <= small_string_max_size)	2,983,920 ✔
414	return Type::small_strings;	2,943,477 ✔
415
416	if (value_size <= medium_string_max_size) {	40,443 ✔
417	// Upgrade root leaf from small to medium strings
418	auto string_short = static_cast<ArrayStringShort*>(m_arr);	30,000 ✔
419	ArraySmallBlobs string_long(m_alloc);	30,000 ✔
420	string_long.create(); // Throws	30,000 ✔
421
422	size_t n = string_short->size();	30,000 ✔
423	for (size_t i = 0; i < n; i++) {	52,140 ✔
424	string_long.add_string(string_short->get(i)); // Throws	22,140 ✔
425	}	22,140 ✔
426	auto parent = string_short->get_parent();	30,000 ✔
427	auto ndx_in_parent = string_short->get_ndx_in_parent();	30,000 ✔
428	string_short->destroy();	30,000 ✔
429
430	auto arr = new (&m_storage) ArraySmallBlobs(m_alloc);	30,000 ✔
431	arr->init_from_mem(string_long.get_mem());	30,000 ✔
432	arr->set_parent(parent, ndx_in_parent);	30,000 ✔
433	arr->update_parent();	30,000 ✔
434
435	m_type = Type::medium_strings;	30,000 ✔
436	}	30,000 ✔
437	else {	10,443 ✔
438	// Upgrade root leaf from small to big strings
439	auto string_short = static_cast<ArrayStringShort*>(m_arr);	10,443 ✔
440	ArrayBigBlobs big_blobs(m_alloc, true);	10,443 ✔
441	big_blobs.create(); // Throws	10,443 ✔
442
443	size_t n = string_short->size();	10,443 ✔
444	for (size_t i = 0; i < n; i++) {	30,966 ✔
445	big_blobs.add_string(string_short->get(i)); // Throws	20,523 ✔
446	}	20,523 ✔
447	auto parent = string_short->get_parent();	10,443 ✔
448	auto ndx_in_parent = string_short->get_ndx_in_parent();	10,443 ✔
449	string_short->destroy();	10,443 ✔
450
451	auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, true);	10,443 ✔
452	arr->init_from_mem(big_blobs.get_mem());	10,443 ✔
453	arr->set_parent(parent, ndx_in_parent);	10,443 ✔
454	arr->update_parent();	10,443 ✔
455
456	m_type = Type::big_strings;	10,443 ✔
457	}	10,443 ✔
458
459	return m_type;	40,443 ✔
460	}	2,983,920 ✔
461
462	void ArrayString::verify() const
463	{	189,876 ✔
464	#ifdef REALM_DEBUG	189,876 ✔
465	switch (m_type) {	189,876 ✔
466	case Type::small_strings:	183,480 ✔
467	static_cast<ArrayStringShort*>(m_arr)->verify();	183,480 ✔
468	break;	183,480 ✔
469	case Type::medium_strings:	663 ✔
470	static_cast<ArraySmallBlobs*>(m_arr)->verify();	663 ✔
471	break;	663 ✔
472	case Type::big_strings:	5,493 ✔
473	static_cast<ArrayBigBlobs*>(m_arr)->verify();	5,493 ✔
474	break;	5,493 ✔
475	case Type::enum_strings:	246 ✔
476	static_cast<Array*>(m_arr)->verify();	246 ✔
477	break;	246 ✔
478	}	189,876 ✔
479	#endif	189,876 ✔
480	}	189,876 ✔

realm / realm-core / github_pull_request_314032

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