• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

realm / realm-core / nicola.cabiddu_1042

27 Sep 2023 06:04PM CUT coverage: 91.085% (-1.8%) from 92.915%
nicola.cabiddu_1042

Pull #6766

Evergreen

nicola-cab
Fix logic for dictionaries
Pull Request #6766: Client Reset for collections in mixed / nested collections

97276 of 178892 branches covered (0.0%)

1994 of 2029 new or added lines in 7 files covered. (98.28%)

4556 existing lines in 112 files now uncovered.

237059 of 260260 relevant lines covered (91.09%)

6321099.55 hits per line

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

85.54
/src/realm/array_string.cpp
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)
27
{
20,300,340✔
28
    m_arr = new (&m_storage.m_string_short) ArrayStringShort(a, true);
20,300,340✔
29
}
20,300,340✔
30

31
void ArrayString::create()
32
{
367,446✔
33
    static_cast<ArrayStringShort*>(m_arr)->create();
367,446✔
34
}
367,446✔
35

36
void ArrayString::init_from_mem(MemRef mem) noexcept
37
{
18,111,522✔
38
    char* header = mem.get_addr();
18,111,522✔
39

9,060,165✔
40
    ArrayParent* parent = m_arr->get_parent();
18,111,522✔
41
    size_t ndx_in_parent = m_arr->get_ndx_in_parent();
18,111,522✔
42

9,060,165✔
43
    bool long_strings = Array::get_hasrefs_from_header(header);
18,111,522✔
44
    if (!long_strings) {
18,111,522✔
45
        // Small strings
6,745,323✔
46
        bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;
13,470,753✔
47
        if (is_small) {
13,470,753✔
48
            auto arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, m_nullable);
7,828,446✔
49
            arr->init_from_mem(mem);
7,828,446✔
50
            m_type = Type::small_strings;
7,828,446✔
51
        }
7,828,446✔
52
        else {
5,642,307✔
53
            auto arr = new (&m_storage.m_enum) Array(m_alloc);
5,642,307✔
54
            arr->init_from_mem(mem);
5,642,307✔
55
            m_string_enum_values = std::make_unique<ArrayString>(m_alloc);
5,642,307✔
56
            ArrayParent* p;
5,642,307✔
57
            REALM_ASSERT(m_spec != nullptr);
5,642,307✔
58
            REALM_ASSERT(m_col_ndx != realm::npos);
5,642,307✔
59
            ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);
5,642,307✔
60
            m_string_enum_values->init_from_ref(r);
5,642,307✔
61
            m_string_enum_values->set_parent(p, m_col_ndx);
5,642,307✔
62
            m_type = Type::enum_strings;
5,642,307✔
63
        }
5,642,307✔
64
    }
13,470,753✔
65
    else {
4,640,769✔
66
        bool is_big = Array::get_context_flag_from_header(header);
4,640,769✔
67
        if (!is_big) {
4,640,769✔
68
            auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);
1,165,254✔
69
            arr->init_from_mem(mem);
1,165,254✔
70
            m_type = Type::medium_strings;
1,165,254✔
71
        }
1,165,254✔
72
        else {
3,475,515✔
73
            auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, m_nullable);
3,475,515✔
74
            arr->init_from_mem(mem);
3,475,515✔
75
            m_type = Type::big_strings;
3,475,515✔
76
        }
3,475,515✔
77
    }
4,640,769✔
78
    m_arr->set_parent(parent, ndx_in_parent);
18,111,522✔
79
}
18,111,522✔
80

81
void ArrayString::init_from_parent()
82
{
5,303,271✔
83
    ref_type ref = m_arr->get_ref_from_parent();
5,303,271✔
84
    init_from_ref(ref);
5,303,271✔
85
}
5,303,271✔
86

87
void ArrayString::destroy() noexcept
88
{
366✔
89
    if (m_arr->is_attached()) {
366✔
90
        Array::destroy_deep(m_arr->get_ref(), m_alloc);
360✔
91
        detach();
360✔
92
    }
360✔
93
}
366✔
94

95
void ArrayString::detach() noexcept
96
{
342,330✔
97
    m_arr->detach();
342,330✔
98
    // Make sure the object is in a state like right after construction
170,835✔
99
    // Next call must be to create()
170,835✔
100
    m_arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, true);
342,330✔
101
    m_type = Type::small_strings;
342,330✔
102
}
342,330✔
103

104
size_t ArrayString::size() const
105
{
15,379,020✔
106
    switch (m_type) {
15,379,020✔
107
        case Type::small_strings:
6,891,549✔
108
            return static_cast<ArrayStringShort*>(m_arr)->size();
6,891,549✔
109
        case Type::medium_strings:
430,725✔
110
            return static_cast<ArraySmallBlobs*>(m_arr)->size();
430,725✔
111
        case Type::big_strings:
8,070,309✔
112
            return static_cast<ArrayBigBlobs*>(m_arr)->size();
8,070,309✔
113
        case Type::enum_strings:
246✔
114
            return static_cast<Array*>(m_arr)->size();
246✔
115
    }
×
116
    return {};
×
117
}
×
118

119
void ArrayString::add(StringData value)
120
{
161,085✔
121
    switch (upgrade_leaf(value.size())) {
161,085✔
122
        case Type::small_strings:
105,717✔
123
            static_cast<ArrayStringShort*>(m_arr)->add(value);
105,717✔
124
            break;
105,717✔
125
        case Type::medium_strings:
27,648✔
126
            static_cast<ArraySmallBlobs*>(m_arr)->add_string(value);
27,648✔
127
            break;
27,648✔
128
        case Type::big_strings:
27,720✔
129
            static_cast<ArrayBigBlobs*>(m_arr)->add_string(value);
27,720✔
130
            break;
27,720✔
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
    }
161,085✔
139
}
161,085✔
140

141
void ArrayString::set(size_t ndx, StringData value)
142
{
3,801,069✔
143
    switch (upgrade_leaf(value.size())) {
3,801,069✔
144
        case Type::small_strings:
520,554✔
145
            static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);
520,554✔
146
            break;
520,554✔
147
        case Type::medium_strings:
246,789✔
148
            static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);
246,789✔
149
            break;
246,789✔
150
        case Type::big_strings:
409,755✔
151
            static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);
409,755✔
152
            break;
409,755✔
153
        case Type::enum_strings: {
2,625,816✔
154
            size_t sz = m_string_enum_values->size();
2,625,816✔
155
            size_t res = m_string_enum_values->find_first(value, 0, sz);
2,625,816✔
156
            if (res == realm::not_found) {
2,625,816✔
157
                m_string_enum_values->add(value);
9,696✔
158
                res = sz;
9,696✔
159
            }
9,696✔
160
            static_cast<Array*>(m_arr)->set(ndx, res);
2,625,816✔
161
            break;
2,625,816✔
162
        }
×
163
    }
3,801,069✔
164
}
3,801,069✔
165

166
void ArrayString::insert(size_t ndx, StringData value)
167
{
3,339,408✔
168
    switch (upgrade_leaf(value.size())) {
3,339,408✔
169
        case Type::small_strings:
1,008,642✔
170
            static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);
1,008,642✔
171
            break;
1,008,642✔
172
        case Type::medium_strings:
281,685✔
173
            static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);
281,685✔
174
            break;
281,685✔
175
        case Type::big_strings:
737,526✔
176
            static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);
737,526✔
177
            break;
737,526✔
178
        case Type::enum_strings: {
1,312,845✔
179
            static_cast<Array*>(m_arr)->insert(ndx, 0);
1,312,845✔
180
            set(ndx, value);
1,312,845✔
181
        }
1,312,845✔
182
    }
3,339,408✔
183
}
3,339,408✔
184

185
StringData ArrayString::get(size_t ndx) const
186
{
22,445,259✔
187
    switch (m_type) {
22,445,259✔
188
        case Type::small_strings:
9,245,634✔
189
            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);
9,245,634✔
190
        case Type::medium_strings:
1,420,698✔
191
            return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);
1,420,698✔
192
        case Type::big_strings:
8,721,309✔
193
            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);
8,721,309✔
194
        case Type::enum_strings: {
3,091,305✔
195
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
3,091,305✔
196
            return m_string_enum_values->get(index);
3,091,305✔
197
        }
×
198
    }
×
199
    return {};
×
200
}
×
201

202
StringData ArrayString::get_legacy(size_t ndx) const
UNCOV
203
{
×
UNCOV
204
    switch (m_type) {
×
UNCOV
205
        case Type::small_strings:
×
UNCOV
206
            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);
×
UNCOV
207
        case Type::medium_strings:
×
UNCOV
208
            return static_cast<ArraySmallBlobs*>(m_arr)->get_string_legacy(ndx);
×
UNCOV
209
        case Type::big_strings:
×
UNCOV
210
            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);
×
UNCOV
211
        case Type::enum_strings: {
×
UNCOV
212
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
×
UNCOV
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,837✔
221
    return Mixed(get(ndx));
132,837✔
222
}
132,837✔
223

224
bool ArrayString::is_null(size_t ndx) const
225
{
3,850,563✔
226
    switch (m_type) {
3,850,563✔
227
        case Type::small_strings:
662,058✔
228
            return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);
662,058✔
229
        case Type::medium_strings:
13,923✔
230
            return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);
13,923✔
231
        case Type::big_strings:
3,178,404✔
232
            return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);
3,178,404✔
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
    }
×
238
    return {};
×
239
}
×
240

241
void ArrayString::erase(size_t ndx)
242
{
184,158✔
243
    switch (m_type) {
184,158✔
244
        case Type::small_strings:
92,424✔
245
            static_cast<ArrayStringShort*>(m_arr)->erase(ndx);
92,424✔
246
            break;
92,424✔
247
        case Type::medium_strings:
58,950✔
248
            static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);
58,950✔
249
            break;
58,950✔
250
        case Type::big_strings:
24,273✔
251
            static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);
24,273✔
252
            break;
24,273✔
253
        case Type::enum_strings:
8,511✔
254
            static_cast<Array*>(m_arr)->erase(ndx);
8,511✔
255
            break;
8,511✔
256
    }
184,158✔
257
}
184,158✔
258

259
void ArrayString::move(ArrayString& dst, size_t ndx)
260
{
66✔
261
    size_t sz = size();
66✔
262
    for (size_t i = ndx; i < sz; i++) {
20,730✔
263
        dst.add(get(i));
20,664✔
264
    }
20,664✔
265

33✔
266
    switch (m_type) {
66✔
267
        case Type::small_strings:
✔
268
            static_cast<ArrayStringShort*>(m_arr)->truncate(ndx);
×
269
            break;
×
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
    }
66✔
281
}
66✔
282

283
void ArrayString::clear()
284
{
375✔
285
    switch (m_type) {
375✔
286
        case Type::small_strings:
321✔
287
            static_cast<ArrayStringShort*>(m_arr)->clear();
321✔
288
            break;
321✔
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
    }
375✔
299
}
375✔
300

301
size_t ArrayString::find_first(StringData value, size_t begin, size_t end) const noexcept
302
{
4,086,819✔
303
    switch (m_type) {
4,086,819✔
304
        case Type::small_strings:
3,130,329✔
305
            return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);
3,130,329✔
306
        case Type::medium_strings: {
104,574✔
307
            BinaryData as_binary(value.data(), value.size());
104,574✔
308
            return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
104,574✔
309
            break;
×
310
        }
×
311
        case Type::big_strings: {
256,173✔
312
            BinaryData as_binary(value.data(), value.size());
256,173✔
313
            return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
256,173✔
314
            break;
×
315
        }
×
316
        case Type::enum_strings: {
596,394✔
317
            size_t sz = m_string_enum_values->size();
596,394✔
318
            size_t res = m_string_enum_values->find_first(value, 0, sz);
596,394✔
319
            if (res != realm::not_found) {
596,394✔
320
                return static_cast<Array*>(m_arr)->find_first(res, begin, end);
596,211✔
321
            }
596,211✔
322
            break;
183✔
323
        }
183✔
324
    }
×
325
    return not_found;
×
326
}
×
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,669✔
339
    return arr->get(ndx);
93,669✔
340
}
93,669✔
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,918✔
348
        size_t half = sz / 2;
531,006✔
349
        size_t mid = i + half;
531,006✔
350
        auto probe = get_string(arr, mid);
531,006✔
351
        if (probe < value) {
531,006✔
352
            i = mid + 1;
190,818✔
353
            sz -= half + 1;
190,818✔
354
        }
190,818✔
355
        else {
340,188✔
356
            sz = half;
340,188✔
357
        }
340,188✔
358
    }
531,006✔
359
    return i;
234,912✔
360
}
234,912✔
361
}
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
    }
×
375
    return realm::npos;
×
376
}
×
377

378
ArrayString::Type ArrayString::upgrade_leaf(size_t value_size)
379
{
7,297,347✔
380
    if (m_type == Type::big_strings)
7,297,347✔
381
        return Type::big_strings;
1,136,820✔
382

3,014,544✔
383
    if (m_type == Type::enum_strings)
6,160,527✔
384
        return Type::enum_strings;
3,938,640✔
385

1,045,140✔
386
    if (m_type == Type::medium_strings) {
2,221,887✔
387
        if (value_size <= medium_string_max_size)
526,917✔
388
            return Type::medium_strings;
526,416✔
389

267✔
390
        // Upgrade root leaf from medium to big strings
267✔
391
        auto string_medium = static_cast<ArraySmallBlobs*>(m_arr);
501✔
392
        ArrayBigBlobs big_blobs(m_alloc, true);
501✔
393
        big_blobs.create(); // Throws
501✔
394

267✔
395
        size_t n = string_medium->size();
501✔
396
        for (size_t i = 0; i < n; i++) {
10,014✔
397
            big_blobs.add_string(string_medium->get_string(i)); // Throws
9,513✔
398
        }
9,513✔
399
        auto parent = string_medium->get_parent();
501✔
400
        auto ndx_in_parent = string_medium->get_ndx_in_parent();
501✔
401
        string_medium->destroy();
501✔
402

267✔
403
        auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);
501✔
404
        arr->init_from_mem(big_blobs.get_mem());
501✔
405
        arr->set_parent(parent, ndx_in_parent);
501✔
406
        arr->update_parent();
501✔
407

267✔
408
        m_type = Type::big_strings;
501✔
409
        return Type::big_strings;
501✔
410
    }
501✔
411

781,401✔
412
    // m_type == Type::small
781,401✔
413
    if (value_size <= small_string_max_size)
1,694,970✔
414
        return Type::small_strings;
1,634,601✔
415

28,992✔
416
    if (value_size <= medium_string_max_size) {
60,369✔
417
        // Upgrade root leaf from small to medium strings
14,532✔
418
        auto string_short = static_cast<ArrayStringShort*>(m_arr);
29,592✔
419
        ArraySmallBlobs string_long(m_alloc);
29,592✔
420
        string_long.create(); // Throws
29,592✔
421

14,532✔
422
        size_t n = string_short->size();
29,592✔
423
        for (size_t i = 0; i < n; i++) {
64,086✔
424
            string_long.add_string(string_short->get(i)); // Throws
34,494✔
425
        }
34,494✔
426
        auto parent = string_short->get_parent();
29,592✔
427
        auto ndx_in_parent = string_short->get_ndx_in_parent();
29,592✔
428
        string_short->destroy();
29,592✔
429

14,532✔
430
        auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);
29,592✔
431
        arr->init_from_mem(string_long.get_mem());
29,592✔
432
        arr->set_parent(parent, ndx_in_parent);
29,592✔
433
        arr->update_parent();
29,592✔
434

14,532✔
435
        m_type = Type::medium_strings;
29,592✔
436
    }
29,592✔
437
    else {
30,777✔
438
        // Upgrade root leaf from small to big strings
14,460✔
439
        auto string_short = static_cast<ArrayStringShort*>(m_arr);
30,777✔
440
        ArrayBigBlobs big_blobs(m_alloc, true);
30,777✔
441
        big_blobs.create(); // Throws
30,777✔
442

14,460✔
443
        size_t n = string_short->size();
30,777✔
444
        for (size_t i = 0; i < n; i++) {
68,778✔
445
            big_blobs.add_string(string_short->get(i)); // Throws
38,001✔
446
        }
38,001✔
447
        auto parent = string_short->get_parent();
30,777✔
448
        auto ndx_in_parent = string_short->get_ndx_in_parent();
30,777✔
449
        string_short->destroy();
30,777✔
450

14,460✔
451
        auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);
30,777✔
452
        arr->init_from_mem(big_blobs.get_mem());
30,777✔
453
        arr->set_parent(parent, ndx_in_parent);
30,777✔
454
        arr->update_parent();
30,777✔
455

14,460✔
456
        m_type = Type::big_strings;
30,777✔
457
    }
30,777✔
458

28,992✔
459
    return m_type;
60,369✔
460
}
60,369✔
461

462
void ArrayString::verify() const
463
{
3,044,562✔
464
#ifdef REALM_DEBUG
3,044,562✔
465
    switch (m_type) {
3,044,562✔
466
        case Type::small_strings:
3,038,193✔
467
            static_cast<ArrayStringShort*>(m_arr)->verify();
3,038,193✔
468
            break;
3,038,193✔
469
        case Type::medium_strings:
720✔
470
            static_cast<ArraySmallBlobs*>(m_arr)->verify();
720✔
471
            break;
720✔
472
        case Type::big_strings:
5,406✔
473
            static_cast<ArrayBigBlobs*>(m_arr)->verify();
5,406✔
474
            break;
5,406✔
475
        case Type::enum_strings:
246✔
476
            static_cast<Array*>(m_arr)->verify();
246✔
477
            break;
246✔
478
    }
3,044,562✔
479
#endif
3,044,562✔
480
}
3,044,562✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc