Coverage Report

Created: 2026-10-28 10:08

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
284k
    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
284k
        return reset();
46
284k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
42
37.2k
    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
37.2k
        return reset();
46
37.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
42
6.87k
    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.87k
        return reset();
46
6.87k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
42
47.6k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
47.6k
        return reset();
46
47.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
42
173k
    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
173k
        return reset();
46
173k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
42
9.33k
    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.33k
        return reset();
46
9.33k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
42
4.47k
    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
4.47k
        return reset();
46
4.47k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
42
5.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
5.32k
        return reset();
46
5.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
982k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE12is_page_fullEv
Line
Count
Source
48
74.4k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE12is_page_fullEv
Line
Count
Source
48
19.9k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE12is_page_fullEv
Line
Count
Source
48
326k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE12is_page_fullEv
Line
Count
Source
48
497k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE12is_page_fullEv
Line
Count
Source
48
19.4k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE12is_page_fullEv
Line
Count
Source
48
9.60k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE12is_page_fullEv
Line
Count
Source
48
32.4k
    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
491k
    Status add(const uint8_t* vals, size_t* count) override {
51
491k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
491k
        size_t old_size = _buffer.size();
56
491k
        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
491k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
491k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
491k
        _count += to_add;
62
491k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
491k
        *count = to_add;
65
491k
        _remain_element_capacity -= to_add;
66
491k
        return Status::OK();
67
491k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE3addEPKhPm
Line
Count
Source
50
37.2k
    Status add(const uint8_t* vals, size_t* count) override {
51
37.2k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
37.2k
        size_t old_size = _buffer.size();
56
37.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
37.2k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
37.2k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
37.2k
        _count += to_add;
62
37.2k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
37.2k
        *count = to_add;
65
37.2k
        _remain_element_capacity -= to_add;
66
37.2k
        return Status::OK();
67
37.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE3addEPKhPm
Line
Count
Source
50
9.96k
    Status add(const uint8_t* vals, size_t* count) override {
51
9.96k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
9.96k
        size_t old_size = _buffer.size();
56
9.96k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
9.96k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
9.96k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
9.96k
        _count += to_add;
62
9.96k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
9.96k
        *count = to_add;
65
9.96k
        _remain_element_capacity -= to_add;
66
9.96k
        return Status::OK();
67
9.96k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE3addEPKhPm
Line
Count
Source
50
163k
    Status add(const uint8_t* vals, size_t* count) override {
51
163k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
163k
        size_t old_size = _buffer.size();
56
163k
        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
163k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
163k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
163k
        _count += to_add;
62
163k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
163k
        *count = to_add;
65
163k
        _remain_element_capacity -= to_add;
66
163k
        return Status::OK();
67
163k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE3addEPKhPm
Line
Count
Source
50
248k
    Status add(const uint8_t* vals, size_t* count) override {
51
248k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
248k
        size_t old_size = _buffer.size();
56
248k
        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
248k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
248k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
248k
        _count += to_add;
62
248k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
248k
        *count = to_add;
65
248k
        _remain_element_capacity -= to_add;
66
248k
        return Status::OK();
67
248k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE3addEPKhPm
Line
Count
Source
50
9.74k
    Status add(const uint8_t* vals, size_t* count) override {
51
9.74k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
9.74k
        size_t old_size = _buffer.size();
56
9.74k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
9.74k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
9.74k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
9.74k
        _count += to_add;
62
9.74k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
9.74k
        *count = to_add;
65
9.74k
        _remain_element_capacity -= to_add;
66
9.74k
        return Status::OK();
67
9.74k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE3addEPKhPm
Line
Count
Source
50
4.80k
    Status add(const uint8_t* vals, size_t* count) override {
51
4.80k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
4.80k
        size_t old_size = _buffer.size();
56
4.80k
        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
4.80k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
4.80k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
4.80k
        _count += to_add;
62
4.80k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
4.80k
        *count = to_add;
65
4.80k
        _remain_element_capacity -= to_add;
66
4.80k
        return Status::OK();
67
4.80k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE3addEPKhPm
Line
Count
Source
50
16.2k
    Status add(const uint8_t* vals, size_t* count) override {
51
16.2k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
16.2k
        size_t old_size = _buffer.size();
56
16.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
16.2k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
16.3k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
16.3k
        _count += to_add;
62
16.3k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
16.3k
        *count = to_add;
65
16.3k
        _remain_element_capacity -= to_add;
66
16.3k
        return Status::OK();
67
16.2k
    }
_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
293k
    Status finish(OwnedSlice* slice) override {
70
293k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
293k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
293k
        return Status::OK();
73
293k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
36.5k
    Status finish(OwnedSlice* slice) override {
70
36.5k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
36.5k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
36.5k
        return Status::OK();
73
36.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6.75k
    Status finish(OwnedSlice* slice) override {
70
6.75k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6.75k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6.75k
        return Status::OK();
73
6.75k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
51.1k
    Status finish(OwnedSlice* slice) override {
70
51.1k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
51.1k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
51.1k
        return Status::OK();
73
51.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
178k
    Status finish(OwnedSlice* slice) override {
70
178k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
178k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
178k
        return Status::OK();
73
178k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
9.60k
    Status finish(OwnedSlice* slice) override {
70
9.60k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
9.60k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
9.60k
        return Status::OK();
73
9.60k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
4.35k
    Status finish(OwnedSlice* slice) override {
70
4.35k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
4.35k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
4.35k
        return Status::OK();
73
4.35k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
5.47k
    Status finish(OwnedSlice* slice) override {
70
5.47k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
5.47k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
5.48k
        return Status::OK();
73
5.47k
    }
_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
577k
    Status reset() override {
76
577k
        RETURN_IF_CATCH_EXCEPTION({
77
577k
            _buffer.reserve(_options.data_page_size);
78
577k
            _count = 0;
79
577k
            _raw_data_size = 0;
80
577k
            _buffer.clear();
81
577k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
577k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
577k
        });
84
578k
        return Status::OK();
85
577k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5resetEv
Line
Count
Source
75
73.8k
    Status reset() override {
76
73.8k
        RETURN_IF_CATCH_EXCEPTION({
77
73.8k
            _buffer.reserve(_options.data_page_size);
78
73.8k
            _count = 0;
79
73.8k
            _raw_data_size = 0;
80
73.8k
            _buffer.clear();
81
73.8k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
73.8k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
73.8k
        });
84
73.8k
        return Status::OK();
85
73.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5resetEv
Line
Count
Source
75
13.6k
    Status reset() override {
76
13.6k
        RETURN_IF_CATCH_EXCEPTION({
77
13.6k
            _buffer.reserve(_options.data_page_size);
78
13.6k
            _count = 0;
79
13.6k
            _raw_data_size = 0;
80
13.6k
            _buffer.clear();
81
13.6k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
13.6k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
13.6k
        });
84
13.6k
        return Status::OK();
85
13.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5resetEv
Line
Count
Source
75
98.6k
    Status reset() override {
76
98.6k
        RETURN_IF_CATCH_EXCEPTION({
77
98.6k
            _buffer.reserve(_options.data_page_size);
78
98.6k
            _count = 0;
79
98.6k
            _raw_data_size = 0;
80
98.6k
            _buffer.clear();
81
98.6k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
98.6k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
98.6k
        });
84
99.2k
        return Status::OK();
85
98.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5resetEv
Line
Count
Source
75
352k
    Status reset() override {
76
352k
        RETURN_IF_CATCH_EXCEPTION({
77
352k
            _buffer.reserve(_options.data_page_size);
78
352k
            _count = 0;
79
352k
            _raw_data_size = 0;
80
352k
            _buffer.clear();
81
352k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
352k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
352k
        });
84
353k
        return Status::OK();
85
352k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5resetEv
Line
Count
Source
75
18.9k
    Status reset() override {
76
18.9k
        RETURN_IF_CATCH_EXCEPTION({
77
18.9k
            _buffer.reserve(_options.data_page_size);
78
18.9k
            _count = 0;
79
18.9k
            _raw_data_size = 0;
80
18.9k
            _buffer.clear();
81
18.9k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18.9k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18.9k
        });
84
18.9k
        return Status::OK();
85
18.9k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5resetEv
Line
Count
Source
75
8.82k
    Status reset() override {
76
8.82k
        RETURN_IF_CATCH_EXCEPTION({
77
8.82k
            _buffer.reserve(_options.data_page_size);
78
8.82k
            _count = 0;
79
8.82k
            _raw_data_size = 0;
80
8.82k
            _buffer.clear();
81
8.82k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8.82k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8.82k
        });
84
8.83k
        return Status::OK();
85
8.82k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5resetEv
Line
Count
Source
75
10.7k
    Status reset() override {
76
10.7k
        RETURN_IF_CATCH_EXCEPTION({
77
10.7k
            _buffer.reserve(_options.data_page_size);
78
10.7k
            _count = 0;
79
10.7k
            _raw_data_size = 0;
80
10.7k
            _buffer.clear();
81
10.7k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10.7k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10.7k
        });
84
10.8k
        return Status::OK();
85
10.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
7.81k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4sizeEv
Line
Count
Source
89
1.45k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4sizeEv
Line
Count
Source
89
663
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4sizeEv
Line
Count
Source
89
2.66k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4sizeEv
Line
Count
Source
89
1.40k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4sizeEv
Line
Count
Source
89
1.10k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4sizeEv
Line
Count
Source
89
272
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4sizeEv
Line
Count
Source
89
250
    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
293k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE17get_raw_data_sizeEv
Line
Count
Source
91
36.5k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE17get_raw_data_sizeEv
Line
Count
Source
91
6.75k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE17get_raw_data_sizeEv
Line
Count
Source
91
51.1k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE17get_raw_data_sizeEv
Line
Count
Source
91
178k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE17get_raw_data_sizeEv
Line
Count
Source
91
9.60k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE17get_raw_data_sizeEv
Line
Count
Source
91
4.35k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE17get_raw_data_sizeEv
Line
Count
Source
91
5.48k
    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
284k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
37.2k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
6.87k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
47.4k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
173k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
9.32k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
4.47k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
5.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
394k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
76.8k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
17.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
161k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
96.9k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
11.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
13.9k
            : _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
391k
    Status init() override {
112
391k
        CHECK(!_parsed);
113
114
391k
        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
391k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
391k
        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
391k
        _parsed = true;
128
129
391k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
391k
        return Status::OK();
131
391k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
111
76.7k
    Status init() override {
112
76.7k
        CHECK(!_parsed);
113
114
76.7k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
76.7k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
76.7k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
76.7k
        _parsed = true;
128
129
76.7k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
76.7k
        return Status::OK();
131
76.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
111
17.2k
    Status init() override {
112
17.2k
        CHECK(!_parsed);
113
114
17.2k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
17.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
17.2k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
17.2k
        _parsed = true;
128
129
17.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
17.2k
        return Status::OK();
131
17.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
111
159k
    Status init() override {
112
159k
        CHECK(!_parsed);
113
114
159k
        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
159k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
159k
        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
159k
        _parsed = true;
128
129
159k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
159k
        return Status::OK();
131
159k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
111
96.8k
    Status init() override {
112
96.8k
        CHECK(!_parsed);
113
114
96.8k
        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
96.8k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
96.8k
        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
96.8k
        _parsed = true;
128
129
96.8k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
96.8k
        return Status::OK();
131
96.8k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
111
16.2k
    Status init() override {
112
16.2k
        CHECK(!_parsed);
113
114
16.2k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16.2k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16.2k
        _parsed = true;
128
129
16.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16.2k
        return Status::OK();
131
16.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
111
11.2k
    Status init() override {
112
11.2k
        CHECK(!_parsed);
113
114
11.2k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
11.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
11.2k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
11.2k
        _parsed = true;
128
129
11.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
11.2k
        return Status::OK();
131
11.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
111
13.9k
    Status init() override {
112
13.9k
        CHECK(!_parsed);
113
114
13.9k
        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
13.9k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
13.9k
        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
13.9k
        _parsed = true;
128
129
13.9k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
13.9k
        return Status::OK();
131
13.9k
    }
_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.29M
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
2.29M
        if (_num_elems == 0) [[unlikely]] {
136
8.53k
            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
8.53k
        }
141
142
2.29M
        DCHECK_LE(pos, _num_elems);
143
144
2.29M
        _cur_idx = cast_set<uint32_t>(pos);
145
2.29M
        return Status::OK();
146
2.29M
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE24seek_to_position_in_pageEm
Line
Count
Source
133
334k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
334k
        if (_num_elems == 0) [[unlikely]] {
136
1.10k
            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.10k
        }
141
142
334k
        DCHECK_LE(pos, _num_elems);
143
144
334k
        _cur_idx = cast_set<uint32_t>(pos);
145
334k
        return Status::OK();
146
334k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE24seek_to_position_in_pageEm
Line
Count
Source
133
251k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
251k
        if (_num_elems == 0) [[unlikely]] {
136
619
            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
619
        }
141
142
251k
        DCHECK_LE(pos, _num_elems);
143
144
251k
        _cur_idx = cast_set<uint32_t>(pos);
145
251k
        return Status::OK();
146
251k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE24seek_to_position_in_pageEm
Line
Count
Source
133
912k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
912k
        if (_num_elems == 0) [[unlikely]] {
136
2.80k
            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.80k
        }
141
142
912k
        DCHECK_LE(pos, _num_elems);
143
144
912k
        _cur_idx = cast_set<uint32_t>(pos);
145
912k
        return Status::OK();
146
912k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE24seek_to_position_in_pageEm
Line
Count
Source
133
193k
    Status seek_to_position_in_page(size_t pos) override {
134
193k
        CHECK(_parsed) << "Must call init()";
135
193k
        if (_num_elems == 0) [[unlikely]] {
136
2.86k
            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.86k
        }
141
142
193k
        DCHECK_LE(pos, _num_elems);
143
144
193k
        _cur_idx = cast_set<uint32_t>(pos);
145
193k
        return Status::OK();
146
193k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE24seek_to_position_in_pageEm
Line
Count
Source
133
131k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
131k
        if (_num_elems == 0) [[unlikely]] {
136
465
            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
465
        }
141
142
131k
        DCHECK_LE(pos, _num_elems);
143
144
131k
        _cur_idx = cast_set<uint32_t>(pos);
145
131k
        return Status::OK();
146
131k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE24seek_to_position_in_pageEm
Line
Count
Source
133
250k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
250k
        if (_num_elems == 0) [[unlikely]] {
136
297
            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
297
        }
141
142
250k
        DCHECK_LE(pos, _num_elems);
143
144
250k
        _cur_idx = cast_set<uint32_t>(pos);
145
250k
        return Status::OK();
146
250k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE24seek_to_position_in_pageEm
Line
Count
Source
133
224k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
224k
        if (_num_elems == 0) [[unlikely]] {
136
381
            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
381
        }
141
142
224k
        DCHECK_LE(pos, _num_elems);
143
144
224k
        _cur_idx = cast_set<uint32_t>(pos);
145
224k
        return Status::OK();
146
224k
    }
_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
46
                left = mid + 1;
168
66
            } else {
169
66
                right = mid;
170
66
            }
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
22
                left = mid + 1;
168
27
            } else {
169
27
                right = mid;
170
27
            }
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
22
                left = mid + 1;
168
27
            } else {
169
27
                right = mid;
170
27
            }
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.62M
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
1.62M
        DCHECK(_parsed);
188
1.63M
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
1.62M
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
1.62M
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
1.62M
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
1.62M
                                               *dst);
197
198
1.62M
        *n = max_fetch;
199
1.62M
        _cur_idx += max_fetch;
200
201
1.62M
        return Status::OK();
202
1.62M
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
81.0k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
81.0k
        DCHECK(_parsed);
188
81.1k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
81.0k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
81.0k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
81.0k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
81.0k
                                               *dst);
197
198
81.0k
        *n = max_fetch;
199
81.0k
        _cur_idx += max_fetch;
200
201
81.0k
        return Status::OK();
202
81.0k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
13.5k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
13.5k
        DCHECK(_parsed);
188
13.5k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
13.5k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
13.5k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
13.5k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
13.5k
                                               *dst);
197
198
13.5k
        *n = max_fetch;
199
13.5k
        _cur_idx += max_fetch;
200
201
13.5k
        return Status::OK();
202
13.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
736k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
736k
        DCHECK(_parsed);
188
737k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
736k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
736k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
736k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
736k
                                               *dst);
197
198
736k
        *n = max_fetch;
199
736k
        _cur_idx += max_fetch;
200
201
736k
        return Status::OK();
202
736k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
737k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
737k
        DCHECK(_parsed);
188
739k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
737k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
737k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
737k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
737k
                                               *dst);
197
198
737k
        *n = max_fetch;
199
737k
        _cur_idx += max_fetch;
200
201
737k
        return Status::OK();
202
737k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
12.5k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
12.5k
        DCHECK(_parsed);
188
12.5k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
12.5k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
12.5k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
12.5k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
12.5k
                                               *dst);
197
198
12.5k
        *n = max_fetch;
199
12.5k
        _cur_idx += max_fetch;
200
201
12.5k
        return Status::OK();
202
12.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
6.97k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
6.97k
        DCHECK(_parsed);
188
6.97k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
6.97k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
6.97k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
6.97k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
6.97k
                                               *dst);
197
198
6.97k
        *n = max_fetch;
199
6.97k
        _cur_idx += max_fetch;
200
201
6.97k
        return Status::OK();
202
6.97k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
38.8k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
38.8k
        DCHECK(_parsed);
188
38.9k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
38.8k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
38.8k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
38.8k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
38.8k
                                               *dst);
197
198
38.8k
        *n = max_fetch;
199
38.8k
        _cur_idx += max_fetch;
200
201
38.8k
        return Status::OK();
202
38.8k
    }
_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
202k
                          MutableColumnPtr& dst) override {
206
202k
        DCHECK(_parsed);
207
202k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
202k
        auto total = *n;
212
202k
        auto read_count = 0;
213
202k
        _buffer.resize(total);
214
68.4M
        for (size_t i = 0; i < total; ++i) {
215
68.2M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
68.2M
            if (UNLIKELY(ord >= _num_elems)) {
217
6.24k
                break;
218
6.24k
            }
219
220
68.2M
            _buffer[read_count++] =
221
68.2M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
68.2M
        }
223
224
202k
        if (LIKELY(read_count > 0)) {
225
202k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
202k
                                                   read_count, *dst);
227
202k
        }
228
229
202k
        *n = read_count;
230
202k
        return Status::OK();
231
202k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
31.3k
                          MutableColumnPtr& dst) override {
206
31.3k
        DCHECK(_parsed);
207
31.3k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
31.3k
        auto total = *n;
212
31.3k
        auto read_count = 0;
213
31.3k
        _buffer.resize(total);
214
1.58M
        for (size_t i = 0; i < total; ++i) {
215
1.55M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.55M
            if (UNLIKELY(ord >= _num_elems)) {
217
76
                break;
218
76
            }
219
220
1.55M
            _buffer[read_count++] =
221
1.55M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.55M
        }
223
224
31.3k
        if (LIKELY(read_count > 0)) {
225
31.3k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
31.3k
                                                   read_count, *dst);
227
31.3k
        }
228
229
31.3k
        *n = read_count;
230
31.3k
        return Status::OK();
231
31.3k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
8.00k
                          MutableColumnPtr& dst) override {
206
8.00k
        DCHECK(_parsed);
207
8.00k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
8.00k
        auto total = *n;
212
8.00k
        auto read_count = 0;
213
8.00k
        _buffer.resize(total);
214
587k
        for (size_t i = 0; i < total; ++i) {
215
579k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
579k
            if (UNLIKELY(ord >= _num_elems)) {
217
13
                break;
218
13
            }
219
220
579k
            _buffer[read_count++] =
221
579k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
579k
        }
223
224
8.00k
        if (LIKELY(read_count > 0)) {
225
8.00k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
8.00k
                                                   read_count, *dst);
227
8.00k
        }
228
229
8.00k
        *n = read_count;
230
8.00k
        return Status::OK();
231
8.00k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
78.6k
                          MutableColumnPtr& dst) override {
206
78.6k
        DCHECK(_parsed);
207
78.6k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
78.6k
        auto total = *n;
212
78.6k
        auto read_count = 0;
213
78.6k
        _buffer.resize(total);
214
34.6M
        for (size_t i = 0; i < total; ++i) {
215
34.5M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
34.5M
            if (UNLIKELY(ord >= _num_elems)) {
217
2.90k
                break;
218
2.90k
            }
219
220
34.5M
            _buffer[read_count++] =
221
34.5M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
34.5M
        }
223
224
78.6k
        if (LIKELY(read_count > 0)) {
225
78.6k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
78.6k
                                                   read_count, *dst);
227
78.6k
        }
228
229
78.6k
        *n = read_count;
230
78.6k
        return Status::OK();
231
78.6k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
63.4k
                          MutableColumnPtr& dst) override {
206
63.4k
        DCHECK(_parsed);
207
63.4k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
63.4k
        auto total = *n;
212
63.4k
        auto read_count = 0;
213
63.4k
        _buffer.resize(total);
214
27.5M
        for (size_t i = 0; i < total; ++i) {
215
27.5M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
27.5M
            if (UNLIKELY(ord >= _num_elems)) {
217
2.40k
                break;
218
2.40k
            }
219
220
27.5M
            _buffer[read_count++] =
221
27.5M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
27.5M
        }
223
224
63.4k
        if (LIKELY(read_count > 0)) {
225
63.4k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
63.4k
                                                   read_count, *dst);
227
63.4k
        }
228
229
63.4k
        *n = read_count;
230
63.4k
        return Status::OK();
231
63.4k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
7.89k
                          MutableColumnPtr& dst) override {
206
7.89k
        DCHECK(_parsed);
207
7.89k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
7.89k
        auto total = *n;
212
7.89k
        auto read_count = 0;
213
7.89k
        _buffer.resize(total);
214
1.54M
        for (size_t i = 0; i < total; ++i) {
215
1.53M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.53M
            if (UNLIKELY(ord >= _num_elems)) {
217
537
                break;
218
537
            }
219
220
1.53M
            _buffer[read_count++] =
221
1.53M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.53M
        }
223
224
7.90k
        if (LIKELY(read_count > 0)) {
225
7.90k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
7.90k
                                                   read_count, *dst);
227
7.90k
        }
228
229
7.89k
        *n = read_count;
230
7.89k
        return Status::OK();
231
7.89k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
6.17k
                          MutableColumnPtr& dst) override {
206
6.17k
        DCHECK(_parsed);
207
6.17k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
6.17k
        auto total = *n;
212
6.17k
        auto read_count = 0;
213
6.17k
        _buffer.resize(total);
214
1.17M
        for (size_t i = 0; i < total; ++i) {
215
1.16M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.16M
            if (UNLIKELY(ord >= _num_elems)) {
217
30
                break;
218
30
            }
219
220
1.16M
            _buffer[read_count++] =
221
1.16M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.16M
        }
223
224
6.18k
        if (LIKELY(read_count > 0)) {
225
6.18k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
6.18k
                                                   read_count, *dst);
227
6.18k
        }
228
229
6.17k
        *n = read_count;
230
6.17k
        return Status::OK();
231
6.17k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
6.41k
                          MutableColumnPtr& dst) override {
206
6.41k
        DCHECK(_parsed);
207
6.41k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
6.41k
        auto total = *n;
212
6.41k
        auto read_count = 0;
213
6.41k
        _buffer.resize(total);
214
1.33M
        for (size_t i = 0; i < total; ++i) {
215
1.32M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
1.32M
            if (UNLIKELY(ord >= _num_elems)) {
217
261
                break;
218
261
            }
219
220
1.32M
            _buffer[read_count++] =
221
1.32M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
1.32M
        }
223
224
6.41k
        if (LIKELY(read_count > 0)) {
225
6.41k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
6.41k
                                                   read_count, *dst);
227
6.41k
        }
228
229
6.41k
        *n = read_count;
230
6.41k
        return Status::OK();
231
6.41k
    }
_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.35M
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.35M
        return _cur_idx;
241
1.35M
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE13current_indexEv
Line
Count
Source
238
232k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
232k
        return _cur_idx;
241
232k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE13current_indexEv
Line
Count
Source
238
231k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
231k
        return _cur_idx;
241
231k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE13current_indexEv
Line
Count
Source
238
272k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
272k
        return _cur_idx;
241
272k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE13current_indexEv
Line
Count
Source
238
61.7k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
61.7k
        return _cur_idx;
241
61.7k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE13current_indexEv
Line
Count
Source
238
110k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
110k
        return _cur_idx;
241
110k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE13current_indexEv
Line
Count
Source
238
237k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
237k
        return _cur_idx;
241
237k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE13current_indexEv
Line
Count
Source
238
208k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
208k
        return _cur_idx;
241
208k
    }
_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