Coverage Report

Created: 2026-11-03 12: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
207k
    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
207k
        return reset();
46
207k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
42
20.5k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
20.5k
        return reset();
46
20.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
42
5.63k
    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.63k
        return reset();
46
5.63k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
42
45.5k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
45.5k
        return reset();
46
45.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
42
119k
    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
119k
        return reset();
46
119k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
42
8.26k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
8.26k
        return reset();
46
8.26k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
42
3.08k
    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
3.08k
        return reset();
46
3.08k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
42
4.99k
    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.99k
        return reset();
46
4.99k
    }
_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
947k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE12is_page_fullEv
Line
Count
Source
48
53.7k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE12is_page_fullEv
Line
Count
Source
48
17.0k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE12is_page_fullEv
Line
Count
Source
48
322k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE12is_page_fullEv
Line
Count
Source
48
494k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE12is_page_fullEv
Line
Count
Source
48
16.7k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE12is_page_fullEv
Line
Count
Source
48
6.61k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE12is_page_fullEv
Line
Count
Source
48
33.6k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE12is_page_fullEv
Line
Count
Source
48
391
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE12is_page_fullEv
Line
Count
Source
48
260
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE12is_page_fullEv
Line
Count
Source
48
128
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE12is_page_fullEv
Line
Count
Source
48
120
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE12is_page_fullEv
Line
Count
Source
48
168
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE12is_page_fullEv
Line
Count
Source
48
116
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE12is_page_fullEv
Line
Count
Source
48
136
    bool is_page_full() override { return _remain_element_capacity == 0; }
49
50
474k
    Status add(const uint8_t* vals, size_t* count) override {
51
474k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
474k
        size_t old_size = _buffer.size();
56
474k
        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
474k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
474k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
474k
        _count += to_add;
62
474k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
474k
        *count = to_add;
65
474k
        _remain_element_capacity -= to_add;
66
474k
        return Status::OK();
67
474k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE3addEPKhPm
Line
Count
Source
50
26.8k
    Status add(const uint8_t* vals, size_t* count) override {
51
26.8k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
26.8k
        size_t old_size = _buffer.size();
56
26.8k
        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
26.8k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
26.8k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
26.8k
        _count += to_add;
62
26.8k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
26.8k
        *count = to_add;
65
26.8k
        _remain_element_capacity -= to_add;
66
26.8k
        return Status::OK();
67
26.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE3addEPKhPm
Line
Count
Source
50
8.50k
    Status add(const uint8_t* vals, size_t* count) override {
51
8.50k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
8.50k
        size_t old_size = _buffer.size();
56
8.50k
        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
8.50k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
8.50k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
8.50k
        _count += to_add;
62
8.50k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
8.50k
        *count = to_add;
65
8.50k
        _remain_element_capacity -= to_add;
66
8.50k
        return Status::OK();
67
8.50k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE3addEPKhPm
Line
Count
Source
50
161k
    Status add(const uint8_t* vals, size_t* count) override {
51
161k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
161k
        size_t old_size = _buffer.size();
56
161k
        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
161k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
161k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
161k
        _count += to_add;
62
161k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
161k
        *count = to_add;
65
161k
        _remain_element_capacity -= to_add;
66
161k
        return Status::OK();
67
161k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE3addEPKhPm
Line
Count
Source
50
247k
    Status add(const uint8_t* vals, size_t* count) override {
51
247k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
247k
        size_t old_size = _buffer.size();
56
247k
        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
247k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
247k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
247k
        _count += to_add;
62
247k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
247k
        *count = to_add;
65
247k
        _remain_element_capacity -= to_add;
66
247k
        return Status::OK();
67
247k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE3addEPKhPm
Line
Count
Source
50
8.38k
    Status add(const uint8_t* vals, size_t* count) override {
51
8.38k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
8.38k
        size_t old_size = _buffer.size();
56
8.38k
        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
8.38k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
8.38k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
8.38k
        _count += to_add;
62
8.38k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
8.38k
        *count = to_add;
65
8.38k
        _remain_element_capacity -= to_add;
66
8.38k
        return Status::OK();
67
8.38k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE3addEPKhPm
Line
Count
Source
50
3.31k
    Status add(const uint8_t* vals, size_t* count) override {
51
3.31k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
3.31k
        size_t old_size = _buffer.size();
56
3.31k
        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
3.31k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
3.31k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
3.31k
        _count += to_add;
62
3.31k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
3.31k
        *count = to_add;
65
3.31k
        _remain_element_capacity -= to_add;
66
3.31k
        return Status::OK();
67
3.31k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE3addEPKhPm
Line
Count
Source
50
16.9k
    Status add(const uint8_t* vals, size_t* count) override {
51
16.9k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
16.9k
        size_t old_size = _buffer.size();
56
16.9k
        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.9k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
17.0k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
17.0k
        _count += to_add;
62
17.0k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
17.0k
        *count = to_add;
65
17.0k
        _remain_element_capacity -= to_add;
66
17.0k
        return Status::OK();
67
16.9k
    }
_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
216k
    Status finish(OwnedSlice* slice) override {
70
216k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
216k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
216k
        return Status::OK();
73
216k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
20.5k
    Status finish(OwnedSlice* slice) override {
70
20.5k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
20.5k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
20.5k
        return Status::OK();
73
20.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
5.61k
    Status finish(OwnedSlice* slice) override {
70
5.61k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
5.61k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
5.61k
        return Status::OK();
73
5.61k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
49.5k
    Status finish(OwnedSlice* slice) override {
70
49.5k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
49.5k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
49.5k
        return Status::OK();
73
49.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
123k
    Status finish(OwnedSlice* slice) override {
70
123k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
123k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
123k
        return Status::OK();
73
123k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
8.28k
    Status finish(OwnedSlice* slice) override {
70
8.28k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
8.28k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
8.28k
        return Status::OK();
73
8.28k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
3.06k
    Status finish(OwnedSlice* slice) override {
70
3.06k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
3.06k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
3.06k
        return Status::OK();
73
3.06k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
5.40k
    Status finish(OwnedSlice* slice) override {
70
5.40k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
5.40k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
5.40k
        return Status::OK();
73
5.40k
    }
_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
424k
    Status reset() override {
76
424k
        RETURN_IF_CATCH_EXCEPTION({
77
424k
            _buffer.reserve(_options.data_page_size);
78
424k
            _count = 0;
79
424k
            _raw_data_size = 0;
80
424k
            _buffer.clear();
81
424k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
424k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
424k
        });
84
425k
        return Status::OK();
85
424k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5resetEv
Line
Count
Source
75
41.0k
    Status reset() override {
76
41.0k
        RETURN_IF_CATCH_EXCEPTION({
77
41.0k
            _buffer.reserve(_options.data_page_size);
78
41.0k
            _count = 0;
79
41.0k
            _raw_data_size = 0;
80
41.0k
            _buffer.clear();
81
41.0k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
41.0k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
41.0k
        });
84
41.0k
        return Status::OK();
85
41.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5resetEv
Line
Count
Source
75
11.2k
    Status reset() override {
76
11.2k
        RETURN_IF_CATCH_EXCEPTION({
77
11.2k
            _buffer.reserve(_options.data_page_size);
78
11.2k
            _count = 0;
79
11.2k
            _raw_data_size = 0;
80
11.2k
            _buffer.clear();
81
11.2k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
11.2k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
11.2k
        });
84
11.2k
        return Status::OK();
85
11.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5resetEv
Line
Count
Source
75
95.0k
    Status reset() override {
76
95.0k
        RETURN_IF_CATCH_EXCEPTION({
77
95.0k
            _buffer.reserve(_options.data_page_size);
78
95.0k
            _count = 0;
79
95.0k
            _raw_data_size = 0;
80
95.0k
            _buffer.clear();
81
95.0k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
95.0k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
95.0k
        });
84
95.5k
        return Status::OK();
85
95.0k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5resetEv
Line
Count
Source
75
243k
    Status reset() override {
76
243k
        RETURN_IF_CATCH_EXCEPTION({
77
243k
            _buffer.reserve(_options.data_page_size);
78
243k
            _count = 0;
79
243k
            _raw_data_size = 0;
80
243k
            _buffer.clear();
81
243k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
243k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
243k
        });
84
243k
        return Status::OK();
85
243k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5resetEv
Line
Count
Source
75
16.5k
    Status reset() override {
76
16.5k
        RETURN_IF_CATCH_EXCEPTION({
77
16.5k
            _buffer.reserve(_options.data_page_size);
78
16.5k
            _count = 0;
79
16.5k
            _raw_data_size = 0;
80
16.5k
            _buffer.clear();
81
16.5k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
16.5k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
16.5k
        });
84
16.5k
        return Status::OK();
85
16.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5resetEv
Line
Count
Source
75
6.14k
    Status reset() override {
76
6.14k
        RETURN_IF_CATCH_EXCEPTION({
77
6.14k
            _buffer.reserve(_options.data_page_size);
78
6.14k
            _count = 0;
79
6.14k
            _raw_data_size = 0;
80
6.14k
            _buffer.clear();
81
6.14k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
6.14k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
6.14k
        });
84
6.14k
        return Status::OK();
85
6.14k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5resetEv
Line
Count
Source
75
10.3k
    Status reset() override {
76
10.3k
        RETURN_IF_CATCH_EXCEPTION({
77
10.3k
            _buffer.reserve(_options.data_page_size);
78
10.3k
            _count = 0;
79
10.3k
            _raw_data_size = 0;
80
10.3k
            _buffer.clear();
81
10.3k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10.3k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10.3k
        });
84
10.4k
        return Status::OK();
85
10.3k
    }
_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
8.50k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4sizeEv
Line
Count
Source
89
1.35k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4sizeEv
Line
Count
Source
89
670
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4sizeEv
Line
Count
Source
89
3.18k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4sizeEv
Line
Count
Source
89
1.62k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4sizeEv
Line
Count
Source
89
1.08k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4sizeEv
Line
Count
Source
89
267
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4sizeEv
Line
Count
Source
89
313
    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
216k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE17get_raw_data_sizeEv
Line
Count
Source
91
20.5k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE17get_raw_data_sizeEv
Line
Count
Source
91
5.61k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE17get_raw_data_sizeEv
Line
Count
Source
91
49.5k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE17get_raw_data_sizeEv
Line
Count
Source
91
123k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE17get_raw_data_sizeEv
Line
Count
Source
91
8.28k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE17get_raw_data_sizeEv
Line
Count
Source
91
3.05k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE17get_raw_data_sizeEv
Line
Count
Source
91
5.40k
    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
207k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
20.5k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
5.63k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
45.2k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
119k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
8.23k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
3.08k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
4.99k
    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
263k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
53.3k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
15.5k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
121k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
36.7k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
12.7k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8.59k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
15.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
9
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
12
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
8
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
32
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
6
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
16
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
110
111
262k
    Status init() override {
112
262k
        CHECK(!_parsed);
113
114
262k
        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
262k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
262k
        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
262k
        _parsed = true;
128
129
262k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
262k
        return Status::OK();
131
262k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
111
53.3k
    Status init() override {
112
53.3k
        CHECK(!_parsed);
113
114
53.3k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
53.3k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
53.3k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
53.3k
        _parsed = true;
128
129
53.3k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
53.3k
        return Status::OK();
131
53.3k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
111
15.5k
    Status init() override {
112
15.5k
        CHECK(!_parsed);
113
114
15.5k
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
15.5k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
15.5k
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
15.5k
        _parsed = true;
128
129
15.5k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
15.5k
        return Status::OK();
131
15.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
111
120k
    Status init() override {
112
120k
        CHECK(!_parsed);
113
114
120k
        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
120k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
120k
        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
120k
        _parsed = true;
128
129
120k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
120k
        return Status::OK();
131
120k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
111
36.6k
    Status init() override {
112
36.6k
        CHECK(!_parsed);
113
114
36.6k
        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
36.6k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
36.6k
        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
36.6k
        _parsed = true;
128
129
36.6k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
36.6k
        return Status::OK();
131
36.6k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
111
12.6k
    Status init() override {
112
12.6k
        CHECK(!_parsed);
113
114
12.6k
        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.6k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
12.6k
        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.6k
        _parsed = true;
128
129
12.6k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
12.6k
        return Status::OK();
131
12.6k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
111
8.59k
    Status init() override {
112
8.59k
        CHECK(!_parsed);
113
114
8.59k
        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.59k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8.59k
        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.59k
        _parsed = true;
128
129
8.59k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8.59k
        return Status::OK();
131
8.59k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
111
15.2k
    Status init() override {
112
15.2k
        CHECK(!_parsed);
113
114
15.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
15.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
15.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
15.2k
        _parsed = true;
128
129
15.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
15.2k
        return Status::OK();
131
15.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE4initEv
Line
Count
Source
111
9
    Status init() override {
112
9
        CHECK(!_parsed);
113
114
9
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
9
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
9
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
9
        _parsed = true;
128
129
9
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
9
        return Status::OK();
131
9
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE4initEv
Line
Count
Source
111
12
    Status init() override {
112
12
        CHECK(!_parsed);
113
114
12
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
12
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
12
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
12
        _parsed = true;
128
129
12
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
12
        return Status::OK();
131
12
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE4initEv
Line
Count
Source
111
8
    Status init() override {
112
8
        CHECK(!_parsed);
113
114
8
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
8
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
8
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
8
        _parsed = true;
128
129
8
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
8
        return Status::OK();
131
8
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE4initEv
Line
Count
Source
111
32
    Status init() override {
112
32
        CHECK(!_parsed);
113
114
32
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
32
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
32
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
32
        _parsed = true;
128
129
32
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
32
        return Status::OK();
131
32
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE4initEv
Line
Count
Source
111
6
    Status init() override {
112
6
        CHECK(!_parsed);
113
114
6
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
6
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
6
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
6
        _parsed = true;
128
129
6
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
6
        return Status::OK();
131
6
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE4initEv
Line
Count
Source
111
16
    Status init() override {
112
16
        CHECK(!_parsed);
113
114
16
        if (_data.size < PLAIN_PAGE_HEADER_SIZE) {
115
0
            return Status::InternalError(
116
0
                    "file corruption: not enough bytes for header in PlainPageDecoder ."
117
0
                    "invalid data size:{}, header size:{}",
118
0
                    _data.size, PLAIN_PAGE_HEADER_SIZE);
119
0
        }
120
121
16
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
16
        if (_data.size != PLAIN_PAGE_HEADER_SIZE + _num_elems * SIZE_OF_TYPE) {
124
0
            return Status::InternalError("file corruption: unexpected data size.");
125
0
        }
126
127
16
        _parsed = true;
128
129
16
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
16
        return Status::OK();
131
16
    }
132
133
806k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
806k
        if (_num_elems == 0) [[unlikely]] {
136
8.66k
            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.66k
        }
141
142
806k
        DCHECK_LE(pos, _num_elems);
143
144
806k
        _cur_idx = cast_set<uint32_t>(pos);
145
806k
        return Status::OK();
146
806k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE24seek_to_position_in_pageEm
Line
Count
Source
133
109k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
109k
        if (_num_elems == 0) [[unlikely]] {
136
1.19k
            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.19k
        }
141
142
109k
        DCHECK_LE(pos, _num_elems);
143
144
109k
        _cur_idx = cast_set<uint32_t>(pos);
145
109k
        return Status::OK();
146
109k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE24seek_to_position_in_pageEm
Line
Count
Source
133
18.1k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
18.1k
        if (_num_elems == 0) [[unlikely]] {
136
622
            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
622
        }
141
142
18.1k
        DCHECK_LE(pos, _num_elems);
143
144
18.1k
        _cur_idx = cast_set<uint32_t>(pos);
145
18.1k
        return Status::OK();
146
18.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE24seek_to_position_in_pageEm
Line
Count
Source
133
480k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
480k
        if (_num_elems == 0) [[unlikely]] {
136
3.61k
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
3.61k
        }
141
142
480k
        DCHECK_LE(pos, _num_elems);
143
144
480k
        _cur_idx = cast_set<uint32_t>(pos);
145
480k
        return Status::OK();
146
480k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE24seek_to_position_in_pageEm
Line
Count
Source
133
152k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
152k
        if (_num_elems == 0) [[unlikely]] {
136
1.98k
            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.98k
        }
141
142
152k
        DCHECK_LE(pos, _num_elems);
143
144
152k
        _cur_idx = cast_set<uint32_t>(pos);
145
152k
        return Status::OK();
146
152k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE24seek_to_position_in_pageEm
Line
Count
Source
133
16.0k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
16.0k
        if (_num_elems == 0) [[unlikely]] {
136
447
            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
447
        }
141
142
16.0k
        DCHECK_LE(pos, _num_elems);
143
144
16.0k
        _cur_idx = cast_set<uint32_t>(pos);
145
16.0k
        return Status::OK();
146
16.0k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE24seek_to_position_in_pageEm
Line
Count
Source
133
9.41k
    Status seek_to_position_in_page(size_t pos) override {
134
9.41k
        CHECK(_parsed) << "Must call init()";
135
9.41k
        if (_num_elems == 0) [[unlikely]] {
136
298
            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
298
        }
141
142
9.41k
        DCHECK_LE(pos, _num_elems);
143
144
9.41k
        _cur_idx = cast_set<uint32_t>(pos);
145
9.41k
        return Status::OK();
146
9.41k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE24seek_to_position_in_pageEm
Line
Count
Source
133
19.6k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
19.6k
        if (_num_elems == 0) [[unlikely]] {
136
505
            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
505
        }
141
142
19.6k
        DCHECK_LE(pos, _num_elems);
143
144
19.6k
        _cur_idx = cast_set<uint32_t>(pos);
145
19.6k
        return Status::OK();
146
19.6k
    }
_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
132
        while (left < right) {
164
111
            uint32_t mid = left + (right - left) / 2;
165
111
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
111
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
52
                left = mid + 1;
168
59
            } else {
169
59
                right = mid;
170
59
            }
171
111
        }
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
53
        while (left < right) {
164
48
            uint32_t mid = left + (right - left) / 2;
165
48
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
48
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
26
                left = mid + 1;
168
26
            } else {
169
22
                right = mid;
170
22
            }
171
48
        }
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
23
                left = mid + 1;
168
26
            } else {
169
26
                right = mid;
170
26
            }
171
49
        }
172
5
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
4
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
4
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
3
            *exact_match = true;
178
3
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
4
        _cur_idx = left;
183
4
        return Status::OK();
184
5
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE22seek_at_or_after_valueEPKvPb
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
11
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
11
        DCHECK(_parsed) << "Must call init() firstly";
150
151
11
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
11
        uint32_t left = 0;
156
11
        uint32_t right = _num_elems;
157
158
11
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
25
        while (left < right) {
164
14
            uint32_t mid = left + (right - left) / 2;
165
14
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
14
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
3
                left = mid + 1;
168
11
            } else {
169
11
                right = mid;
170
11
            }
171
14
        }
172
11
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
10
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
10
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
9
            *exact_match = true;
178
9
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
10
        _cur_idx = left;
183
10
        return Status::OK();
184
11
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE22seek_at_or_after_valueEPKvPb
185
186
690k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
690k
        DCHECK(_parsed);
188
691k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
690k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
690k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
690k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
690k
                                               *dst);
197
198
690k
        *n = max_fetch;
199
690k
        _cur_idx += max_fetch;
200
201
690k
        return Status::OK();
202
690k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
110k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
110k
        DCHECK(_parsed);
188
110k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
110k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
110k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
110k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
110k
                                               *dst);
197
198
110k
        *n = max_fetch;
199
110k
        _cur_idx += max_fetch;
200
201
110k
        return Status::OK();
202
110k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
12.4k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
12.4k
        DCHECK(_parsed);
188
12.4k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
12.4k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
12.4k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
12.4k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
12.4k
                                               *dst);
197
198
12.4k
        *n = max_fetch;
199
12.4k
        _cur_idx += max_fetch;
200
201
12.4k
        return Status::OK();
202
12.4k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
448k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
448k
        DCHECK(_parsed);
188
449k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
448k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
448k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
448k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
448k
                                               *dst);
197
198
448k
        *n = max_fetch;
199
448k
        _cur_idx += max_fetch;
200
201
448k
        return Status::OK();
202
448k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
61.8k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
61.8k
        DCHECK(_parsed);
188
61.8k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
61.8k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
61.8k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
61.8k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
61.8k
                                               *dst);
197
198
61.8k
        *n = max_fetch;
199
61.8k
        _cur_idx += max_fetch;
200
201
61.8k
        return Status::OK();
202
61.8k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
11.7k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
11.7k
        DCHECK(_parsed);
188
11.7k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
11.7k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
11.7k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
11.7k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
11.7k
                                               *dst);
197
198
11.7k
        *n = max_fetch;
199
11.7k
        _cur_idx += max_fetch;
200
201
11.7k
        return Status::OK();
202
11.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
6.58k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
6.58k
        DCHECK(_parsed);
188
6.58k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
6.58k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
6.58k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
6.58k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
6.58k
                                               *dst);
197
198
6.58k
        *n = max_fetch;
199
6.58k
        _cur_idx += max_fetch;
200
201
6.58k
        return Status::OK();
202
6.58k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
38.7k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
38.7k
        DCHECK(_parsed);
188
38.8k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
38.7k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
38.7k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
38.7k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
38.7k
                                               *dst);
197
198
38.7k
        *n = max_fetch;
199
38.7k
        _cur_idx += max_fetch;
200
201
38.7k
        return Status::OK();
202
38.7k
    }
_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
207k
                          MutableColumnPtr& dst) override {
206
207k
        DCHECK(_parsed);
207
207k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
207k
        auto total = *n;
212
207k
        auto read_count = 0;
213
207k
        _buffer.resize(total);
214
25.6M
        for (size_t i = 0; i < total; ++i) {
215
25.4M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
25.4M
            if (UNLIKELY(ord >= _num_elems)) {
217
4.11k
                break;
218
4.11k
            }
219
220
25.3M
            _buffer[read_count++] =
221
25.3M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
25.3M
        }
223
224
208k
        if (LIKELY(read_count > 0)) {
225
208k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
208k
                                                   read_count, *dst);
227
208k
        }
228
229
207k
        *n = read_count;
230
207k
        return Status::OK();
231
207k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
16.9k
                          MutableColumnPtr& dst) override {
206
16.9k
        DCHECK(_parsed);
207
16.9k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
16.9k
        auto total = *n;
212
16.9k
        auto read_count = 0;
213
16.9k
        _buffer.resize(total);
214
105k
        for (size_t i = 0; i < total; ++i) {
215
88.6k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
88.6k
            if (UNLIKELY(ord >= _num_elems)) {
217
4
                break;
218
4
            }
219
220
88.6k
            _buffer[read_count++] =
221
88.6k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
88.6k
        }
223
224
16.9k
        if (LIKELY(read_count > 0)) {
225
16.9k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
16.9k
                                                   read_count, *dst);
227
16.9k
        }
228
229
16.9k
        *n = read_count;
230
16.9k
        return Status::OK();
231
16.9k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
7.13k
                          MutableColumnPtr& dst) override {
206
7.13k
        DCHECK(_parsed);
207
7.13k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
7.13k
        auto total = *n;
212
7.13k
        auto read_count = 0;
213
7.13k
        _buffer.resize(total);
214
74.5k
        for (size_t i = 0; i < total; ++i) {
215
67.3k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
67.3k
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
67.3k
            _buffer[read_count++] =
221
67.3k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
67.3k
        }
223
224
7.13k
        if (LIKELY(read_count > 0)) {
225
7.13k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
7.13k
                                                   read_count, *dst);
227
7.13k
        }
228
229
7.13k
        *n = read_count;
230
7.13k
        return Status::OK();
231
7.13k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
60.7k
                          MutableColumnPtr& dst) override {
206
60.7k
        DCHECK(_parsed);
207
60.7k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
60.7k
        auto total = *n;
212
60.7k
        auto read_count = 0;
213
60.7k
        _buffer.resize(total);
214
16.9M
        for (size_t i = 0; i < total; ++i) {
215
16.9M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
16.9M
            if (UNLIKELY(ord >= _num_elems)) {
217
1.73k
                break;
218
1.73k
            }
219
220
16.9M
            _buffer[read_count++] =
221
16.9M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
16.9M
        }
223
224
60.7k
        if (LIKELY(read_count > 0)) {
225
60.7k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
60.7k
                                                   read_count, *dst);
227
60.7k
        }
228
229
60.7k
        *n = read_count;
230
60.7k
        return Status::OK();
231
60.7k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
101k
                          MutableColumnPtr& dst) override {
206
101k
        DCHECK(_parsed);
207
101k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
101k
        auto total = *n;
212
101k
        auto read_count = 0;
213
101k
        _buffer.resize(total);
214
3.14M
        for (size_t i = 0; i < total; ++i) {
215
3.04M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
3.04M
            if (UNLIKELY(ord >= _num_elems)) {
217
1.24k
                break;
218
1.24k
            }
219
220
3.04M
            _buffer[read_count++] =
221
3.04M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
3.04M
        }
223
224
101k
        if (LIKELY(read_count > 0)) {
225
101k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
101k
                                                   read_count, *dst);
227
101k
        }
228
229
101k
        *n = read_count;
230
101k
        return Status::OK();
231
101k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
6.15k
                          MutableColumnPtr& dst) override {
206
6.15k
        DCHECK(_parsed);
207
6.15k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
6.15k
        auto total = *n;
212
6.15k
        auto read_count = 0;
213
6.15k
        _buffer.resize(total);
214
13.9k
        for (size_t i = 0; i < total; ++i) {
215
7.78k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
7.78k
            if (UNLIKELY(ord >= _num_elems)) {
217
3
                break;
218
3
            }
219
220
7.78k
            _buffer[read_count++] =
221
7.78k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
7.78k
        }
223
224
6.15k
        if (LIKELY(read_count > 0)) {
225
6.15k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
6.15k
                                                   read_count, *dst);
227
6.15k
        }
228
229
6.15k
        *n = read_count;
230
6.15k
        return Status::OK();
231
6.15k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
4.37k
                          MutableColumnPtr& dst) override {
206
4.37k
        DCHECK(_parsed);
207
4.37k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
4.37k
        auto total = *n;
212
4.37k
        auto read_count = 0;
213
4.37k
        _buffer.resize(total);
214
15.3k
        for (size_t i = 0; i < total; ++i) {
215
10.9k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
10.9k
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
10.9k
            _buffer[read_count++] =
221
10.9k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
10.9k
        }
223
224
4.37k
        if (LIKELY(read_count > 0)) {
225
4.37k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
4.37k
                                                   read_count, *dst);
227
4.37k
        }
228
229
4.37k
        *n = read_count;
230
4.37k
        return Status::OK();
231
4.37k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
10.4k
                          MutableColumnPtr& dst) override {
206
10.4k
        DCHECK(_parsed);
207
10.4k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
10.4k
        auto total = *n;
212
10.4k
        auto read_count = 0;
213
10.4k
        _buffer.resize(total);
214
5.24M
        for (size_t i = 0; i < total; ++i) {
215
5.23M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
5.23M
            if (UNLIKELY(ord >= _num_elems)) {
217
1.11k
                break;
218
1.11k
            }
219
220
5.23M
            _buffer[read_count++] =
221
5.23M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
5.23M
        }
223
224
10.4k
        if (LIKELY(read_count > 0)) {
225
10.4k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
10.4k
                                                   read_count, *dst);
227
10.4k
        }
228
229
10.4k
        *n = read_count;
230
10.4k
        return Status::OK();
231
10.4k
    }
_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
213k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
213k
        return _cur_idx;
241
213k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE13current_indexEv
Line
Count
Source
238
998
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
998
        return _cur_idx;
241
998
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE13current_indexEv
Line
Count
Source
238
707
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
707
        return _cur_idx;
241
707
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE13current_indexEv
Line
Count
Source
238
40.6k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
40.6k
        return _cur_idx;
241
40.6k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE13current_indexEv
Line
Count
Source
238
167k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
167k
        return _cur_idx;
241
167k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE13current_indexEv
Line
Count
Source
238
348
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
348
        return _cur_idx;
241
348
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE13current_indexEv
Line
Count
Source
238
445
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
445
        return _cur_idx;
241
445
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE13current_indexEv
Line
Count
Source
238
2.11k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
2.11k
        return _cur_idx;
241
2.11k
    }
_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