Coverage Report

Created: 2026-10-27 06:26

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/storage/segment/plain_page.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  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,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#pragma once
19
20
#include "common/cast_set.h"
21
#include "storage/olap_common.h"
22
#include "storage/segment/options.h"
23
#include "storage/segment/page_builder.h"
24
#include "storage/segment/page_decoder.h"
25
#include "storage/storage_layout.h"
26
#include "storage/types.h"
27
#include "util/coding.h"
28
#include "util/faststring.h"
29
#include "util/unaligned.h"
30
31
namespace doris {
32
namespace segment_v2 {
33
34
static const size_t PLAIN_PAGE_HEADER_SIZE = sizeof(uint32_t);
35
36
template <FieldType Type>
37
class PlainPageBuilder : public PageBuilderHelper<PlainPageBuilder<Type>> {
38
public:
39
    using Self = PlainPageBuilder<Type>;
40
    friend class PageBuilderHelper<Self>;
41
42
172k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
172k
        return reset();
46
172k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
42
40.7k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
40.7k
        return reset();
46
40.7k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
42
9.30k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
9.30k
        return reset();
46
9.30k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
42
53.5k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
53.5k
        return reset();
46
53.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
42
39.5k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
39.5k
        return reset();
46
39.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
42
11.6k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
11.6k
        return reset();
46
11.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
42
8.00k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
8.00k
        return reset();
46
8.00k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
42
9.48k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
9.48k
        return reset();
46
9.48k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE4initEv
Line
Count
Source
42
5
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
5
        return reset();
46
5
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE4initEv
Line
Count
Source
42
10
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
10
        return reset();
46
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE4initEv
Line
Count
Source
42
2
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
2
        return reset();
46
2
    }
47
48
812k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE12is_page_fullEv
Line
Count
Source
48
91.5k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE12is_page_fullEv
Line
Count
Source
48
18.1k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE12is_page_fullEv
Line
Count
Source
48
343k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE12is_page_fullEv
Line
Count
Source
48
279k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE12is_page_fullEv
Line
Count
Source
48
22.8k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE12is_page_fullEv
Line
Count
Source
48
14.9k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE12is_page_fullEv
Line
Count
Source
48
40.6k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE12is_page_fullEv
Line
Count
Source
48
391
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE12is_page_fullEv
Line
Count
Source
48
260
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE12is_page_fullEv
Line
Count
Source
48
128
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE12is_page_fullEv
Line
Count
Source
48
168
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
49
50
406k
    Status add(const uint8_t* vals, size_t* count) override {
51
406k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
406k
        size_t old_size = _buffer.size();
56
406k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
406k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
406k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
406k
        _count += to_add;
62
406k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
406k
        *count = to_add;
65
406k
        _remain_element_capacity -= to_add;
66
406k
        return Status::OK();
67
406k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE3addEPKhPm
Line
Count
Source
50
45.7k
    Status add(const uint8_t* vals, size_t* count) override {
51
45.7k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
45.7k
        size_t old_size = _buffer.size();
56
45.7k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
45.7k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
45.7k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
45.7k
        _count += to_add;
62
45.7k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
45.7k
        *count = to_add;
65
45.7k
        _remain_element_capacity -= to_add;
66
45.7k
        return Status::OK();
67
45.7k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE3addEPKhPm
Line
Count
Source
50
9.08k
    Status add(const uint8_t* vals, size_t* count) override {
51
9.08k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
9.08k
        size_t old_size = _buffer.size();
56
9.08k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
9.08k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
9.08k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
9.08k
        _count += to_add;
62
9.08k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
9.08k
        *count = to_add;
65
9.08k
        _remain_element_capacity -= to_add;
66
9.08k
        return Status::OK();
67
9.08k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE3addEPKhPm
Line
Count
Source
50
171k
    Status add(const uint8_t* vals, size_t* count) override {
51
171k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
171k
        size_t old_size = _buffer.size();
56
171k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
171k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
171k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
171k
        _count += to_add;
62
171k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
171k
        *count = to_add;
65
171k
        _remain_element_capacity -= to_add;
66
171k
        return Status::OK();
67
171k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE3addEPKhPm
Line
Count
Source
50
139k
    Status add(const uint8_t* vals, size_t* count) override {
51
139k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
139k
        size_t old_size = _buffer.size();
56
139k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
139k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
139k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
139k
        _count += to_add;
62
139k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
139k
        *count = to_add;
65
139k
        _remain_element_capacity -= to_add;
66
139k
        return Status::OK();
67
139k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE3addEPKhPm
Line
Count
Source
50
11.4k
    Status add(const uint8_t* vals, size_t* count) override {
51
11.4k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
11.4k
        size_t old_size = _buffer.size();
56
11.4k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
11.4k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
11.4k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
11.4k
        _count += to_add;
62
11.4k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
11.4k
        *count = to_add;
65
11.4k
        _remain_element_capacity -= to_add;
66
11.4k
        return Status::OK();
67
11.4k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE3addEPKhPm
Line
Count
Source
50
7.47k
    Status add(const uint8_t* vals, size_t* count) override {
51
7.47k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
7.47k
        size_t old_size = _buffer.size();
56
7.47k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
7.47k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
7.47k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
7.47k
        _count += to_add;
62
7.47k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
7.47k
        *count = to_add;
65
7.47k
        _remain_element_capacity -= to_add;
66
7.47k
        return Status::OK();
67
7.47k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE3addEPKhPm
Line
Count
Source
50
20.3k
    Status add(const uint8_t* vals, size_t* count) override {
51
20.4k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
20.3k
        size_t old_size = _buffer.size();
56
20.3k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
20.3k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
20.4k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
20.4k
        _count += to_add;
62
20.4k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
20.4k
        *count = to_add;
65
20.4k
        _remain_element_capacity -= to_add;
66
20.4k
        return Status::OK();
67
20.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE3addEPKhPm
Line
Count
Source
50
197
    Status add(const uint8_t* vals, size_t* count) override {
51
197
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
197
        size_t old_size = _buffer.size();
56
197
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
197
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
197
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
197
        _count += to_add;
62
197
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
197
        *count = to_add;
65
197
        _remain_element_capacity -= to_add;
66
197
        return Status::OK();
67
197
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE3addEPKhPm
Line
Count
Source
50
131
    Status add(const uint8_t* vals, size_t* count) override {
51
131
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
131
        size_t old_size = _buffer.size();
56
131
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
131
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
131
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
131
        _count += to_add;
62
131
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
131
        *count = to_add;
65
131
        _remain_element_capacity -= to_add;
66
131
        return Status::OK();
67
131
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE3addEPKhPm
Line
Count
Source
50
58
    Status add(const uint8_t* vals, size_t* count) override {
51
58
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
58
        size_t old_size = _buffer.size();
56
58
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
58
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
58
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
58
        _count += to_add;
62
58
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
58
        *count = to_add;
65
58
        _remain_element_capacity -= to_add;
66
58
        return Status::OK();
67
58
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE3addEPKhPm
Line
Count
Source
50
60
    Status add(const uint8_t* vals, size_t* count) override {
51
60
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
60
        size_t old_size = _buffer.size();
56
60
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
60
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
60
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
60
        _count += to_add;
62
60
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
60
        *count = to_add;
65
60
        _remain_element_capacity -= to_add;
66
60
        return Status::OK();
67
60
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE3addEPKhPm
Line
Count
Source
50
60
    Status add(const uint8_t* vals, size_t* count) override {
51
60
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
60
        size_t old_size = _buffer.size();
56
60
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
60
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
60
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
60
        _count += to_add;
62
60
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
60
        *count = to_add;
65
60
        _remain_element_capacity -= to_add;
66
60
        return Status::OK();
67
60
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE3addEPKhPm
Line
Count
Source
50
60
    Status add(const uint8_t* vals, size_t* count) override {
51
60
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
60
        size_t old_size = _buffer.size();
56
60
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
60
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
60
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
60
        _count += to_add;
62
60
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
60
        *count = to_add;
65
60
        _remain_element_capacity -= to_add;
66
60
        return Status::OK();
67
60
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE3addEPKhPm
Line
Count
Source
50
60
    Status add(const uint8_t* vals, size_t* count) override {
51
60
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
60
        size_t old_size = _buffer.size();
56
60
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
60
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
60
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
60
        _count += to_add;
62
60
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
60
        *count = to_add;
65
60
        _remain_element_capacity -= to_add;
66
60
        return Status::OK();
67
60
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE3addEPKhPm
Line
Count
Source
50
64
    Status add(const uint8_t* vals, size_t* count) override {
51
64
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
64
        size_t old_size = _buffer.size();
56
64
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
64
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
64
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
64
        _count += to_add;
62
64
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
64
        *count = to_add;
65
64
        _remain_element_capacity -= to_add;
66
64
        return Status::OK();
67
64
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE3addEPKhPm
Line
Count
Source
50
58
    Status add(const uint8_t* vals, size_t* count) override {
51
58
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
58
        size_t old_size = _buffer.size();
56
58
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
58
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
58
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
58
        _count += to_add;
62
58
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
58
        *count = to_add;
65
58
        _remain_element_capacity -= to_add;
66
58
        return Status::OK();
67
58
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE3addEPKhPm
Line
Count
Source
50
60
    Status add(const uint8_t* vals, size_t* count) override {
51
60
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
60
        size_t old_size = _buffer.size();
56
60
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
60
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
60
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
60
        _count += to_add;
62
60
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
60
        *count = to_add;
65
60
        _remain_element_capacity -= to_add;
66
60
        return Status::OK();
67
60
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE3addEPKhPm
Line
Count
Source
50
68
    Status add(const uint8_t* vals, size_t* count) override {
51
68
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
68
        size_t old_size = _buffer.size();
56
68
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
68
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
68
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
68
        _count += to_add;
62
68
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
68
        *count = to_add;
65
68
        _remain_element_capacity -= to_add;
66
68
        return Status::OK();
67
68
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE3addEPKhPm
Line
Count
Source
50
84
    Status add(const uint8_t* vals, size_t* count) override {
51
84
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
84
        size_t old_size = _buffer.size();
56
84
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
84
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
84
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
84
        _count += to_add;
62
84
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
84
        *count = to_add;
65
84
        _remain_element_capacity -= to_add;
66
84
        return Status::OK();
67
84
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE3addEPKhPm
Line
Count
Source
50
58
    Status add(const uint8_t* vals, size_t* count) override {
51
58
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
58
        size_t old_size = _buffer.size();
56
58
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
58
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
58
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
58
        _count += to_add;
62
58
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
58
        *count = to_add;
65
58
        _remain_element_capacity -= to_add;
66
58
        return Status::OK();
67
58
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE3addEPKhPm
Line
Count
Source
50
68
    Status add(const uint8_t* vals, size_t* count) override {
51
68
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
68
        size_t old_size = _buffer.size();
56
68
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
68
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
68
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
68
        _count += to_add;
62
68
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
68
        *count = to_add;
65
68
        _remain_element_capacity -= to_add;
66
68
        return Status::OK();
67
68
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE3addEPKhPm
Line
Count
Source
50
68
    Status add(const uint8_t* vals, size_t* count) override {
51
68
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
68
        size_t old_size = _buffer.size();
56
68
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
68
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
68
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
68
        _count += to_add;
62
68
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
68
        *count = to_add;
65
68
        _remain_element_capacity -= to_add;
66
68
        return Status::OK();
67
68
    }
68
69
173k
    Status finish(OwnedSlice* slice) override {
70
173k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
173k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
173k
        return Status::OK();
73
173k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
39.2k
    Status finish(OwnedSlice* slice) override {
70
39.2k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
39.2k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
39.2k
        return Status::OK();
73
39.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8.47k
    Status finish(OwnedSlice* slice) override {
70
8.47k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8.47k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8.47k
        return Status::OK();
73
8.47k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
56.2k
    Status finish(OwnedSlice* slice) override {
70
56.2k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
56.2k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
56.2k
        return Status::OK();
73
56.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
41.6k
    Status finish(OwnedSlice* slice) override {
70
41.6k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
41.6k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
41.6k
        return Status::OK();
73
41.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
11.5k
    Status finish(OwnedSlice* slice) override {
70
11.5k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
11.5k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
11.5k
        return Status::OK();
73
11.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
7.22k
    Status finish(OwnedSlice* slice) override {
70
7.22k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
7.22k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
7.22k
        return Status::OK();
73
7.22k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
9.17k
    Status finish(OwnedSlice* slice) override {
70
9.17k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
9.17k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
9.17k
        return Status::OK();
73
9.17k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
9
    Status finish(OwnedSlice* slice) override {
70
9
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
9
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
9
        return Status::OK();
73
9
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
56
    Status finish(OwnedSlice* slice) override {
70
56
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
56
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
56
        return Status::OK();
73
56
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6
    Status finish(OwnedSlice* slice) override {
70
6
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6
        return Status::OK();
73
6
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8
    Status finish(OwnedSlice* slice) override {
70
8
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8
        return Status::OK();
73
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8
    Status finish(OwnedSlice* slice) override {
70
8
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8
        return Status::OK();
73
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8
    Status finish(OwnedSlice* slice) override {
70
8
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8
        return Status::OK();
73
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8
    Status finish(OwnedSlice* slice) override {
70
8
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8
        return Status::OK();
73
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
12
    Status finish(OwnedSlice* slice) override {
70
12
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
12
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
12
        return Status::OK();
73
12
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6
    Status finish(OwnedSlice* slice) override {
70
6
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6
        return Status::OK();
73
6
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8
    Status finish(OwnedSlice* slice) override {
70
8
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8
        return Status::OK();
73
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
16
    Status finish(OwnedSlice* slice) override {
70
16
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
16
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
16
        return Status::OK();
73
16
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
32
    Status finish(OwnedSlice* slice) override {
70
32
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
32
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
32
        return Status::OK();
73
32
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6
    Status finish(OwnedSlice* slice) override {
70
6
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6
        return Status::OK();
73
6
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
16
    Status finish(OwnedSlice* slice) override {
70
16
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
16
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
16
        return Status::OK();
73
16
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
16
    Status finish(OwnedSlice* slice) override {
70
16
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
16
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
16
        return Status::OK();
73
16
    }
74
75
345k
    Status reset() override {
76
345k
        RETURN_IF_CATCH_EXCEPTION({
77
345k
            _buffer.reserve(_options.data_page_size);
78
345k
            _count = 0;
79
345k
            _raw_data_size = 0;
80
345k
            _buffer.clear();
81
345k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
345k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
345k
        });
84
346k
        return Status::OK();
85
345k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5resetEv
Line
Count
Source
75
79.9k
    Status reset() override {
76
79.9k
        RETURN_IF_CATCH_EXCEPTION({
77
79.9k
            _buffer.reserve(_options.data_page_size);
78
79.9k
            _count = 0;
79
79.9k
            _raw_data_size = 0;
80
79.9k
            _buffer.clear();
81
79.9k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
79.9k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
79.9k
        });
84
79.9k
        return Status::OK();
85
79.9k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5resetEv
Line
Count
Source
75
17.7k
    Status reset() override {
76
17.7k
        RETURN_IF_CATCH_EXCEPTION({
77
17.7k
            _buffer.reserve(_options.data_page_size);
78
17.7k
            _count = 0;
79
17.7k
            _raw_data_size = 0;
80
17.7k
            _buffer.clear();
81
17.7k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
17.7k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
17.7k
        });
84
17.7k
        return Status::OK();
85
17.7k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5resetEv
Line
Count
Source
75
109k
    Status reset() override {
76
109k
        RETURN_IF_CATCH_EXCEPTION({
77
109k
            _buffer.reserve(_options.data_page_size);
78
109k
            _count = 0;
79
109k
            _raw_data_size = 0;
80
109k
            _buffer.clear();
81
109k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
109k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
109k
        });
84
110k
        return Status::OK();
85
109k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5resetEv
Line
Count
Source
75
81.0k
    Status reset() override {
76
81.0k
        RETURN_IF_CATCH_EXCEPTION({
77
81.0k
            _buffer.reserve(_options.data_page_size);
78
81.0k
            _count = 0;
79
81.0k
            _raw_data_size = 0;
80
81.0k
            _buffer.clear();
81
81.0k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
81.0k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
81.0k
        });
84
81.4k
        return Status::OK();
85
81.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5resetEv
Line
Count
Source
75
23.1k
    Status reset() override {
76
23.1k
        RETURN_IF_CATCH_EXCEPTION({
77
23.1k
            _buffer.reserve(_options.data_page_size);
78
23.1k
            _count = 0;
79
23.1k
            _raw_data_size = 0;
80
23.1k
            _buffer.clear();
81
23.1k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
23.1k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
23.1k
        });
84
23.2k
        return Status::OK();
85
23.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5resetEv
Line
Count
Source
75
15.2k
    Status reset() override {
76
15.2k
        RETURN_IF_CATCH_EXCEPTION({
77
15.2k
            _buffer.reserve(_options.data_page_size);
78
15.2k
            _count = 0;
79
15.2k
            _raw_data_size = 0;
80
15.2k
            _buffer.clear();
81
15.2k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
15.2k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
15.2k
        });
84
15.2k
        return Status::OK();
85
15.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5resetEv
Line
Count
Source
75
18.6k
    Status reset() override {
76
18.6k
        RETURN_IF_CATCH_EXCEPTION({
77
18.6k
            _buffer.reserve(_options.data_page_size);
78
18.6k
            _count = 0;
79
18.6k
            _raw_data_size = 0;
80
18.6k
            _buffer.clear();
81
18.6k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18.6k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18.6k
        });
84
18.6k
        return Status::OK();
85
18.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE5resetEv
Line
Count
Source
75
11
    Status reset() override {
76
11
        RETURN_IF_CATCH_EXCEPTION({
77
11
            _buffer.reserve(_options.data_page_size);
78
11
            _count = 0;
79
11
            _raw_data_size = 0;
80
11
            _buffer.clear();
81
11
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
11
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
11
        });
84
11
        return Status::OK();
85
11
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE5resetEv
Line
Count
Source
75
64
    Status reset() override {
76
64
        RETURN_IF_CATCH_EXCEPTION({
77
64
            _buffer.reserve(_options.data_page_size);
78
64
            _count = 0;
79
64
            _raw_data_size = 0;
80
64
            _buffer.clear();
81
64
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
64
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
64
        });
84
64
        return Status::OK();
85
64
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE5resetEv
Line
Count
Source
75
14
    Status reset() override {
76
14
        RETURN_IF_CATCH_EXCEPTION({
77
14
            _buffer.reserve(_options.data_page_size);
78
14
            _count = 0;
79
14
            _raw_data_size = 0;
80
14
            _buffer.clear();
81
14
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
14
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
14
        });
84
14
        return Status::OK();
85
14
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE5resetEv
Line
Count
Source
75
34
    Status reset() override {
76
34
        RETURN_IF_CATCH_EXCEPTION({
77
34
            _buffer.reserve(_options.data_page_size);
78
34
            _count = 0;
79
34
            _raw_data_size = 0;
80
34
            _buffer.clear();
81
34
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
34
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
34
        });
84
34
        return Status::OK();
85
34
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
86
87
32
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5countEv
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5countEv
Line
Count
Source
87
5
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE5countEv
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE5countEv
Line
Count
Source
87
27
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE5countEv
88
89
11.8k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4sizeEv
Line
Count
Source
89
1.75k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4sizeEv
Line
Count
Source
89
763
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4sizeEv
Line
Count
Source
89
4.39k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4sizeEv
Line
Count
Source
89
2.75k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4sizeEv
Line
Count
Source
89
1.07k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4sizeEv
Line
Count
Source
89
544
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4sizeEv
Line
Count
Source
89
545
    uint64_t size() const override { return _buffer.size(); }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE4sizeEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE4sizeEv
90
91
173k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE17get_raw_data_sizeEv
Line
Count
Source
91
39.2k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE17get_raw_data_sizeEv
Line
Count
Source
91
8.47k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE17get_raw_data_sizeEv
Line
Count
Source
91
56.1k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE17get_raw_data_sizeEv
Line
Count
Source
91
41.6k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE17get_raw_data_sizeEv
Line
Count
Source
91
11.5k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE17get_raw_data_sizeEv
Line
Count
Source
91
7.22k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE17get_raw_data_sizeEv
Line
Count
Source
91
9.17k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE17get_raw_data_sizeEv
Line
Count
Source
91
6
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE17get_raw_data_sizeEv
Line
Count
Source
91
30
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE17get_raw_data_sizeEv
Line
Count
Source
91
6
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE17get_raw_data_sizeEv
Line
Count
Source
91
8
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE17get_raw_data_sizeEv
Line
Count
Source
91
8
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE17get_raw_data_sizeEv
Line
Count
Source
91
8
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE17get_raw_data_sizeEv
Line
Count
Source
91
8
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE17get_raw_data_sizeEv
Line
Count
Source
91
12
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE17get_raw_data_sizeEv
Line
Count
Source
91
6
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE17get_raw_data_sizeEv
Line
Count
Source
91
8
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE17get_raw_data_sizeEv
Line
Count
Source
91
16
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE17get_raw_data_sizeEv
Line
Count
Source
91
32
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE17get_raw_data_sizeEv
Line
Count
Source
91
6
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE17get_raw_data_sizeEv
Line
Count
Source
91
16
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE17get_raw_data_sizeEv
Line
Count
Source
91
16
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
92
93
private:
94
171k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
40.7k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
9.30k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
53.2k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
39.3k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
11.6k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
7.99k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
9.48k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
5
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
10
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
2
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
95
96
    faststring _buffer;
97
    PageBuilderOptions _options;
98
    size_t _count;
99
    size_t _remain_element_capacity {0};
100
    uint64_t _raw_data_size = 0;
101
    typedef typename TypeTraits<Type>::CppType CppType;
102
    static constexpr size_t SIZE_OF_TYPE = TypeTraits<Type>::size;
103
};
104
105
template <FieldType Type>
106
class PlainPageDecoder : public PageDecoder {
107
public:
108
    PlainPageDecoder(Slice data, const PageDecoderOptions& options)
109
342k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
70.7k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
19.5k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
150k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
51.1k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
19.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
14.0k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
17.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
9
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
12
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
32
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
110
111
342k
    Status init() override {
112
342k
        CHECK(!_parsed);
113
114
342k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
342k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
342k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
342k
        _parsed = true;
128
129
342k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
342k
        return Status::OK();
131
342k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
111
70.7k
    Status init() override {
112
70.7k
        CHECK(!_parsed);
113
114
70.7k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
70.7k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
70.7k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
70.7k
        _parsed = true;
128
129
70.7k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
70.7k
        return Status::OK();
131
70.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
111
19.5k
    Status init() override {
112
19.5k
        CHECK(!_parsed);
113
114
19.5k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
19.5k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
19.5k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
19.5k
        _parsed = true;
128
129
19.5k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
19.5k
        return Status::OK();
131
19.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
111
150k
    Status init() override {
112
150k
        CHECK(!_parsed);
113
114
150k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
150k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
150k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
150k
        _parsed = true;
128
129
150k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
150k
        return Status::OK();
131
150k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
111
51.1k
    Status init() override {
112
51.1k
        CHECK(!_parsed);
113
114
51.1k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
51.1k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
51.1k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
51.1k
        _parsed = true;
128
129
51.1k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
51.1k
        return Status::OK();
131
51.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
111
19.2k
    Status init() override {
112
19.2k
        CHECK(!_parsed);
113
114
19.2k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
19.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
19.2k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
19.2k
        _parsed = true;
128
129
19.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
19.2k
        return Status::OK();
131
19.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
111
14.0k
    Status init() override {
112
14.0k
        CHECK(!_parsed);
113
114
14.0k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
14.0k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
14.0k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
14.0k
        _parsed = true;
128
129
14.0k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
14.0k
        return Status::OK();
131
14.0k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
111
17.2k
    Status init() override {
112
17.2k
        CHECK(!_parsed);
113
114
17.2k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
17.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
17.2k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
17.2k
        _parsed = true;
128
129
17.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
17.2k
        return Status::OK();
131
17.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE4initEv
Line
Count
Source
111
9
    Status init() override {
112
9
        CHECK(!_parsed);
113
114
9
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
9
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
9
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
9
        _parsed = true;
128
129
9
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
9
        return Status::OK();
131
9
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE4initEv
Line
Count
Source
111
12
    Status init() override {
112
12
        CHECK(!_parsed);
113
114
12
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
12
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
12
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
12
        _parsed = true;
128
129
12
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
12
        return Status::OK();
131
12
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE4initEv
Line
Count
Source
111
32
    Status init() override {
112
32
        CHECK(!_parsed);
113
114
32
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
32
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
32
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
32
        _parsed = true;
128
129
32
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
32
        return Status::OK();
131
32
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
132
133
2.27M
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
2.27M
        if (_num_elems == 0) [[unlikely]] {
136
10.6k
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
10.6k
        }
141
142
2.27M
        DCHECK_LE(pos, _num_elems);
143
144
2.27M
        _cur_idx = cast_set<uint32_t>(pos);
145
2.27M
        return Status::OK();
146
2.27M
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE24seek_to_position_in_pageEm
Line
Count
Source
133
336k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
336k
        if (_num_elems == 0) [[unlikely]] {
136
1.26k
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
1.26k
        }
141
142
336k
        DCHECK_LE(pos, _num_elems);
143
144
336k
        _cur_idx = cast_set<uint32_t>(pos);
145
336k
        return Status::OK();
146
336k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE24seek_to_position_in_pageEm
Line
Count
Source
133
249k
    Status seek_to_position_in_page(size_t pos) override {
134
249k
        CHECK(_parsed) << "Must call init()";
135
249k
        if (_num_elems == 0) [[unlikely]] {
136
677
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
677
        }
141
142
249k
        DCHECK_LE(pos, _num_elems);
143
144
249k
        _cur_idx = cast_set<uint32_t>(pos);
145
249k
        return Status::OK();
146
249k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE24seek_to_position_in_pageEm
Line
Count
Source
133
840k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
840k
        if (_num_elems == 0) [[unlikely]] {
136
4.40k
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
4.40k
        }
141
142
840k
        DCHECK_LE(pos, _num_elems);
143
144
840k
        _cur_idx = cast_set<uint32_t>(pos);
145
840k
        return Status::OK();
146
840k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE24seek_to_position_in_pageEm
Line
Count
Source
133
250k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
250k
        if (_num_elems == 0) [[unlikely]] {
136
2.87k
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
2.87k
        }
141
142
250k
        DCHECK_LE(pos, _num_elems);
143
144
250k
        _cur_idx = cast_set<uint32_t>(pos);
145
250k
        return Status::OK();
146
250k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE24seek_to_position_in_pageEm
Line
Count
Source
133
130k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
130k
        if (_num_elems == 0) [[unlikely]] {
136
543
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
543
        }
141
142
130k
        DCHECK_LE(pos, _num_elems);
143
144
130k
        _cur_idx = cast_set<uint32_t>(pos);
145
130k
        return Status::OK();
146
130k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE24seek_to_position_in_pageEm
Line
Count
Source
133
247k
    Status seek_to_position_in_page(size_t pos) override {
134
247k
        CHECK(_parsed) << "Must call init()";
135
247k
        if (_num_elems == 0) [[unlikely]] {
136
401
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
401
        }
141
142
247k
        DCHECK_LE(pos, _num_elems);
143
144
247k
        _cur_idx = cast_set<uint32_t>(pos);
145
247k
        return Status::OK();
146
247k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE24seek_to_position_in_pageEm
Line
Count
Source
133
223k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
223k
        if (_num_elems == 0) [[unlikely]] {
136
453
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
453
        }
141
142
223k
        DCHECK_LE(pos, _num_elems);
143
144
223k
        _cur_idx = cast_set<uint32_t>(pos);
145
223k
        return Status::OK();
146
223k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE24seek_to_position_in_pageEm
Line
Count
Source
133
103
    Status seek_to_position_in_page(size_t pos) override {
134
103
        CHECK(_parsed) << "Must call init()";
135
103
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
103
        DCHECK_LE(pos, _num_elems);
143
144
103
        _cur_idx = cast_set<uint32_t>(pos);
145
103
        return Status::OK();
146
103
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE24seek_to_position_in_pageEm
Line
Count
Source
133
45
    Status seek_to_position_in_page(size_t pos) override {
134
45
        CHECK(_parsed) << "Must call init()";
135
45
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
45
        DCHECK_LE(pos, _num_elems);
143
144
45
        _cur_idx = cast_set<uint32_t>(pos);
145
45
        return Status::OK();
146
45
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE24seek_to_position_in_pageEm
Line
Count
Source
133
39
    Status seek_to_position_in_page(size_t pos) override {
134
39
        CHECK(_parsed) << "Must call init()";
135
39
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
39
        DCHECK_LE(pos, _num_elems);
143
144
39
        _cur_idx = cast_set<uint32_t>(pos);
145
39
        return Status::OK();
146
39
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE24seek_to_position_in_pageEm
Line
Count
Source
133
69
    Status seek_to_position_in_page(size_t pos) override {
134
69
        CHECK(_parsed) << "Must call init()";
135
69
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
69
        DCHECK_LE(pos, _num_elems);
143
144
69
        _cur_idx = cast_set<uint32_t>(pos);
145
69
        return Status::OK();
146
69
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
147
148
21
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
21
        DCHECK(_parsed) << "Must call init() firstly";
150
151
21
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
21
        uint32_t left = 0;
156
21
        uint32_t right = _num_elems;
157
158
21
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
133
        while (left < right) {
164
112
            uint32_t mid = left + (right - left) / 2;
165
112
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
112
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
52
                left = mid + 1;
168
60
            } else {
169
60
                right = mid;
170
60
            }
171
112
        }
172
21
        if (left >= _num_elems) {
173
3
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
3
        }
175
18
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
18
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
15
            *exact_match = true;
178
15
        } else {
179
3
            *exact_match = false;
180
3
        }
181
182
18
        _cur_idx = left;
183
18
        return Status::OK();
184
21
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE22seek_at_or_after_valueEPKvPb
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
5
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
5
        DCHECK(_parsed) << "Must call init() firstly";
150
151
5
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
5
        uint32_t left = 0;
156
5
        uint32_t right = _num_elems;
157
158
5
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
54
        while (left < right) {
164
49
            uint32_t mid = left + (right - left) / 2;
165
49
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
49
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
24
                left = mid + 1;
168
25
            } else {
169
25
                right = mid;
170
25
            }
171
49
        }
172
5
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
4
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
4
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
3
            *exact_match = true;
178
3
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
4
        _cur_idx = left;
183
4
        return Status::OK();
184
5
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
5
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
5
        DCHECK(_parsed) << "Must call init() firstly";
150
151
5
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
5
        uint32_t left = 0;
156
5
        uint32_t right = _num_elems;
157
158
5
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
54
        while (left < right) {
164
49
            uint32_t mid = left + (right - left) / 2;
165
49
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
49
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
25
                left = mid + 1;
168
25
            } else {
169
24
                right = mid;
170
24
            }
171
49
        }
172
5
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
4
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
4
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
3
            *exact_match = true;
178
3
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
4
        _cur_idx = left;
183
4
        return Status::OK();
184
5
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE22seek_at_or_after_valueEPKvPb
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
11
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
11
        DCHECK(_parsed) << "Must call init() firstly";
150
151
11
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
11
        uint32_t left = 0;
156
11
        uint32_t right = _num_elems;
157
158
11
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
25
        while (left < right) {
164
14
            uint32_t mid = left + (right - left) / 2;
165
14
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
14
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
3
                left = mid + 1;
168
11
            } else {
169
11
                right = mid;
170
11
            }
171
14
        }
172
11
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
10
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
10
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
9
            *exact_match = true;
178
9
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
10
        _cur_idx = left;
183
10
        return Status::OK();
184
11
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE22seek_at_or_after_valueEPKvPb
185
186
782k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
782k
        DCHECK(_parsed);
188
782k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
782k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
782k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
782k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
782k
                                               *dst);
197
198
782k
        *n = max_fetch;
199
782k
        _cur_idx += max_fetch;
200
201
782k
        return Status::OK();
202
782k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
82.3k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
82.3k
        DCHECK(_parsed);
188
82.3k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
82.3k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
82.3k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
82.3k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
82.3k
                                               *dst);
197
198
82.3k
        *n = max_fetch;
199
82.3k
        _cur_idx += max_fetch;
200
201
82.3k
        return Status::OK();
202
82.3k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
13.7k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
13.7k
        DCHECK(_parsed);
188
13.7k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
13.7k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
13.7k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
13.7k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
13.7k
                                               *dst);
197
198
13.7k
        *n = max_fetch;
199
13.7k
        _cur_idx += max_fetch;
200
201
13.7k
        return Status::OK();
202
13.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
554k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
554k
        DCHECK(_parsed);
188
554k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
554k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
554k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
554k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
554k
                                               *dst);
197
198
554k
        *n = max_fetch;
199
554k
        _cur_idx += max_fetch;
200
201
554k
        return Status::OK();
202
554k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
72.1k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
72.1k
        DCHECK(_parsed);
188
72.1k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
72.1k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
72.1k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
72.1k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
72.1k
                                               *dst);
197
198
72.1k
        *n = max_fetch;
199
72.1k
        _cur_idx += max_fetch;
200
201
72.1k
        return Status::OK();
202
72.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
13.2k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
13.2k
        DCHECK(_parsed);
188
13.2k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
13.2k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
13.2k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
13.2k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
13.2k
                                               *dst);
197
198
13.2k
        *n = max_fetch;
199
13.2k
        _cur_idx += max_fetch;
200
201
13.2k
        return Status::OK();
202
13.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
7.52k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
7.52k
        DCHECK(_parsed);
188
7.52k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
7.52k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
7.52k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
7.52k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
7.52k
                                               *dst);
197
198
7.52k
        *n = max_fetch;
199
7.52k
        _cur_idx += max_fetch;
200
201
7.52k
        return Status::OK();
202
7.52k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
38.5k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
38.5k
        DCHECK(_parsed);
188
38.5k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
38.5k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
38.5k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
38.5k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
38.5k
                                               *dst);
197
198
38.5k
        *n = max_fetch;
199
38.5k
        _cur_idx += max_fetch;
200
201
38.5k
        return Status::OK();
202
38.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
93
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
93
        DCHECK(_parsed);
188
93
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
93
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
93
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
93
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
93
                                               *dst);
197
198
93
        *n = max_fetch;
199
93
        _cur_idx += max_fetch;
200
201
93
        return Status::OK();
202
93
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
35
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
35
        DCHECK(_parsed);
188
35
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
35
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
35
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
35
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
35
                                               *dst);
197
198
35
        *n = max_fetch;
199
35
        _cur_idx += max_fetch;
200
201
35
        return Status::OK();
202
35
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
28
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
28
        DCHECK(_parsed);
188
28
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
28
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
28
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
28
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
28
                                               *dst);
197
198
28
        *n = max_fetch;
199
28
        _cur_idx += max_fetch;
200
201
28
        return Status::OK();
202
28
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
30
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
30
        DCHECK(_parsed);
188
30
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
30
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
30
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
30
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
30
                                               *dst);
197
198
30
        *n = max_fetch;
199
30
        _cur_idx += max_fetch;
200
201
30
        return Status::OK();
202
30
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
38
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
38
        DCHECK(_parsed);
188
38
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
38
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
38
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
38
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
38
                                               *dst);
197
198
38
        *n = max_fetch;
199
38
        _cur_idx += max_fetch;
200
201
38
        return Status::OK();
202
38
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
26
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
26
        DCHECK(_parsed);
188
26
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
26
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
26
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
26
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
26
                                               *dst);
197
198
26
        *n = max_fetch;
199
26
        _cur_idx += max_fetch;
200
201
26
        return Status::OK();
202
26
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
30
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
30
        DCHECK(_parsed);
188
30
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
30
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
30
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
30
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
30
                                               *dst);
197
198
30
        *n = max_fetch;
199
30
        _cur_idx += max_fetch;
200
201
30
        return Status::OK();
202
30
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
30
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
30
        DCHECK(_parsed);
188
30
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
30
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
30
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
30
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
30
                                               *dst);
197
198
30
        *n = max_fetch;
199
30
        _cur_idx += max_fetch;
200
201
30
        return Status::OK();
202
30
    }
203
204
    Status read_by_rowids(const rowid_t* rowids, ordinal_t page_first_ordinal, size_t* n,
205
257k
                          MutableColumnPtr& dst) override {
206
257k
        DCHECK(_parsed);
207
257k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
257k
        auto total = *n;
212
257k
        auto read_count = 0;
213
257k
        _buffer.resize(total);
214
39.0M
        for (size_t i = 0; i < total; ++i) {
215
38.8M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
38.8M
            if (UNLIKELY(ord >= _num_elems)) {
217
3.76k
                break;
218
3.76k
            }
219
220
38.8M
            _buffer[read_count++] =
221
38.8M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
38.8M
        }
223
224
257k
        if (LIKELY(read_count > 0)) {
225
257k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
257k
                                                   read_count, *dst);
227
257k
        }
228
229
257k
        *n = read_count;
230
257k
        return Status::OK();
231
257k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
35.7k
                          MutableColumnPtr& dst) override {
206
35.7k
        DCHECK(_parsed);
207
35.7k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
35.7k
        auto total = *n;
212
35.7k
        auto read_count = 0;
213
35.7k
        _buffer.resize(total);
214
1.37M
        for (size_t i = 0; i < total; ++i) {
215
1.34M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.34M
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
1.34M
            _buffer[read_count++] =
221
1.34M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.34M
        }
223
224
35.7k
        if (LIKELY(read_count > 0)) {
225
35.7k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
35.7k
                                                   read_count, *dst);
227
35.7k
        }
228
229
35.7k
        *n = read_count;
230
35.7k
        return Status::OK();
231
35.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
10.1k
                          MutableColumnPtr& dst) override {
206
10.1k
        DCHECK(_parsed);
207
10.1k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
10.1k
        auto total = *n;
212
10.1k
        auto read_count = 0;
213
10.1k
        _buffer.resize(total);
214
663k
        for (size_t i = 0; i < total; ++i) {
215
653k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
653k
            if (UNLIKELY(ord >= _num_elems)) {
217
14
                break;
218
14
            }
219
220
653k
            _buffer[read_count++] =
221
653k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
653k
        }
223
224
10.1k
        if (LIKELY(read_count > 0)) {
225
10.1k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
10.1k
                                                   read_count, *dst);
227
10.1k
        }
228
229
10.1k
        *n = read_count;
230
10.1k
        return Status::OK();
231
10.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
71.5k
                          MutableColumnPtr& dst) override {
206
71.5k
        DCHECK(_parsed);
207
71.5k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
71.5k
        auto total = *n;
212
71.5k
        auto read_count = 0;
213
71.5k
        _buffer.resize(total);
214
14.5M
        for (size_t i = 0; i < total; ++i) {
215
14.5M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
14.5M
            if (UNLIKELY(ord >= _num_elems)) {
217
1.64k
                break;
218
1.64k
            }
219
220
14.5M
            _buffer[read_count++] =
221
14.5M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
14.5M
        }
223
224
71.5k
        if (LIKELY(read_count > 0)) {
225
71.5k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
71.5k
                                                   read_count, *dst);
227
71.5k
        }
228
229
71.5k
        *n = read_count;
230
71.5k
        return Status::OK();
231
71.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
111k
                          MutableColumnPtr& dst) override {
206
111k
        DCHECK(_parsed);
207
111k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
111k
        auto total = *n;
212
111k
        auto read_count = 0;
213
111k
        _buffer.resize(total);
214
17.5M
        for (size_t i = 0; i < total; ++i) {
215
17.4M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
17.4M
            if (UNLIKELY(ord >= _num_elems)) {
217
1.15k
                break;
218
1.15k
            }
219
220
17.4M
            _buffer[read_count++] =
221
17.4M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
17.4M
        }
223
224
111k
        if (LIKELY(read_count > 0)) {
225
111k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
111k
                                                   read_count, *dst);
227
111k
        }
228
229
111k
        *n = read_count;
230
111k
        return Status::OK();
231
111k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
9.58k
                          MutableColumnPtr& dst) override {
206
9.58k
        DCHECK(_parsed);
207
9.58k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
9.58k
        auto total = *n;
212
9.58k
        auto read_count = 0;
213
9.58k
        _buffer.resize(total);
214
1.66M
        for (size_t i = 0; i < total; ++i) {
215
1.65M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.65M
            if (UNLIKELY(ord >= _num_elems)) {
217
549
                break;
218
549
            }
219
220
1.65M
            _buffer[read_count++] =
221
1.65M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.65M
        }
223
224
9.58k
        if (LIKELY(read_count > 0)) {
225
9.58k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
9.58k
                                                   read_count, *dst);
227
9.58k
        }
228
229
9.58k
        *n = read_count;
230
9.58k
        return Status::OK();
231
9.58k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
8.05k
                          MutableColumnPtr& dst) override {
206
8.05k
        DCHECK(_parsed);
207
8.05k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
8.05k
        auto total = *n;
212
8.05k
        auto read_count = 0;
213
8.05k
        _buffer.resize(total);
214
1.22M
        for (size_t i = 0; i < total; ++i) {
215
1.21M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.21M
            if (UNLIKELY(ord >= _num_elems)) {
217
32
                break;
218
32
            }
219
220
1.21M
            _buffer[read_count++] =
221
1.21M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.21M
        }
223
224
8.05k
        if (LIKELY(read_count > 0)) {
225
8.04k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
8.04k
                                                   read_count, *dst);
227
8.04k
        }
228
229
8.05k
        *n = read_count;
230
8.05k
        return Status::OK();
231
8.05k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
9.99k
                          MutableColumnPtr& dst) override {
206
9.99k
        DCHECK(_parsed);
207
9.99k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
9.99k
        auto total = *n;
212
9.99k
        auto read_count = 0;
213
9.99k
        _buffer.resize(total);
214
2.01M
        for (size_t i = 0; i < total; ++i) {
215
2.00M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
2.00M
            if (UNLIKELY(ord >= _num_elems)) {
217
348
                break;
218
348
            }
219
220
2.00M
            _buffer[read_count++] =
221
2.00M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
2.00M
        }
223
224
9.99k
        if (LIKELY(read_count > 0)) {
225
9.99k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
9.99k
                                                   read_count, *dst);
227
9.99k
        }
228
229
9.99k
        *n = read_count;
230
9.99k
        return Status::OK();
231
9.99k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
93
                          MutableColumnPtr& dst) override {
206
93
        DCHECK(_parsed);
207
93
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
93
        auto total = *n;
212
93
        auto read_count = 0;
213
93
        _buffer.resize(total);
214
803
        for (size_t i = 0; i < total; ++i) {
215
710
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
710
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
710
            _buffer[read_count++] =
221
710
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
710
        }
223
224
93
        if (LIKELY(read_count > 0)) {
225
93
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
93
                                                   read_count, *dst);
227
93
        }
228
229
93
        *n = read_count;
230
93
        return Status::OK();
231
93
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
36
                          MutableColumnPtr& dst) override {
206
36
        DCHECK(_parsed);
207
36
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
36
        auto total = *n;
212
36
        auto read_count = 0;
213
36
        _buffer.resize(total);
214
277
        for (size_t i = 0; i < total; ++i) {
215
241
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
241
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
241
            _buffer[read_count++] =
221
241
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
241
        }
223
224
36
        if (LIKELY(read_count > 0)) {
225
36
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
36
                                                   read_count, *dst);
227
36
        }
228
229
36
        *n = read_count;
230
36
        return Status::OK();
231
36
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
206
        for (size_t i = 0; i < total; ++i) {
215
179
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
179
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
179
            _buffer[read_count++] =
221
179
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
179
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
194
        for (size_t i = 0; i < total; ++i) {
215
168
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
168
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
194
        for (size_t i = 0; i < total; ++i) {
215
168
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
168
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
194
        for (size_t i = 0; i < total; ++i) {
215
168
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
168
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
194
        for (size_t i = 0; i < total; ++i) {
215
168
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
168
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
28
                          MutableColumnPtr& dst) override {
206
28
        DCHECK(_parsed);
207
28
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
28
        auto total = *n;
212
28
        auto read_count = 0;
213
28
        _buffer.resize(total);
214
195
        for (size_t i = 0; i < total; ++i) {
215
169
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
169
            if (UNLIKELY(ord >= _num_elems)) {
217
2
                break;
218
2
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
28
        if (LIKELY(read_count > 0)) {
225
28
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
28
                                                   read_count, *dst);
227
28
        }
228
229
28
        *n = read_count;
230
28
        return Status::OK();
231
28
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
206
        for (size_t i = 0; i < total; ++i) {
215
179
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
179
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
179
            _buffer[read_count++] =
221
179
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
179
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
194
        for (size_t i = 0; i < total; ++i) {
215
168
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
168
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
31
                          MutableColumnPtr& dst) override {
206
31
        DCHECK(_parsed);
207
31
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
31
        auto total = *n;
212
31
        auto read_count = 0;
213
31
        _buffer.resize(total);
214
198
        for (size_t i = 0; i < total; ++i) {
215
170
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
170
            if (UNLIKELY(ord >= _num_elems)) {
217
3
                break;
218
3
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
31
        if (LIKELY(read_count > 0)) {
225
31
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
31
                                                   read_count, *dst);
227
31
        }
228
229
31
        *n = read_count;
230
31
        return Status::OK();
231
31
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
38
                          MutableColumnPtr& dst) override {
206
38
        DCHECK(_parsed);
207
38
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
38
        auto total = *n;
212
38
        auto read_count = 0;
213
38
        _buffer.resize(total);
214
205
        for (size_t i = 0; i < total; ++i) {
215
173
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
173
            if (UNLIKELY(ord >= _num_elems)) {
217
6
                break;
218
6
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
38
        if (LIKELY(read_count > 0)) {
225
38
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
38
                                                   read_count, *dst);
227
38
        }
228
229
38
        *n = read_count;
230
38
        return Status::OK();
231
38
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
27
                          MutableColumnPtr& dst) override {
206
27
        DCHECK(_parsed);
207
27
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
27
        auto total = *n;
212
27
        auto read_count = 0;
213
27
        _buffer.resize(total);
214
206
        for (size_t i = 0; i < total; ++i) {
215
179
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
179
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
179
            _buffer[read_count++] =
221
179
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
179
        }
223
224
27
        if (LIKELY(read_count > 0)) {
225
27
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
27
                                                   read_count, *dst);
227
27
        }
228
229
27
        *n = read_count;
230
27
        return Status::OK();
231
27
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
31
                          MutableColumnPtr& dst) override {
206
31
        DCHECK(_parsed);
207
31
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
31
        auto total = *n;
212
31
        auto read_count = 0;
213
31
        _buffer.resize(total);
214
198
        for (size_t i = 0; i < total; ++i) {
215
170
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
170
            if (UNLIKELY(ord >= _num_elems)) {
217
3
                break;
218
3
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
31
        if (LIKELY(read_count > 0)) {
225
31
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
31
                                                   read_count, *dst);
227
31
        }
228
229
31
        *n = read_count;
230
31
        return Status::OK();
231
31
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
31
                          MutableColumnPtr& dst) override {
206
31
        DCHECK(_parsed);
207
31
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
31
        auto total = *n;
212
31
        auto read_count = 0;
213
31
        _buffer.resize(total);
214
198
        for (size_t i = 0; i < total; ++i) {
215
170
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
170
            if (UNLIKELY(ord >= _num_elems)) {
217
3
                break;
218
3
            }
219
220
167
            _buffer[read_count++] =
221
167
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
167
        }
223
224
31
        if (LIKELY(read_count > 0)) {
225
31
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
31
                                                   read_count, *dst);
227
31
        }
228
229
31
        *n = read_count;
230
31
        return Status::OK();
231
31
    }
232
233
0
    size_t count() const override {
234
0
        DCHECK(_parsed);
235
0
        return _num_elems;
236
0
    }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE5countEv
237
238
1.51M
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.51M
        return _cur_idx;
241
1.51M
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE13current_indexEv
Line
Count
Source
238
227k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
227k
        return _cur_idx;
241
227k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE13current_indexEv
Line
Count
Source
238
225k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
225k
        return _cur_idx;
241
225k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE13current_indexEv
Line
Count
Source
238
270k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
270k
        return _cur_idx;
241
270k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE13current_indexEv
Line
Count
Source
238
244k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
244k
        return _cur_idx;
241
244k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE13current_indexEv
Line
Count
Source
238
106k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
106k
        return _cur_idx;
241
106k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE13current_indexEv
Line
Count
Source
238
232k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
232k
        return _cur_idx;
241
232k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE13current_indexEv
Line
Count
Source
238
205k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
205k
        return _cur_idx;
241
205k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE13current_indexEv
Line
Count
Source
238
197
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
197
        return _cur_idx;
241
197
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE13current_indexEv
Line
Count
Source
238
68
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
68
        return _cur_idx;
241
68
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE13current_indexEv
Line
Count
Source
238
51
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
51
        return _cur_idx;
241
51
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE13current_indexEv
Line
Count
Source
238
52
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
52
        return _cur_idx;
241
52
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE13current_indexEv
Line
Count
Source
238
52
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
52
        return _cur_idx;
241
52
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE13current_indexEv
Line
Count
Source
238
52
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
52
        return _cur_idx;
241
52
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE13current_indexEv
Line
Count
Source
238
52
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
52
        return _cur_idx;
241
52
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE13current_indexEv
Line
Count
Source
238
50
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
50
        return _cur_idx;
241
50
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE13current_indexEv
Line
Count
Source
238
51
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
51
        return _cur_idx;
241
51
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE13current_indexEv
Line
Count
Source
238
52
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
52
        return _cur_idx;
241
52
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE13current_indexEv
Line
Count
Source
238
53
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
53
        return _cur_idx;
241
53
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE13current_indexEv
Line
Count
Source
238
58
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
58
        return _cur_idx;
241
58
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE13current_indexEv
Line
Count
Source
238
51
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
51
        return _cur_idx;
241
51
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE13current_indexEv
Line
Count
Source
238
53
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
53
        return _cur_idx;
241
53
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE13current_indexEv
Line
Count
Source
238
53
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
53
        return _cur_idx;
241
53
    }
242
243
private:
244
    Slice _data;
245
    PageDecoderOptions _options;
246
    bool _parsed;
247
    uint32_t _num_elems;
248
    uint32_t _cur_idx;
249
    typedef typename TypeTraits<Type>::CppType CppType;
250
    static constexpr size_t SIZE_OF_TYPE = TypeTraits<Type>::size;
251
252
    std::vector<std::conditional_t<std::is_same_v<CppType, bool>, uint8_t, CppType>> _buffer;
253
};
254
255
} // namespace segment_v2
256
} // namespace doris