Coverage Report

Created: 2026-11-05 11:32

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
79.3k
    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
79.3k
        return reset();
46
79.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
42
17.3k
    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
17.3k
        return reset();
46
17.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
42
3.89k
    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.89k
        return reset();
46
3.89k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
42
21.8k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
21.8k
        return reset();
46
21.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
42
26.7k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
26.7k
        return reset();
46
26.7k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
42
6.54k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
6.54k
        return reset();
46
6.54k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
42
1.38k
    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
1.38k
        return reset();
46
1.38k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
42
1.55k
    Status init() override {
43
        // Reserve enough space for the page, plus a bit of slop since
44
        // we often overrun the page by a few values.
45
1.55k
        return reset();
46
1.55k
    }
_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
543k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE12is_page_fullEv
Line
Count
Source
48
40.4k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE12is_page_fullEv
Line
Count
Source
48
8.63k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE12is_page_fullEv
Line
Count
Source
48
246k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE12is_page_fullEv
Line
Count
Source
48
225k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE12is_page_fullEv
Line
Count
Source
48
13.4k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE12is_page_fullEv
Line
Count
Source
48
3.21k
    bool is_page_full() override { return _remain_element_capacity == 0; }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE12is_page_fullEv
Line
Count
Source
48
3.58k
    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
271k
    Status add(const uint8_t* vals, size_t* count) override {
51
271k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
271k
        size_t old_size = _buffer.size();
56
271k
        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
271k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
271k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
271k
        _count += to_add;
62
271k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
271k
        *count = to_add;
65
271k
        _remain_element_capacity -= to_add;
66
271k
        return Status::OK();
67
271k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE3addEPKhPm
Line
Count
Source
50
20.2k
    Status add(const uint8_t* vals, size_t* count) override {
51
20.2k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
20.2k
        size_t old_size = _buffer.size();
56
20.2k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
20.2k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
20.2k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
20.2k
        _count += to_add;
62
20.2k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
20.2k
        *count = to_add;
65
20.2k
        _remain_element_capacity -= to_add;
66
20.2k
        return Status::OK();
67
20.2k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE3addEPKhPm
Line
Count
Source
50
4.31k
    Status add(const uint8_t* vals, size_t* count) override {
51
4.31k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
4.31k
        size_t old_size = _buffer.size();
56
4.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
4.31k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
4.31k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
4.31k
        _count += to_add;
62
4.31k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
4.31k
        *count = to_add;
65
4.31k
        _remain_element_capacity -= to_add;
66
4.31k
        return Status::OK();
67
4.31k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE3addEPKhPm
Line
Count
Source
50
123k
    Status add(const uint8_t* vals, size_t* count) override {
51
123k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
123k
        size_t old_size = _buffer.size();
56
123k
        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
123k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
123k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
123k
        _count += to_add;
62
123k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
123k
        *count = to_add;
65
123k
        _remain_element_capacity -= to_add;
66
123k
        return Status::OK();
67
123k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE3addEPKhPm
Line
Count
Source
50
112k
    Status add(const uint8_t* vals, size_t* count) override {
51
112k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
112k
        size_t old_size = _buffer.size();
56
112k
        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
112k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
112k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
112k
        _count += to_add;
62
112k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
112k
        *count = to_add;
65
112k
        _remain_element_capacity -= to_add;
66
112k
        return Status::OK();
67
112k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE3addEPKhPm
Line
Count
Source
50
6.74k
    Status add(const uint8_t* vals, size_t* count) override {
51
6.74k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
6.74k
        size_t old_size = _buffer.size();
56
6.74k
        size_t to_add = std::min(_remain_element_capacity, *count);
57
        // This may need a large memory, should return error if could not allocated
58
        // successfully, to avoid BE OOM.
59
6.74k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
6.73k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
6.73k
        _count += to_add;
62
6.73k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
6.73k
        *count = to_add;
65
6.73k
        _remain_element_capacity -= to_add;
66
6.73k
        return Status::OK();
67
6.74k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE3addEPKhPm
Line
Count
Source
50
1.60k
    Status add(const uint8_t* vals, size_t* count) override {
51
1.60k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
1.60k
        size_t old_size = _buffer.size();
56
1.60k
        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
1.60k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
1.60k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
1.60k
        _count += to_add;
62
1.60k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
1.60k
        *count = to_add;
65
1.60k
        _remain_element_capacity -= to_add;
66
1.60k
        return Status::OK();
67
1.60k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE3addEPKhPm
Line
Count
Source
50
1.79k
    Status add(const uint8_t* vals, size_t* count) override {
51
1.79k
        if (is_page_full() || *count == 0) {
52
0
            *count = 0;
53
0
            return Status::OK();
54
0
        }
55
1.79k
        size_t old_size = _buffer.size();
56
1.79k
        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
1.79k
        RETURN_IF_CATCH_EXCEPTION(_buffer.resize(old_size + to_add * SIZE_OF_TYPE));
60
1.79k
        memcpy(&_buffer[old_size], vals, to_add * SIZE_OF_TYPE);
61
1.79k
        _count += to_add;
62
1.79k
        _raw_data_size += to_add * SIZE_OF_TYPE;
63
64
1.79k
        *count = to_add;
65
1.79k
        _remain_element_capacity -= to_add;
66
1.79k
        return Status::OK();
67
1.79k
    }
_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
80.6k
    Status finish(OwnedSlice* slice) override {
70
80.6k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
80.6k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
80.6k
        return Status::OK();
73
80.6k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
17.3k
    Status finish(OwnedSlice* slice) override {
70
17.3k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
17.3k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
17.3k
        return Status::OK();
73
17.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
3.85k
    Status finish(OwnedSlice* slice) override {
70
3.85k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
3.85k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
3.85k
        return Status::OK();
73
3.85k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
22.5k
    Status finish(OwnedSlice* slice) override {
70
22.5k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
22.5k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
22.5k
        return Status::OK();
73
22.5k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
27.1k
    Status finish(OwnedSlice* slice) override {
70
27.1k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
27.1k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
27.1k
        return Status::OK();
73
27.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
6.58k
    Status finish(OwnedSlice* slice) override {
70
6.58k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
6.58k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
6.58k
        return Status::OK();
73
6.58k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
1.34k
    Status finish(OwnedSlice* slice) override {
70
1.34k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
1.34k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
1.34k
        return Status::OK();
73
1.34k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE6finishEPNS_10OwnedSliceE
Line
Count
Source
69
1.57k
    Status finish(OwnedSlice* slice) override {
70
1.57k
        encode_fixed32_le((uint8_t*)&_buffer[0], cast_set<uint32_t>(_count));
71
1.57k
        RETURN_IF_CATCH_EXCEPTION({ *slice = _buffer.build(); });
72
1.57k
        return Status::OK();
73
1.57k
    }
_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
159k
    Status reset() override {
76
159k
        RETURN_IF_CATCH_EXCEPTION({
77
159k
            _buffer.reserve(_options.data_page_size);
78
159k
            _count = 0;
79
159k
            _raw_data_size = 0;
80
159k
            _buffer.clear();
81
159k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
159k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
159k
        });
84
160k
        return Status::OK();
85
159k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5resetEv
Line
Count
Source
75
34.7k
    Status reset() override {
76
34.7k
        RETURN_IF_CATCH_EXCEPTION({
77
34.7k
            _buffer.reserve(_options.data_page_size);
78
34.7k
            _count = 0;
79
34.7k
            _raw_data_size = 0;
80
34.7k
            _buffer.clear();
81
34.7k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
34.7k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
34.7k
        });
84
34.7k
        return Status::OK();
85
34.7k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5resetEv
Line
Count
Source
75
7.75k
    Status reset() override {
76
7.75k
        RETURN_IF_CATCH_EXCEPTION({
77
7.75k
            _buffer.reserve(_options.data_page_size);
78
7.75k
            _count = 0;
79
7.75k
            _raw_data_size = 0;
80
7.75k
            _buffer.clear();
81
7.75k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
7.75k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
7.75k
        });
84
7.75k
        return Status::OK();
85
7.75k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5resetEv
Line
Count
Source
75
44.3k
    Status reset() override {
76
44.3k
        RETURN_IF_CATCH_EXCEPTION({
77
44.3k
            _buffer.reserve(_options.data_page_size);
78
44.3k
            _count = 0;
79
44.3k
            _raw_data_size = 0;
80
44.3k
            _buffer.clear();
81
44.3k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
44.3k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
44.3k
        });
84
44.4k
        return Status::OK();
85
44.3k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5resetEv
Line
Count
Source
75
53.8k
    Status reset() override {
76
53.8k
        RETURN_IF_CATCH_EXCEPTION({
77
53.8k
            _buffer.reserve(_options.data_page_size);
78
53.8k
            _count = 0;
79
53.8k
            _raw_data_size = 0;
80
53.8k
            _buffer.clear();
81
53.8k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
53.8k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
53.8k
        });
84
53.9k
        return Status::OK();
85
53.8k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5resetEv
Line
Count
Source
75
13.1k
    Status reset() override {
76
13.1k
        RETURN_IF_CATCH_EXCEPTION({
77
13.1k
            _buffer.reserve(_options.data_page_size);
78
13.1k
            _count = 0;
79
13.1k
            _raw_data_size = 0;
80
13.1k
            _buffer.clear();
81
13.1k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
13.1k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
13.1k
        });
84
13.1k
        return Status::OK();
85
13.1k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5resetEv
Line
Count
Source
75
2.73k
    Status reset() override {
76
2.73k
        RETURN_IF_CATCH_EXCEPTION({
77
2.73k
            _buffer.reserve(_options.data_page_size);
78
2.73k
            _count = 0;
79
2.73k
            _raw_data_size = 0;
80
2.73k
            _buffer.clear();
81
2.73k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
2.73k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
2.73k
        });
84
2.73k
        return Status::OK();
85
2.73k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5resetEv
Line
Count
Source
75
3.12k
    Status reset() override {
76
3.12k
        RETURN_IF_CATCH_EXCEPTION({
77
3.12k
            _buffer.reserve(_options.data_page_size);
78
3.12k
            _count = 0;
79
3.12k
            _raw_data_size = 0;
80
3.12k
            _buffer.clear();
81
3.12k
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
3.12k
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
3.12k
        });
84
3.12k
        return Status::OK();
85
3.12k
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE5resetEv
Line
Count
Source
75
11
    Status reset() override {
76
11
        RETURN_IF_CATCH_EXCEPTION({
77
11
            _buffer.reserve(_options.data_page_size);
78
11
            _count = 0;
79
11
            _raw_data_size = 0;
80
11
            _buffer.clear();
81
11
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
11
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
11
        });
84
11
        return Status::OK();
85
11
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE5resetEv
Line
Count
Source
75
64
    Status reset() override {
76
64
        RETURN_IF_CATCH_EXCEPTION({
77
64
            _buffer.reserve(_options.data_page_size);
78
64
            _count = 0;
79
64
            _raw_data_size = 0;
80
64
            _buffer.clear();
81
64
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
64
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
64
        });
84
64
        return Status::OK();
85
64
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE5resetEv
Line
Count
Source
75
14
    Status reset() override {
76
14
        RETURN_IF_CATCH_EXCEPTION({
77
14
            _buffer.reserve(_options.data_page_size);
78
14
            _count = 0;
79
14
            _raw_data_size = 0;
80
14
            _buffer.clear();
81
14
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
14
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
14
        });
84
14
        return Status::OK();
85
14
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE5resetEv
Line
Count
Source
75
10
    Status reset() override {
76
10
        RETURN_IF_CATCH_EXCEPTION({
77
10
            _buffer.reserve(_options.data_page_size);
78
10
            _count = 0;
79
10
            _raw_data_size = 0;
80
10
            _buffer.clear();
81
10
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
10
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
10
        });
84
10
        return Status::OK();
85
10
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE5resetEv
Line
Count
Source
75
34
    Status reset() override {
76
34
        RETURN_IF_CATCH_EXCEPTION({
77
34
            _buffer.reserve(_options.data_page_size);
78
34
            _count = 0;
79
34
            _raw_data_size = 0;
80
34
            _buffer.clear();
81
34
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
34
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
34
        });
84
34
        return Status::OK();
85
34
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE5resetEv
Line
Count
Source
75
8
    Status reset() override {
76
8
        RETURN_IF_CATCH_EXCEPTION({
77
8
            _buffer.reserve(_options.data_page_size);
78
8
            _count = 0;
79
8
            _raw_data_size = 0;
80
8
            _buffer.clear();
81
8
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
8
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
8
        });
84
8
        return Status::OK();
85
8
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE5resetEv
Line
Count
Source
75
18
    Status reset() override {
76
18
        RETURN_IF_CATCH_EXCEPTION({
77
18
            _buffer.reserve(_options.data_page_size);
78
18
            _count = 0;
79
18
            _raw_data_size = 0;
80
18
            _buffer.clear();
81
18
            _buffer.resize(PLAIN_PAGE_HEADER_SIZE);
82
18
            _remain_element_capacity = _options.data_page_size / SIZE_OF_TYPE;
83
18
        });
84
18
        return Status::OK();
85
18
    }
86
87
32
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE5countEv
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE5countEv
Line
Count
Source
87
5
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE24EE5countEv
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE14EE5countEv
Line
Count
Source
87
27
    size_t count() const override { return _count; }
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE28EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE29EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE41EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE15EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE40EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE16EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE31EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE32EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE33EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE37EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE38EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE39EE5countEv
Unexecuted instantiation: _ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE42EE5countEv
88
89
7.87k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE4sizeEv
Line
Count
Source
89
1.80k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE4sizeEv
Line
Count
Source
89
808
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE4sizeEv
Line
Count
Source
89
2.13k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE4sizeEv
Line
Count
Source
89
1.21k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE4sizeEv
Line
Count
Source
89
1.42k
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE4sizeEv
Line
Count
Source
89
271
    uint64_t size() const override { return _buffer.size(); }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE4sizeEv
Line
Count
Source
89
207
    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
80.6k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EE17get_raw_data_sizeEv
Line
Count
Source
91
17.3k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EE17get_raw_data_sizeEv
Line
Count
Source
91
3.85k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EE17get_raw_data_sizeEv
Line
Count
Source
91
22.5k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EE17get_raw_data_sizeEv
Line
Count
Source
91
27.1k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EE17get_raw_data_sizeEv
Line
Count
Source
91
6.58k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EE17get_raw_data_sizeEv
Line
Count
Source
91
1.34k
    uint64_t get_raw_data_size() const override { return _raw_data_size; }
_ZNK5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EE17get_raw_data_sizeEv
Line
Count
Source
91
1.56k
    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
79.2k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE1EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
17.3k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE3EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
3.89k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE5EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
21.7k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE7EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
26.6k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE9EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
6.54k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE10EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
1.38k
    PlainPageBuilder(const PageBuilderOptions& options) : _options(options) {}
_ZN5doris10segment_v216PlainPageBuilderILNS_9FieldTypeE11EEC2ERKNS0_18PageBuilderOptionsE
Line
Count
Source
94
1.55k
    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
131k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
37.2k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
9.23k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
49.5k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
19.3k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
7.90k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
3.35k
            : _data(data), _options(options), _parsed(false), _num_elems(0), _cur_idx(0) {}
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EEC2ENS_5SliceERKNS0_18PageDecoderOptionsE
Line
Count
Source
109
4.51k
            : _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
131k
    Status init() override {
112
131k
        CHECK(!_parsed);
113
114
131k
        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
131k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
131k
        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
131k
        _parsed = true;
128
129
131k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
131k
        return Status::OK();
131
131k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE4initEv
Line
Count
Source
111
37.2k
    Status init() override {
112
37.2k
        CHECK(!_parsed);
113
114
37.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
37.2k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
37.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
37.2k
        _parsed = true;
128
129
37.2k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
37.2k
        return Status::OK();
131
37.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE4initEv
Line
Count
Source
111
9.23k
    Status init() override {
112
9.23k
        CHECK(!_parsed);
113
114
9.23k
        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.23k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
9.23k
        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.23k
        _parsed = true;
128
129
9.23k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
9.23k
        return Status::OK();
131
9.23k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE4initEv
Line
Count
Source
111
49.5k
    Status init() override {
112
49.5k
        CHECK(!_parsed);
113
114
49.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
49.5k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
49.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
49.5k
        _parsed = true;
128
129
49.5k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
49.5k
        return Status::OK();
131
49.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE4initEv
Line
Count
Source
111
19.3k
    Status init() override {
112
19.3k
        CHECK(!_parsed);
113
114
19.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
19.3k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
19.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
19.3k
        _parsed = true;
128
129
19.3k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
19.3k
        return Status::OK();
131
19.3k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE4initEv
Line
Count
Source
111
7.90k
    Status init() override {
112
7.90k
        CHECK(!_parsed);
113
114
7.90k
        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
7.90k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
7.90k
        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
7.90k
        _parsed = true;
128
129
7.90k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
7.90k
        return Status::OK();
131
7.90k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE4initEv
Line
Count
Source
111
3.35k
    Status init() override {
112
3.35k
        CHECK(!_parsed);
113
114
3.35k
        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
3.35k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
3.35k
        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
3.35k
        _parsed = true;
128
129
3.35k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
3.35k
        return Status::OK();
131
3.35k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE4initEv
Line
Count
Source
111
4.51k
    Status init() override {
112
4.51k
        CHECK(!_parsed);
113
114
4.51k
        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
4.51k
        _num_elems = decode_fixed32_le((const uint8_t*)&_data[0]);
122
123
4.51k
        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
4.51k
        _parsed = true;
128
129
4.51k
        RETURN_IF_ERROR(seek_to_position_in_page(0));
130
4.51k
        return Status::OK();
131
4.51k
    }
_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
337k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
337k
        if (_num_elems == 0) [[unlikely]] {
136
4.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
4.66k
        }
141
142
337k
        DCHECK_LE(pos, _num_elems);
143
144
337k
        _cur_idx = cast_set<uint32_t>(pos);
145
337k
        return Status::OK();
146
337k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE24seek_to_position_in_pageEm
Line
Count
Source
133
48.2k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
48.2k
        if (_num_elems == 0) [[unlikely]] {
136
1.01k
            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.01k
        }
141
142
48.2k
        DCHECK_LE(pos, _num_elems);
143
144
48.2k
        _cur_idx = cast_set<uint32_t>(pos);
145
48.2k
        return Status::OK();
146
48.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE24seek_to_position_in_pageEm
Line
Count
Source
133
9.67k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
9.67k
        if (_num_elems == 0) [[unlikely]] {
136
359
            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
359
        }
141
142
9.67k
        DCHECK_LE(pos, _num_elems);
143
144
9.67k
        _cur_idx = cast_set<uint32_t>(pos);
145
9.67k
        return Status::OK();
146
9.67k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE24seek_to_position_in_pageEm
Line
Count
Source
133
236k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
236k
        if (_num_elems == 0) [[unlikely]] {
136
1.31k
            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.31k
        }
141
142
236k
        DCHECK_LE(pos, _num_elems);
143
144
236k
        _cur_idx = cast_set<uint32_t>(pos);
145
236k
        return Status::OK();
146
236k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE24seek_to_position_in_pageEm
Line
Count
Source
133
24.1k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
24.1k
        if (_num_elems == 0) [[unlikely]] {
136
1.39k
            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.39k
        }
141
142
24.1k
        DCHECK_LE(pos, _num_elems);
143
144
24.1k
        _cur_idx = cast_set<uint32_t>(pos);
145
24.1k
        return Status::OK();
146
24.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE24seek_to_position_in_pageEm
Line
Count
Source
133
10.1k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
10.1k
        if (_num_elems == 0) [[unlikely]] {
136
229
            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
229
        }
141
142
10.1k
        DCHECK_LE(pos, _num_elems);
143
144
10.1k
        _cur_idx = cast_set<uint32_t>(pos);
145
10.1k
        return Status::OK();
146
10.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE24seek_to_position_in_pageEm
Line
Count
Source
133
3.74k
    Status seek_to_position_in_page(size_t pos) override {
134
18.4E
        CHECK(_parsed) << "Must call init()";
135
3.74k
        if (_num_elems == 0) [[unlikely]] {
136
105
            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
105
        }
141
142
3.74k
        DCHECK_LE(pos, _num_elems);
143
144
3.74k
        _cur_idx = cast_set<uint32_t>(pos);
145
3.74k
        return Status::OK();
146
3.74k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE24seek_to_position_in_pageEm
Line
Count
Source
133
4.92k
    Status seek_to_position_in_page(size_t pos) override {
134
4.92k
        CHECK(_parsed) << "Must call init()";
135
4.92k
        if (_num_elems == 0) [[unlikely]] {
136
240
            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
240
        }
141
142
4.92k
        DCHECK_LE(pos, _num_elems);
143
144
4.92k
        _cur_idx = cast_set<uint32_t>(pos);
145
4.92k
        return Status::OK();
146
4.92k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE24seek_to_position_in_pageEm
Line
Count
Source
133
103
    Status seek_to_position_in_page(size_t pos) override {
134
103
        CHECK(_parsed) << "Must call init()";
135
103
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
103
        DCHECK_LE(pos, _num_elems);
143
144
103
        _cur_idx = cast_set<uint32_t>(pos);
145
103
        return Status::OK();
146
103
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE24seek_to_position_in_pageEm
Line
Count
Source
133
45
    Status seek_to_position_in_page(size_t pos) override {
134
45
        CHECK(_parsed) << "Must call init()";
135
45
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
45
        DCHECK_LE(pos, _num_elems);
143
144
45
        _cur_idx = cast_set<uint32_t>(pos);
145
45
        return Status::OK();
146
45
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE24seek_to_position_in_pageEm
Line
Count
Source
133
39
    Status seek_to_position_in_page(size_t pos) override {
134
39
        CHECK(_parsed) << "Must call init()";
135
39
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
39
        DCHECK_LE(pos, _num_elems);
143
144
39
        _cur_idx = cast_set<uint32_t>(pos);
145
39
        return Status::OK();
146
39
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE24seek_to_position_in_pageEm
Line
Count
Source
133
37
    Status seek_to_position_in_page(size_t pos) override {
134
37
        CHECK(_parsed) << "Must call init()";
135
37
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
37
        DCHECK_LE(pos, _num_elems);
143
144
37
        _cur_idx = cast_set<uint32_t>(pos);
145
37
        return Status::OK();
146
37
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE24seek_to_position_in_pageEm
Line
Count
Source
133
69
    Status seek_to_position_in_page(size_t pos) override {
134
69
        CHECK(_parsed) << "Must call init()";
135
69
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
69
        DCHECK_LE(pos, _num_elems);
143
144
69
        _cur_idx = cast_set<uint32_t>(pos);
145
69
        return Status::OK();
146
69
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE24seek_to_position_in_pageEm
Line
Count
Source
133
34
    Status seek_to_position_in_page(size_t pos) override {
134
34
        CHECK(_parsed) << "Must call init()";
135
34
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
34
        DCHECK_LE(pos, _num_elems);
143
144
34
        _cur_idx = cast_set<uint32_t>(pos);
145
34
        return Status::OK();
146
34
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE24seek_to_position_in_pageEm
Line
Count
Source
133
47
    Status seek_to_position_in_page(size_t pos) override {
134
47
        CHECK(_parsed) << "Must call init()";
135
47
        if (_num_elems == 0) [[unlikely]] {
136
0
            if (pos != 0) {
137
0
                return Status::Error<ErrorCode::INTERNAL_ERROR, false>(
138
0
                        "seek pos {} is larger than total elements  {}", pos, _num_elems);
139
0
            }
140
0
        }
141
142
47
        DCHECK_LE(pos, _num_elems);
143
144
47
        _cur_idx = cast_set<uint32_t>(pos);
145
47
        return Status::OK();
146
47
    }
147
148
21
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
21
        DCHECK(_parsed) << "Must call init() firstly";
150
151
21
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
21
        uint32_t left = 0;
156
21
        uint32_t right = _num_elems;
157
158
21
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
133
        while (left < right) {
164
112
            uint32_t mid = left + (right - left) / 2;
165
112
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
112
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
48
                left = mid + 1;
168
64
            } else {
169
64
                right = mid;
170
64
            }
171
112
        }
172
21
        if (left >= _num_elems) {
173
3
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
3
        }
175
18
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
18
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
15
            *exact_match = true;
178
15
        } else {
179
3
            *exact_match = false;
180
3
        }
181
182
18
        _cur_idx = left;
183
18
        return Status::OK();
184
21
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE22seek_at_or_after_valueEPKvPb
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
5
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
5
        DCHECK(_parsed) << "Must call init() firstly";
150
151
5
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
5
        uint32_t left = 0;
156
5
        uint32_t right = _num_elems;
157
158
5
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
54
        while (left < right) {
164
49
            uint32_t mid = left + (right - left) / 2;
165
49
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
49
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
21
                left = mid + 1;
168
28
            } else {
169
28
                right = mid;
170
28
            }
171
49
        }
172
5
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
4
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
4
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
3
            *exact_match = true;
178
3
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
4
        _cur_idx = left;
183
4
        return Status::OK();
184
5
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
5
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
5
        DCHECK(_parsed) << "Must call init() firstly";
150
151
5
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
5
        uint32_t left = 0;
156
5
        uint32_t right = _num_elems;
157
158
5
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
54
        while (left < right) {
164
49
            uint32_t mid = left + (right - left) / 2;
165
49
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
49
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
25
                left = mid + 1;
168
25
            } else {
169
24
                right = mid;
170
24
            }
171
49
        }
172
5
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
4
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
4
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
3
            *exact_match = true;
178
3
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
4
        _cur_idx = left;
183
4
        return Status::OK();
184
5
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE22seek_at_or_after_valueEPKvPb
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE24EE22seek_at_or_after_valueEPKvPb
Line
Count
Source
148
11
    Status seek_at_or_after_value(const void* value, bool* exact_match) override {
149
11
        DCHECK(_parsed) << "Must call init() firstly";
150
151
11
        if (_num_elems == 0) {
152
0
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("page is empty");
153
0
        }
154
155
11
        uint32_t left = 0;
156
11
        uint32_t right = _num_elems;
157
158
11
        const void* mid_value = nullptr;
159
160
        // find the first value >= target. after loop,
161
        // - left == index of first value >= target when found
162
        // - left == _num_elems when not found (all values < target)
163
25
        while (left < right) {
164
14
            uint32_t mid = left + (right - left) / 2;
165
14
            mid_value = &_data[PLAIN_PAGE_HEADER_SIZE + mid * SIZE_OF_TYPE];
166
14
            if (TypeTraits<Type>::cmp(mid_value, value) < 0) {
167
2
                left = mid + 1;
168
12
            } else {
169
12
                right = mid;
170
12
            }
171
14
        }
172
11
        if (left >= _num_elems) {
173
1
            return Status::Error<ErrorCode::ENTRY_NOT_FOUND>("all value small than the value");
174
1
        }
175
10
        const void* find_value = &_data[PLAIN_PAGE_HEADER_SIZE + left * SIZE_OF_TYPE];
176
10
        if (TypeTraits<Type>::cmp(find_value, value) == 0) {
177
9
            *exact_match = true;
178
9
        } else {
179
1
            *exact_match = false;
180
1
        }
181
182
10
        _cur_idx = left;
183
10
        return Status::OK();
184
11
    }
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE14EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE28EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE29EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE41EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE15EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE40EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE16EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE31EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE32EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE33EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE37EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE38EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE39EE22seek_at_or_after_valueEPKvPb
Unexecuted instantiation: _ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE42EE22seek_at_or_after_valueEPKvPb
185
186
287k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
287k
        DCHECK(_parsed);
188
288k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
287k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
287k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
287k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
287k
                                               *dst);
197
198
287k
        *n = max_fetch;
199
287k
        _cur_idx += max_fetch;
200
201
287k
        return Status::OK();
202
287k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
34.1k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
34.1k
        DCHECK(_parsed);
188
34.1k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
34.1k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
34.1k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
34.1k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
34.1k
                                               *dst);
197
198
34.1k
        *n = max_fetch;
199
34.1k
        _cur_idx += max_fetch;
200
201
34.1k
        return Status::OK();
202
34.1k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
6.34k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
6.34k
        DCHECK(_parsed);
188
6.34k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
6.34k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
6.34k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
6.34k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
6.34k
                                               *dst);
197
198
6.34k
        *n = max_fetch;
199
6.34k
        _cur_idx += max_fetch;
200
201
6.34k
        return Status::OK();
202
6.34k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
216k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
216k
        DCHECK(_parsed);
188
218k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
216k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
216k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
216k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
216k
                                               *dst);
197
198
216k
        *n = max_fetch;
199
216k
        _cur_idx += max_fetch;
200
201
216k
        return Status::OK();
202
216k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
15.6k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
15.6k
        DCHECK(_parsed);
188
15.6k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
15.6k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
15.6k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
15.6k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
15.6k
                                               *dst);
197
198
15.6k
        *n = max_fetch;
199
15.6k
        _cur_idx += max_fetch;
200
201
15.6k
        return Status::OK();
202
15.6k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
7.84k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
7.84k
        DCHECK(_parsed);
188
7.84k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
7.84k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
7.84k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
7.84k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
7.84k
                                               *dst);
197
198
7.84k
        *n = max_fetch;
199
7.84k
        _cur_idx += max_fetch;
200
201
7.84k
        return Status::OK();
202
7.84k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
2.88k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
2.88k
        DCHECK(_parsed);
188
2.88k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
2.88k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
2.88k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
2.88k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
2.88k
                                               *dst);
197
198
2.88k
        *n = max_fetch;
199
2.88k
        _cur_idx += max_fetch;
200
201
2.88k
        return Status::OK();
202
2.88k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE10next_batchEPmRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EE
Line
Count
Source
186
2.94k
    Status next_batch(size_t* n, MutableColumnPtr& dst) override {
187
2.94k
        DCHECK(_parsed);
188
2.94k
        if (*n == 0 || _cur_idx >= _num_elems) [[unlikely]] {
189
0
            return Status::OK();
190
0
        }
191
192
2.94k
        size_t max_fetch = std::min(*n, static_cast<size_t>(_num_elems - _cur_idx));
193
2.94k
        const void* src_data = &_data[PLAIN_PAGE_HEADER_SIZE + _cur_idx * SIZE_OF_TYPE];
194
195
2.94k
        StorageLayout<Type>::storage_to_column(static_cast<const uint8_t*>(src_data), max_fetch,
196
2.94k
                                               *dst);
197
198
2.94k
        *n = max_fetch;
199
2.94k
        _cur_idx += max_fetch;
200
201
2.94k
        return Status::OK();
202
2.94k
    }
_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
59.5k
                          MutableColumnPtr& dst) override {
206
59.5k
        DCHECK(_parsed);
207
59.5k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
59.5k
        auto total = *n;
212
59.5k
        auto read_count = 0;
213
59.5k
        _buffer.resize(total);
214
7.95M
        for (size_t i = 0; i < total; ++i) {
215
7.90M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
7.90M
            if (UNLIKELY(ord >= _num_elems)) {
217
859
                break;
218
859
            }
219
220
7.89M
            _buffer[read_count++] =
221
7.89M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
7.89M
        }
223
224
59.5k
        if (LIKELY(read_count > 0)) {
225
59.5k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
59.5k
                                                   read_count, *dst);
227
59.5k
        }
228
229
59.5k
        *n = read_count;
230
59.5k
        return Status::OK();
231
59.5k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
13.9k
                          MutableColumnPtr& dst) override {
206
13.9k
        DCHECK(_parsed);
207
13.9k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
13.9k
        auto total = *n;
212
13.9k
        auto read_count = 0;
213
13.9k
        _buffer.resize(total);
214
114k
        for (size_t i = 0; i < total; ++i) {
215
100k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
100k
            if (UNLIKELY(ord >= _num_elems)) {
217
2
                break;
218
2
            }
219
220
100k
            _buffer[read_count++] =
221
100k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
100k
        }
223
224
14.0k
        if (LIKELY(read_count > 0)) {
225
14.0k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
14.0k
                                                   read_count, *dst);
227
14.0k
        }
228
229
13.9k
        *n = read_count;
230
13.9k
        return Status::OK();
231
13.9k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
3.88k
                          MutableColumnPtr& dst) override {
206
3.88k
        DCHECK(_parsed);
207
3.88k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
3.88k
        auto total = *n;
212
3.88k
        auto read_count = 0;
213
3.88k
        _buffer.resize(total);
214
69.2k
        for (size_t i = 0; i < total; ++i) {
215
65.3k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
65.3k
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
65.3k
            _buffer[read_count++] =
221
65.3k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
65.3k
        }
223
224
3.89k
        if (LIKELY(read_count > 0)) {
225
3.89k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
3.89k
                                                   read_count, *dst);
227
3.89k
        }
228
229
3.88k
        *n = read_count;
230
3.88k
        return Status::OK();
231
3.88k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
24.2k
                          MutableColumnPtr& dst) override {
206
24.2k
        DCHECK(_parsed);
207
24.2k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
24.2k
        auto total = *n;
212
24.2k
        auto read_count = 0;
213
24.2k
        _buffer.resize(total);
214
7.59M
        for (size_t i = 0; i < total; ++i) {
215
7.57M
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
7.57M
            if (UNLIKELY(ord >= _num_elems)) {
217
816
                break;
218
816
            }
219
220
7.56M
            _buffer[read_count++] =
221
7.56M
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
7.56M
        }
223
224
24.2k
        if (LIKELY(read_count > 0)) {
225
24.2k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
24.2k
                                                   read_count, *dst);
227
24.2k
        }
228
229
24.2k
        *n = read_count;
230
24.2k
        return Status::OK();
231
24.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
11.2k
                          MutableColumnPtr& dst) override {
206
11.2k
        DCHECK(_parsed);
207
11.2k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
11.2k
        auto total = *n;
212
11.2k
        auto read_count = 0;
213
11.2k
        _buffer.resize(total);
214
150k
        for (size_t i = 0; i < total; ++i) {
215
139k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
139k
            if (UNLIKELY(ord >= _num_elems)) {
217
15
                break;
218
15
            }
219
220
139k
            _buffer[read_count++] =
221
139k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
139k
        }
223
224
11.2k
        if (LIKELY(read_count > 0)) {
225
11.2k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
11.2k
                                                   read_count, *dst);
227
11.2k
        }
228
229
11.2k
        *n = read_count;
230
11.2k
        return Status::OK();
231
11.2k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
2.40k
                          MutableColumnPtr& dst) override {
206
2.40k
        DCHECK(_parsed);
207
2.40k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
2.40k
        auto total = *n;
212
2.40k
        auto read_count = 0;
213
2.40k
        _buffer.resize(total);
214
7.66k
        for (size_t i = 0; i < total; ++i) {
215
5.26k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
5.26k
            if (UNLIKELY(ord >= _num_elems)) {
217
3
                break;
218
3
            }
219
220
5.26k
            _buffer[read_count++] =
221
5.26k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
5.26k
        }
223
224
2.40k
        if (LIKELY(read_count > 0)) {
225
2.40k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
2.40k
                                                   read_count, *dst);
227
2.40k
        }
228
229
2.40k
        *n = read_count;
230
2.40k
        return Status::OK();
231
2.40k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
1.21k
                          MutableColumnPtr& dst) override {
206
1.21k
        DCHECK(_parsed);
207
1.21k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
1.21k
        auto total = *n;
212
1.21k
        auto read_count = 0;
213
1.21k
        _buffer.resize(total);
214
8.77k
        for (size_t i = 0; i < total; ++i) {
215
7.56k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
7.56k
            if (UNLIKELY(ord >= _num_elems)) {
217
0
                break;
218
0
            }
219
220
7.56k
            _buffer[read_count++] =
221
7.56k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
7.56k
        }
223
224
1.21k
        if (LIKELY(read_count > 0)) {
225
1.21k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
1.21k
                                                   read_count, *dst);
227
1.21k
        }
228
229
1.21k
        *n = read_count;
230
1.21k
        return Status::OK();
231
1.21k
    }
_ZN5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE14read_by_rowidsEPKjmPmRNS_3COWINS_7IColumnEE11mutable_ptrIS8_EE
Line
Count
Source
205
2.02k
                          MutableColumnPtr& dst) override {
206
2.02k
        DCHECK(_parsed);
207
2.02k
        if (*n == 0) [[unlikely]] {
208
0
            return Status::OK();
209
0
        }
210
211
2.02k
        auto total = *n;
212
2.02k
        auto read_count = 0;
213
2.02k
        _buffer.resize(total);
214
10.5k
        for (size_t i = 0; i < total; ++i) {
215
8.50k
            ordinal_t ord = rowids[i] - page_first_ordinal;
216
8.50k
            if (UNLIKELY(ord >= _num_elems)) {
217
1
                break;
218
1
            }
219
220
8.50k
            _buffer[read_count++] =
221
8.50k
                    unaligned_load<CppType>(&_data[PLAIN_PAGE_HEADER_SIZE + ord * SIZE_OF_TYPE]);
222
8.50k
        }
223
224
2.02k
        if (LIKELY(read_count > 0)) {
225
2.02k
            StorageLayout<Type>::storage_to_column(reinterpret_cast<const uint8_t*>(_buffer.data()),
226
2.02k
                                                   read_count, *dst);
227
2.02k
        }
228
229
2.02k
        *n = read_count;
230
2.02k
        return Status::OK();
231
2.02k
    }
_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
6.91k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
6.91k
        return _cur_idx;
241
6.91k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE1EE13current_indexEv
Line
Count
Source
238
1.02k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.02k
        return _cur_idx;
241
1.02k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE3EE13current_indexEv
Line
Count
Source
238
545
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
545
        return _cur_idx;
241
545
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE5EE13current_indexEv
Line
Count
Source
238
1.65k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.65k
        return _cur_idx;
241
1.65k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE7EE13current_indexEv
Line
Count
Source
238
1.89k
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
1.89k
        return _cur_idx;
241
1.89k
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE9EE13current_indexEv
Line
Count
Source
238
160
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
160
        return _cur_idx;
241
160
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE10EE13current_indexEv
Line
Count
Source
238
283
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
283
        return _cur_idx;
241
283
    }
_ZNK5doris10segment_v216PlainPageDecoderILNS_9FieldTypeE11EE13current_indexEv
Line
Count
Source
238
408
    size_t current_index() const override {
239
        DCHECK(_parsed);
240
408
        return _cur_idx;
241
408
    }
_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