Coverage Report

Created: 2026-11-02 13:31

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
274k
    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
274k
        return reset();
46
274k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
42
48.8k
    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
48.8k
        return reset();
46
48.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
42
9.16k
    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.16k
        return reset();
46
9.16k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
42
48.8k
    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
48.8k
        return reset();
46
48.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
42
141k
    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
141k
        return reset();
46
141k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
42
12.0k
    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
12.0k
        return reset();
46
12.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
42
6.55k
    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
6.55k
        return reset();
46
6.55k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
42
7.32k
    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
7.32k
        return reset();
46
7.32k
    }
_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
1.08M
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE12is_page_fullEv
Line
Count
Source
48
98.3k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE12is_page_fullEv
Line
Count
Source
48
24.1k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE12is_page_fullEv
Line
Count
Source
48
318k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE12is_page_fullEv
Line
Count
Source
48
568k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE12is_page_fullEv
Line
Count
Source
48
24.5k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE12is_page_fullEv
Line
Count
Source
48
13.5k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE12is_page_fullEv
Line
Count
Source
48
40.3k
    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
544k
    Status add(const uint8_t* vals, size_t* count) override {
51
544k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
544k
        size_t old_size = _buffer.size();
56
544k
        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
544k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
545k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
545k
        _count += to_add;
62
545k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
545k
        *count = to_add;
65
545k
        _remain_element_capacity -= to_add;
66
545k
        return Status::OK();
67
544k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE3addEPKhPm
Line
Count
Source
50
49.1k
    Status add(const uint8_t* vals, size_t* count) override {
51
49.1k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
49.1k
        size_t old_size = _buffer.size();
56
49.1k
        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
49.1k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
49.1k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
49.1k
        _count += to_add;
62
49.1k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
49.1k
        *count = to_add;
65
49.1k
        _remain_element_capacity -= to_add;
66
49.1k
        return Status::OK();
67
49.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE3addEPKhPm
Line
Count
Source
50
12.0k
    Status add(const uint8_t* vals, size_t* count) override {
51
12.0k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
12.0k
        size_t old_size = _buffer.size();
56
12.0k
        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
12.0k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
12.0k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
12.0k
        _count += to_add;
62
12.0k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
12.0k
        *count = to_add;
65
12.0k
        _remain_element_capacity -= to_add;
66
12.0k
        return Status::OK();
67
12.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE3addEPKhPm
Line
Count
Source
50
159k
    Status add(const uint8_t* vals, size_t* count) override {
51
159k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
159k
        size_t old_size = _buffer.size();
56
159k
        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
159k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
159k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
159k
        _count += to_add;
62
159k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
159k
        *count = to_add;
65
159k
        _remain_element_capacity -= to_add;
66
159k
        return Status::OK();
67
159k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE3addEPKhPm
Line
Count
Source
50
284k
    Status add(const uint8_t* vals, size_t* count) override {
51
284k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
284k
        size_t old_size = _buffer.size();
56
284k
        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
284k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
284k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
284k
        _count += to_add;
62
284k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
284k
        *count = to_add;
65
284k
        _remain_element_capacity -= to_add;
66
284k
        return Status::OK();
67
284k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE3addEPKhPm
Line
Count
Source
50
12.2k
    Status add(const uint8_t* vals, size_t* count) override {
51
12.2k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
12.2k
        size_t old_size = _buffer.size();
56
12.2k
        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
12.2k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
12.2k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
12.2k
        _count += to_add;
62
12.2k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
12.2k
        *count = to_add;
65
12.2k
        _remain_element_capacity -= to_add;
66
12.2k
        return Status::OK();
67
12.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE3addEPKhPm
Line
Count
Source
50
6.75k
    Status add(const uint8_t* vals, size_t* count) override {
51
6.75k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
6.75k
        size_t old_size = _buffer.size();
56
6.75k
        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
6.75k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
6.75k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
6.75k
        _count += to_add;
62
6.75k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
6.75k
        *count = to_add;
65
6.75k
        _remain_element_capacity -= to_add;
66
6.75k
        return Status::OK();
67
6.75k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE3addEPKhPm
Line
Count
Source
50
20.1k
    Status add(const uint8_t* vals, size_t* count) override {
51
20.1k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
20.1k
        size_t old_size = _buffer.size();
56
20.1k
        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.1k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
20.2k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
20.2k
        _count += to_add;
62
20.2k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
20.2k
        *count = to_add;
65
20.2k
        _remain_element_capacity -= to_add;
66
20.2k
        return Status::OK();
67
20.1k
    }
_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
278k
    Status finish(OwnedSlice* slice) override {
70
278k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
278k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
278k
        return Status::OK();
73
278k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
48.3k
    Status finish(OwnedSlice* slice) override {
70
48.3k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
48.3k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
48.3k
        return Status::OK();
73
48.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8.77k
    Status finish(OwnedSlice* slice) override {
70
8.77k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8.77k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8.77k
        return Status::OK();
73
8.77k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
50.0k
    Status finish(OwnedSlice* slice) override {
70
50.0k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
50.0k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
50.0k
        return Status::OK();
73
50.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
145k
    Status finish(OwnedSlice* slice) override {
70
145k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
145k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
145k
        return Status::OK();
73
145k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
12.2k
    Status finish(OwnedSlice* slice) override {
70
12.2k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
12.2k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
12.2k
        return Status::OK();
73
12.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6.26k
    Status finish(OwnedSlice* slice) override {
70
6.26k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6.26k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6.26k
        return Status::OK();
73
6.26k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
7.45k
    Status finish(OwnedSlice* slice) override {
70
7.45k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
7.45k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
7.45k
        return Status::OK();
73
7.45k
    }
_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
552k
    Status reset() override {
76
552k
        RETURN_IF_CATCH_EXCEPTION({
77
552k
            _buffer.reserve(_options.data_page_size);
78
552k
            _count = 0;
79
552k
            _raw_data_size = 0;
80
552k
            _buffer.clear();
81
552k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
552k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
552k
        });
84
553k
        return Status::OK();
85
552k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5resetEv
Line
Count
Source
75
97.1k
    Status reset() override {
76
97.1k
        RETURN_IF_CATCH_EXCEPTION({
77
97.1k
            _buffer.reserve(_options.data_page_size);
78
97.1k
            _count = 0;
79
97.1k
            _raw_data_size = 0;
80
97.1k
            _buffer.clear();
81
97.1k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
97.1k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
97.1k
        });
84
97.2k
        return Status::OK();
85
97.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5resetEv
Line
Count
Source
75
17.9k
    Status reset() override {
76
17.9k
        RETURN_IF_CATCH_EXCEPTION({
77
17.9k
            _buffer.reserve(_options.data_page_size);
78
17.9k
            _count = 0;
79
17.9k
            _raw_data_size = 0;
80
17.9k
            _buffer.clear();
81
17.9k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
17.9k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
17.9k
        });
84
17.9k
        return Status::OK();
85
17.9k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5resetEv
Line
Count
Source
75
98.8k
    Status reset() override {
76
98.8k
        RETURN_IF_CATCH_EXCEPTION({
77
98.8k
            _buffer.reserve(_options.data_page_size);
78
98.8k
            _count = 0;
79
98.8k
            _raw_data_size = 0;
80
98.8k
            _buffer.clear();
81
98.8k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
98.8k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
98.8k
        });
84
99.2k
        return Status::OK();
85
98.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5resetEv
Line
Count
Source
75
286k
    Status reset() override {
76
286k
        RETURN_IF_CATCH_EXCEPTION({
77
286k
            _buffer.reserve(_options.data_page_size);
78
286k
            _count = 0;
79
286k
            _raw_data_size = 0;
80
286k
            _buffer.clear();
81
286k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
286k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
286k
        });
84
287k
        return Status::OK();
85
286k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5resetEv
Line
Count
Source
75
24.2k
    Status reset() override {
76
24.2k
        RETURN_IF_CATCH_EXCEPTION({
77
24.2k
            _buffer.reserve(_options.data_page_size);
78
24.2k
            _count = 0;
79
24.2k
            _raw_data_size = 0;
80
24.2k
            _buffer.clear();
81
24.2k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
24.2k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
24.2k
        });
84
24.2k
        return Status::OK();
85
24.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5resetEv
Line
Count
Source
75
12.8k
    Status reset() override {
76
12.8k
        RETURN_IF_CATCH_EXCEPTION({
77
12.8k
            _buffer.reserve(_options.data_page_size);
78
12.8k
            _count = 0;
79
12.8k
            _raw_data_size = 0;
80
12.8k
            _buffer.clear();
81
12.8k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
12.8k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
12.8k
        });
84
12.8k
        return Status::OK();
85
12.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5resetEv
Line
Count
Source
75
14.7k
    Status reset() override {
76
14.7k
        RETURN_IF_CATCH_EXCEPTION({
77
14.7k
            _buffer.reserve(_options.data_page_size);
78
14.7k
            _count = 0;
79
14.7k
            _raw_data_size = 0;
80
14.7k
            _buffer.clear();
81
14.7k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
14.7k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
14.7k
        });
84
14.7k
        return Status::OK();
85
14.7k
    }
_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.7k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4sizeEv
Line
Count
Source
89
2.01k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4sizeEv
Line
Count
Source
89
913
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4sizeEv
Line
Count
Source
89
3.87k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4sizeEv
Line
Count
Source
89
2.48k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4sizeEv
Line
Count
Source
89
1.47k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4sizeEv
Line
Count
Source
89
518
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4sizeEv
Line
Count
Source
89
459
    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
278k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE17get_raw_data_sizeEv
Line
Count
Source
91
48.3k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE17get_raw_data_sizeEv
Line
Count
Source
91
8.77k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE17get_raw_data_sizeEv
Line
Count
Source
91
50.0k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE17get_raw_data_sizeEv
Line
Count
Source
91
145k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE17get_raw_data_sizeEv
Line
Count
Source
91
12.2k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE17get_raw_data_sizeEv
Line
Count
Source
91
6.26k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE17get_raw_data_sizeEv
Line
Count
Source
91
7.45k
    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
274k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
48.8k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
9.16k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
48.6k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
141k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
11.9k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
6.55k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
7.32k
    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
423k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
86.0k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16.4k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
146k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
130k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
18.1k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
9.66k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
15.3k
            : _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
422k
    Status init() override {
112
422k
        CHECK(!_parsed);
113
114
422k
        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
422k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
422k
        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
422k
        _parsed = true;
128
129
422k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
422k
        return Status::OK();
131
422k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
111
86.0k
    Status init() override {
112
86.0k
        CHECK(!_parsed);
113
114
86.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
86.0k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
86.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
86.0k
        _parsed = true;
128
129
86.0k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
86.0k
        return Status::OK();
131
86.0k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
111
16.4k
    Status init() override {
112
16.4k
        CHECK(!_parsed);
113
114
16.4k
        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.4k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16.4k
        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.4k
        _parsed = true;
128
129
16.4k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16.4k
        return Status::OK();
131
16.4k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
111
146k
    Status init() override {
112
146k
        CHECK(!_parsed);
113
114
146k
        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
146k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
146k
        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
146k
        _parsed = true;
128
129
146k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
146k
        return Status::OK();
131
146k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
111
130k
    Status init() override {
112
130k
        CHECK(!_parsed);
113
114
130k
        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
130k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
130k
        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
130k
        _parsed = true;
128
129
130k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
130k
        return Status::OK();
131
130k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
111
18.1k
    Status init() override {
112
18.1k
        CHECK(!_parsed);
113
114
18.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
18.1k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
18.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
18.1k
        _parsed = true;
128
129
18.1k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
18.1k
        return Status::OK();
131
18.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
111
9.66k
    Status init() override {
112
9.66k
        CHECK(!_parsed);
113
114
9.66k
        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.66k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
9.66k
        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.66k
        _parsed = true;
128
129
9.66k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
9.66k
        return Status::OK();
131
9.66k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
111
15.3k
    Status init() override {
112
15.3k
        CHECK(!_parsed);
113
114
15.3k
        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
15.3k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
15.3k
        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
15.3k
        _parsed = true;
128
129
15.3k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
15.3k
        return Status::OK();
131
15.3k
    }
_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.40M
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
2.40M
        if (_num_elems == 0) [[unlikely]] {
136
9.08k
            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
9.08k
        }
141
142
2.40M
        DCHECK_LE(pos, _num_elems);
143
144
2.40M
        _cur_idx = cast_set<uint32_t>(pos);
145
2.40M
        return Status::OK();
146
2.40M
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE24seek_to_position_in_pageEm
Line
Count
Source
133
379k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
379k
        if (_num_elems == 0) [[unlikely]] {
136
1.07k
            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.07k
        }
141
142
379k
        DCHECK_LE(pos, _num_elems);
143
144
379k
        _cur_idx = cast_set<uint32_t>(pos);
145
379k
        return Status::OK();
146
379k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE24seek_to_position_in_pageEm
Line
Count
Source
133
257k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
257k
        if (_num_elems == 0) [[unlikely]] {
136
604
            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
604
        }
141
142
257k
        DCHECK_LE(pos, _num_elems);
143
144
257k
        _cur_idx = cast_set<uint32_t>(pos);
145
257k
        return Status::OK();
146
257k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE24seek_to_position_in_pageEm
Line
Count
Source
133
795k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
795k
        if (_num_elems == 0) [[unlikely]] {
136
3.41k
            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
3.41k
        }
141
142
795k
        DCHECK_LE(pos, _num_elems);
143
144
795k
        _cur_idx = cast_set<uint32_t>(pos);
145
795k
        return Status::OK();
146
795k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE24seek_to_position_in_pageEm
Line
Count
Source
133
350k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
350k
        if (_num_elems == 0) [[unlikely]] {
136
2.91k
            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.91k
        }
141
142
350k
        DCHECK_LE(pos, _num_elems);
143
144
350k
        _cur_idx = cast_set<uint32_t>(pos);
145
350k
        return Status::OK();
146
350k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE24seek_to_position_in_pageEm
Line
Count
Source
133
135k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
135k
        if (_num_elems == 0) [[unlikely]] {
136
466
            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
466
        }
141
142
135k
        DCHECK_LE(pos, _num_elems);
143
144
135k
        _cur_idx = cast_set<uint32_t>(pos);
145
135k
        return Status::OK();
146
135k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE24seek_to_position_in_pageEm
Line
Count
Source
133
254k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
254k
        if (_num_elems == 0) [[unlikely]] {
136
311
            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
311
        }
141
142
254k
        DCHECK_LE(pos, _num_elems);
143
144
254k
        _cur_idx = cast_set<uint32_t>(pos);
145
254k
        return Status::OK();
146
254k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE24seek_to_position_in_pageEm
Line
Count
Source
133
233k
    Status seek_to_position_in_page(size_t pos) override {
134
233k
        CHECK(_parsed) << "Must call init()";
135
233k
        if (_num_elems == 0) [[unlikely]] {
136
308
            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
308
        }
141
142
233k
        DCHECK_LE(pos, _num_elems);
143
144
233k
        _cur_idx = cast_set<uint32_t>(pos);
145
233k
        return Status::OK();
146
233k
    }
_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
50
                left = mid + 1;
168
62
            } else {
169
62
                right = mid;
170
62
            }
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
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
    }
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
2
                left = mid + 1;
168
12
            } else {
169
12
                right = mid;
170
12
            }
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
1.61M
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
1.61M
        DCHECK(_parsed);
188
1.62M
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
1.61M
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
1.61M
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
1.61M
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
1.61M
                                               *dst);
197
198
1.61M
        *n = max_fetch;
199
1.61M
        _cur_idx += max_fetch;
200
201
1.61M
        return Status::OK();
202
1.61M
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
126k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
126k
        DCHECK(_parsed);
188
126k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
126k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
126k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
126k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
126k
                                               *dst);
197
198
126k
        *n = max_fetch;
199
126k
        _cur_idx += max_fetch;
200
201
126k
        return Status::OK();
202
126k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
14.3k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
14.3k
        DCHECK(_parsed);
188
14.3k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
14.3k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
14.3k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
14.3k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
14.3k
                                               *dst);
197
198
14.3k
        *n = max_fetch;
199
14.3k
        _cur_idx += max_fetch;
200
201
14.3k
        return Status::OK();
202
14.3k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
601k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
601k
        DCHECK(_parsed);
188
601k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
601k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
601k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
601k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
601k
                                               *dst);
197
198
601k
        *n = max_fetch;
199
601k
        _cur_idx += max_fetch;
200
201
601k
        return Status::OK();
202
601k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
796k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
796k
        DCHECK(_parsed);
188
799k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
796k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
796k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
796k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
796k
                                               *dst);
197
198
796k
        *n = max_fetch;
199
796k
        _cur_idx += max_fetch;
200
201
796k
        return Status::OK();
202
796k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
16.0k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
16.0k
        DCHECK(_parsed);
188
16.0k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
16.0k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
16.0k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
16.0k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
16.0k
                                               *dst);
197
198
16.0k
        *n = max_fetch;
199
16.0k
        _cur_idx += max_fetch;
200
201
16.0k
        return Status::OK();
202
16.0k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
8.00k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
8.00k
        DCHECK(_parsed);
188
8.00k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
8.00k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
8.00k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
8.00k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
8.00k
                                               *dst);
197
198
8.00k
        *n = max_fetch;
199
8.00k
        _cur_idx += max_fetch;
200
201
8.00k
        return Status::OK();
202
8.00k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
54.5k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
54.5k
        DCHECK(_parsed);
188
54.5k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
54.5k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
54.5k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
54.5k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
54.5k
                                               *dst);
197
198
54.5k
        *n = max_fetch;
199
54.5k
        _cur_idx += max_fetch;
200
201
54.5k
        return Status::OK();
202
54.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
292k
                          MutableColumnPtr& dst) override {
206
292k
        DCHECK(_parsed);
207
292k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
292k
        auto total = *n;
212
292k
        auto read_count = 0;
213
292k
        _buffer.resize(total);
214
67.0M
        for (size_t i = 0; i < total; ++i) {
215
66.7M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
66.7M
            if (UNLIKELY(ord >= _num_elems)) {
217
5.18k
                break;
218
5.18k
            }
219
220
66.7M
            _buffer[read_count++] =
221
66.7M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
66.7M
        }
223
224
292k
        if (LIKELY(read_count > 0)) {
225
292k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
292k
                                                   read_count, *dst);
227
292k
        }
228
229
292k
        *n = read_count;
230
292k
        return Status::OK();
231
292k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
32.6k
                          MutableColumnPtr& dst) override {
206
32.6k
        DCHECK(_parsed);
207
32.6k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
32.6k
        auto total = *n;
212
32.6k
        auto read_count = 0;
213
32.6k
        _buffer.resize(total);
214
1.51M
        for (size_t i = 0; i < total; ++i) {
215
1.48M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.48M
            if (UNLIKELY(ord >= _num_elems)) {
217
33
                break;
218
33
            }
219
220
1.48M
            _buffer[read_count++] =
221
1.48M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.48M
        }
223
224
32.6k
        if (LIKELY(read_count > 0)) {
225
32.6k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
32.6k
                                                   read_count, *dst);
227
32.6k
        }
228
229
32.6k
        *n = read_count;
230
32.6k
        return Status::OK();
231
32.6k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
7.78k
                          MutableColumnPtr& dst) override {
206
7.78k
        DCHECK(_parsed);
207
7.78k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
7.78k
        auto total = *n;
212
7.78k
        auto read_count = 0;
213
7.78k
        _buffer.resize(total);
214
674k
        for (size_t i = 0; i < total; ++i) {
215
667k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
667k
            if (UNLIKELY(ord >= _num_elems)) {
217
14
                break;
218
14
            }
219
220
667k
            _buffer[read_count++] =
221
667k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
667k
        }
223
224
7.78k
        if (LIKELY(read_count > 0)) {
225
7.78k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
7.78k
                                                   read_count, *dst);
227
7.78k
        }
228
229
7.78k
        *n = read_count;
230
7.78k
        return Status::OK();
231
7.78k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
76.1k
                          MutableColumnPtr& dst) override {
206
76.1k
        DCHECK(_parsed);
207
76.1k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
76.1k
        auto total = *n;
212
76.1k
        auto read_count = 0;
213
76.1k
        _buffer.resize(total);
214
32.2M
        for (size_t i = 0; i < total; ++i) {
215
32.1M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
32.1M
            if (UNLIKELY(ord >= _num_elems)) {
217
2.09k
                break;
218
2.09k
            }
219
220
32.1M
            _buffer[read_count++] =
221
32.1M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
32.1M
        }
223
224
76.2k
        if (LIKELY(read_count > 0)) {
225
76.2k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
76.2k
                                                   read_count, *dst);
227
76.2k
        }
228
229
76.1k
        *n = read_count;
230
76.1k
        return Status::OK();
231
76.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
155k
                          MutableColumnPtr& dst) override {
206
155k
        DCHECK(_parsed);
207
155k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
155k
        auto total = *n;
212
155k
        auto read_count = 0;
213
155k
        _buffer.resize(total);
214
28.2M
        for (size_t i = 0; i < total; ++i) {
215
28.1M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
28.1M
            if (UNLIKELY(ord >= _num_elems)) {
217
2.19k
                break;
218
2.19k
            }
219
220
28.1M
            _buffer[read_count++] =
221
28.1M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
28.1M
        }
223
224
155k
        if (LIKELY(read_count > 0)) {
225
155k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
155k
                                                   read_count, *dst);
227
155k
        }
228
229
155k
        *n = read_count;
230
155k
        return Status::OK();
231
155k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
8.63k
                          MutableColumnPtr& dst) override {
206
8.63k
        DCHECK(_parsed);
207
8.63k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
8.63k
        auto total = *n;
212
8.63k
        auto read_count = 0;
213
8.63k
        _buffer.resize(total);
214
1.73M
        for (size_t i = 0; i < total; ++i) {
215
1.72M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.72M
            if (UNLIKELY(ord >= _num_elems)) {
217
534
                break;
218
534
            }
219
220
1.72M
            _buffer[read_count++] =
221
1.72M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.72M
        }
223
224
8.63k
        if (LIKELY(read_count > 0)) {
225
8.63k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
8.63k
                                                   read_count, *dst);
227
8.63k
        }
228
229
8.63k
        *n = read_count;
230
8.63k
        return Status::OK();
231
8.63k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
4.95k
                          MutableColumnPtr& dst) override {
206
4.95k
        DCHECK(_parsed);
207
4.95k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
4.95k
        auto total = *n;
212
4.95k
        auto read_count = 0;
213
4.95k
        _buffer.resize(total);
214
1.20M
        for (size_t i = 0; i < total; ++i) {
215
1.20M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.20M
            if (UNLIKELY(ord >= _num_elems)) {
217
31
                break;
218
31
            }
219
220
1.20M
            _buffer[read_count++] =
221
1.20M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.20M
        }
223
224
4.95k
        if (LIKELY(read_count > 0)) {
225
4.95k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
4.95k
                                                   read_count, *dst);
227
4.95k
        }
228
229
4.95k
        *n = read_count;
230
4.95k
        return Status::OK();
231
4.95k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
6.68k
                          MutableColumnPtr& dst) override {
206
6.68k
        DCHECK(_parsed);
207
6.68k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
6.68k
        auto total = *n;
212
6.68k
        auto read_count = 0;
213
6.68k
        _buffer.resize(total);
214
1.36M
        for (size_t i = 0; i < total; ++i) {
215
1.36M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.36M
            if (UNLIKELY(ord >= _num_elems)) {
217
264
                break;
218
264
            }
219
220
1.36M
            _buffer[read_count++] =
221
1.36M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.36M
        }
223
224
6.68k
        if (LIKELY(read_count > 0)) {
225
6.68k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
6.68k
                                                   read_count, *dst);
227
6.68k
        }
228
229
6.68k
        *n = read_count;
230
6.68k
        return Status::OK();
231
6.68k
    }
_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.57M
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.57M
        return _cur_idx;
241
1.57M
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE13current_indexEv
Line
Count
Source
238
239k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
239k
        return _cur_idx;
241
239k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE13current_indexEv
Line
Count
Source
238
237k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
237k
        return _cur_idx;
241
237k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE13current_indexEv
Line
Count
Source
238
280k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
280k
        return _cur_idx;
241
280k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE13current_indexEv
Line
Count
Source
238
249k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
249k
        return _cur_idx;
241
249k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE13current_indexEv
Line
Count
Source
238
111k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
111k
        return _cur_idx;
241
111k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE13current_indexEv
Line
Count
Source
238
243k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
243k
        return _cur_idx;
241
243k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE13current_indexEv
Line
Count
Source
238
214k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
214k
        return _cur_idx;
241
214k
    }
_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