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

realm / realm-core / michael.wilkersonbarker_1325

12 Aug 2024 01:31PM CUT coverage: 91.101% (-0.006%) from 91.107%
michael.wilkersonbarker_1325

Pull #7971

Evergreen

michael-wb
Merge branch 'master' of github.com:realm/realm-core into mwb/no-empty-progress-notifications
Pull Request #7971: RCORE-2235 Upload progress notifications should not be reported after client reset if no local changes to upload

102834 of 181652 branches covered (56.61%)

39 of 39 new or added lines in 2 files covered. (100.0%)

75 existing lines in 8 files now uncovered.

217388 of 238622 relevant lines covered (91.1%)

5688716.04 hits per line

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

88.03
/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)
10,019,103✔
27
{
20,061,399✔
28
    m_arr = new (&m_storage) ArrayStringShort(a, true);
20,061,399✔
29
}
20,061,399✔
30

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

36
void ArrayString::init_from_mem(MemRef mem) noexcept
37
{
12,928,350✔
38
    char* header = mem.get_addr();
12,928,350✔
39

40
    ArrayParent* parent = m_arr->get_parent();
12,928,350✔
41
    size_t ndx_in_parent = m_arr->get_ndx_in_parent();
12,928,350✔
42

43
    bool long_strings = Array::get_hasrefs_from_header(header);
12,928,350✔
44
    if (!long_strings) {
12,928,350✔
45
        // Small strings
46
        bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;
10,126,767✔
47
        if (is_small) {
10,126,767✔
48
            auto arr = new (&m_storage) ArrayStringShort(m_alloc, m_nullable);
6,425,259✔
49
            arr->init_from_mem(mem);
6,425,259✔
50
            m_type = Type::small_strings;
6,425,259✔
51
        }
6,425,259✔
52
        else {
3,701,508✔
53
            auto arr = new (&m_storage) Array(m_alloc);
3,701,508✔
54
            arr->init_from_mem(mem);
3,701,508✔
55
            m_string_enum_values = std::make_unique<ArrayString>(m_alloc);
3,701,508✔
56
            ArrayParent* p;
3,701,508✔
57
            REALM_ASSERT(m_spec != nullptr);
3,701,508✔
58
            REALM_ASSERT(m_col_ndx != realm::npos);
3,701,508✔
59
            ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);
3,701,508✔
60
            m_string_enum_values->init_from_ref(r);
3,701,508✔
61
            m_string_enum_values->set_parent(p, m_col_ndx);
3,701,508✔
62
            m_type = Type::enum_strings;
3,701,508✔
63
        }
3,701,508✔
64
    }
10,126,767✔
65
    else {
2,801,583✔
66
        bool is_big = Array::get_context_flag_from_header(header);
2,801,583✔
67
        if (!is_big) {
2,801,583✔
68
            auto arr = new (&m_storage) ArraySmallBlobs(m_alloc);
702,243✔
69
            arr->init_from_mem(mem);
702,243✔
70
            m_type = Type::medium_strings;
702,243✔
71
        }
702,243✔
72
        else {
2,099,340✔
73
            auto arr = new (&m_storage) ArrayBigBlobs(m_alloc, m_nullable);
2,099,340✔
74
            arr->init_from_mem(mem);
2,099,340✔
75
            m_type = Type::big_strings;
2,099,340✔
76
        }
2,099,340✔
77
    }
2,801,583✔
78
    m_arr->set_parent(parent, ndx_in_parent);
12,928,350✔
79
}
12,928,350✔
80

81
void ArrayString::init_from_parent()
82
{
6,095,835✔
83
    ref_type ref = m_arr->get_ref_from_parent();
6,095,835✔
84
    init_from_ref(ref);
6,095,835✔
85
}
6,095,835✔
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,189,002✔
97
    m_arr->detach();
4,189,002✔
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,189,002✔
101
    m_type = Type::small_strings;
4,189,002✔
102
}
4,189,002✔
103

104
size_t ArrayString::size() const
105
{
16,275,903✔
106
    switch (m_type) {
16,275,903✔
107
        case Type::small_strings:
6,903,000✔
108
            return static_cast<ArrayStringShort*>(m_arr)->size();
6,903,000✔
109
        case Type::medium_strings:
456,135✔
110
            return static_cast<ArraySmallBlobs*>(m_arr)->size();
456,135✔
111
        case Type::big_strings:
8,931,111✔
112
            return static_cast<ArrayBigBlobs*>(m_arr)->size();
8,931,111✔
113
        case Type::enum_strings:
246✔
114
            return static_cast<Array*>(m_arr)->size();
246✔
115
    }
16,275,903✔
116
    return {};
×
117
}
16,275,903✔
118

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

141
void ArrayString::set(size_t ndx, StringData value)
142
{
3,822,489✔
143
    switch (upgrade_leaf(value.size())) {
3,822,489✔
144
        case Type::small_strings:
575,073✔
145
            static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);
575,073✔
146
            break;
575,073✔
147
        case Type::medium_strings:
238,497✔
148
            static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);
238,497✔
149
            break;
238,497✔
150
        case Type::big_strings:
384,825✔
151
            static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);
384,825✔
152
            break;
384,825✔
153
        case Type::enum_strings: {
2,625,759✔
154
            size_t sz = m_string_enum_values->size();
2,625,759✔
155
            size_t res = m_string_enum_values->find_first(value, 0, sz);
2,625,759✔
156
            if (res == realm::not_found) {
2,625,759✔
157
                m_string_enum_values->add(value);
9,639✔
158
                res = sz;
9,639✔
159
            }
9,639✔
160
            static_cast<Array*>(m_arr)->set(ndx, res);
2,625,759✔
161
            break;
2,625,759✔
162
        }
×
163
    }
3,822,489✔
164
}
3,822,489✔
165

166
void ArrayString::insert(size_t ndx, StringData value)
167
{
4,444,410✔
168
    switch (upgrade_leaf(value.size())) {
4,444,410✔
169
        case Type::small_strings:
1,971,021✔
170
            static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);
1,971,021✔
171
            break;
1,971,021✔
172
        case Type::medium_strings:
295,359✔
173
            static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);
295,359✔
174
            break;
295,359✔
175
        case Type::big_strings:
867,162✔
176
            static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);
867,162✔
177
            break;
867,162✔
178
        case Type::enum_strings: {
1,312,854✔
179
            static_cast<Array*>(m_arr)->insert(ndx, 0);
1,312,854✔
180
            set(ndx, value);
1,312,854✔
181
        }
1,312,854✔
182
    }
4,444,410✔
183
}
4,444,410✔
184

185
StringData ArrayString::get(size_t ndx) const
186
{
20,719,908✔
187
    switch (m_type) {
20,719,908✔
188
        case Type::small_strings:
11,046,303✔
189
            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);
11,046,303✔
190
        case Type::medium_strings:
839,694✔
191
            return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);
839,694✔
192
        case Type::big_strings:
7,727,424✔
193
            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);
7,727,424✔
194
        case Type::enum_strings: {
1,144,890✔
195
            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));
1,144,890✔
196
            return m_string_enum_values->get(index);
1,144,890✔
197
        }
×
198
    }
20,719,908✔
199
    return {};
×
200
}
20,719,908✔
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,900✔
221
    return Mixed(get(ndx));
132,900✔
222
}
132,900✔
223

224
bool ArrayString::is_null(size_t ndx) const
225
{
3,865,353✔
226
    switch (m_type) {
3,865,353✔
227
        case Type::small_strings:
537,156✔
228
            return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);
537,156✔
229
        case Type::medium_strings:
16,500✔
230
            return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);
16,500✔
231
        case Type::big_strings:
3,316,008✔
232
            return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);
3,316,008✔
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,865,353✔
238
    return {};
×
239
}
3,865,353✔
240

241
void ArrayString::erase(size_t ndx)
242
{
480,204✔
243
    switch (m_type) {
480,204✔
244
        case Type::small_strings:
388,401✔
245
            static_cast<ArrayStringShort*>(m_arr)->erase(ndx);
388,401✔
246
            break;
388,401✔
247
        case Type::medium_strings:
57,138✔
248
            static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);
57,138✔
249
            break;
57,138✔
250
        case Type::big_strings:
26,289✔
251
            static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);
26,289✔
252
            break;
26,289✔
253
        case Type::enum_strings:
8,445✔
254
            static_cast<Array*>(m_arr)->erase(ndx);
8,445✔
255
            break;
8,445✔
256
    }
480,204✔
257
}
480,204✔
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++) {
115,461✔
263
        dst.add(get(i));
114,387✔
264
    }
114,387✔
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,127,880✔
303
    switch (m_type) {
4,127,880✔
304
        case Type::small_strings:
3,151,119✔
305
            return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);
3,151,119✔
306
        case Type::medium_strings: {
124,866✔
307
            BinaryData as_binary(value.data(), value.size());
124,866✔
308
            return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
124,866✔
309
            break;
×
310
        }
×
311
        case Type::big_strings: {
255,348✔
312
            BinaryData as_binary(value.data(), value.size());
255,348✔
313
            return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);
255,348✔
314
            break;
×
315
        }
×
316
        case Type::enum_strings: {
596,688✔
317
            size_t sz = m_string_enum_values->size();
596,688✔
318
            size_t res = m_string_enum_values->find_first(value, 0, sz);
596,688✔
319
            if (res != realm::not_found) {
596,688✔
320
                return static_cast<Array*>(m_arr)->find_first(res, begin, end);
596,688✔
321
            }
596,688✔
UNCOV
322
            break;
×
323
        }
596,688✔
324
    }
4,127,880✔
325
    return not_found;
×
326
}
4,127,880✔
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;
191,088✔
353
            sz -= half + 1;
191,088✔
354
        }
191,088✔
355
        else {
339,918✔
356
            sz = half;
339,918✔
357
        }
339,918✔
358
    }
531,006✔
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,708,550✔
380
    if (m_type == Type::big_strings)
8,708,550✔
381
        return Type::big_strings;
1,259,406✔
382

383
    if (m_type == Type::enum_strings)
7,449,144✔
384
        return Type::enum_strings;
3,938,496✔
385

386
    if (m_type == Type::medium_strings) {
3,510,648✔
387
        if (value_size <= medium_string_max_size)
532,653✔
388
            return Type::medium_strings;
532,131✔
389

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

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

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

408
        m_type = Type::big_strings;
522✔
409
        return Type::big_strings;
522✔
410
    }
532,653✔
411

412
    // m_type == Type::small
413
    if (value_size <= small_string_max_size)
2,977,995✔
414
        return Type::small_strings;
2,935,488✔
415

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

422
        size_t n = string_short->size();
29,883✔
423
        for (size_t i = 0; i < n; i++) {
51,906✔
424
            string_long.add_string(string_short->get(i)); // Throws
22,023✔
425
        }
22,023✔
426
        auto parent = string_short->get_parent();
29,883✔
427
        auto ndx_in_parent = string_short->get_ndx_in_parent();
29,883✔
428
        string_short->destroy();
29,883✔
429

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

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

443
        size_t n = string_short->size();
12,624✔
444
        for (size_t i = 0; i < n; i++) {
33,054✔
445
            big_blobs.add_string(string_short->get(i)); // Throws
20,430✔
446
        }
20,430✔
447
        auto parent = string_short->get_parent();
12,624✔
448
        auto ndx_in_parent = string_short->get_ndx_in_parent();
12,624✔
449
        string_short->destroy();
12,624✔
450

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

456
        m_type = Type::big_strings;
12,624✔
457
    }
12,624✔
458

459
    return m_type;
42,507✔
460
}
2,977,995✔
461

462
void ArrayString::verify() const
463
{
182,433✔
464
#ifdef REALM_DEBUG
182,433✔
465
    switch (m_type) {
182,433✔
466
        case Type::small_strings:
176,076✔
467
            static_cast<ArrayStringShort*>(m_arr)->verify();
176,076✔
468
            break;
176,076✔
469
        case Type::medium_strings:
786✔
470
            static_cast<ArraySmallBlobs*>(m_arr)->verify();
786✔
471
            break;
786✔
472
        case Type::big_strings:
5,331✔
473
            static_cast<ArrayBigBlobs*>(m_arr)->verify();
5,331✔
474
            break;
5,331✔
475
        case Type::enum_strings:
246✔
476
            static_cast<Array*>(m_arr)->verify();
246✔
477
            break;
246✔
478
    }
182,433✔
479
#endif
182,433✔
480
}
182,433✔
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