be/src/format/table/paimon_reader.cpp

Source
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "format/table/paimon_reader.h"

#include <vector>

#include "common/status.h"
#include "format/table/deletion_vector_reader.h"
#include "runtime/runtime_state.h"

namespace doris {

// ============================================================================
// PaimonOrcReader
// ============================================================================
void PaimonOrcReader::_init_paimon_profile() {
    static const char* paimon_profile = "PaimonProfile";
    ADD_TIMER(get_profile(), paimon_profile);
    _paimon_profile.num_delete_rows =
            ADD_CHILD_COUNTER(get_profile(), "NumDeleteRows", TUnit::UNIT, paimon_profile);
    _paimon_profile.delete_files_read_time =
            ADD_CHILD_TIMER(get_profile(), "DeleteFileReadTime", paimon_profile);
    _paimon_profile.parse_deletion_vector_time =
            ADD_CHILD_TIMER(get_profile(), "ParseDeletionVectorTime", paimon_profile);
}

Status PaimonOrcReader::on_before_init_reader(ReaderInitContext* ctx) {
    _column_descs = ctx->column_descs;
    _fill_col_name_to_block_idx = ctx->col_name_to_block_idx;
    RETURN_IF_ERROR(_extract_partition_values(*ctx->range, ctx->tuple_descriptor,
                                              _fill_partition_values,
                                              &_fill_partition_value_is_null));
    const orc::Type* orc_type_ptr = nullptr;
    RETURN_IF_ERROR(get_file_type(&orc_type_ptr));

    RETURN_IF_ERROR(gen_table_info_node_by_field_id(
            get_scan_params(), get_scan_range().table_format_params.paimon_params.schema_id,
            get_tuple_descriptor(), orc_type_ptr));
    ctx->table_info_node = table_info_node_ptr;

    for (const auto& desc : *ctx->column_descs) {
        if (desc.category == ColumnCategory::REGULAR ||
            desc.category == ColumnCategory::GENERATED) {
            ctx->column_names.push_back(desc.name);
        }
    }
    return Status::OK();
}

Status PaimonOrcReader::on_after_init_reader(ReaderInitContext* /*ctx*/) {
    return _init_deletion_vector();
}

Status PaimonOrcReader::_init_deletion_vector() {
    const auto& table_desc = get_scan_range().table_format_params.paimon_params;
    if (!table_desc.__isset.deletion_file) {
        return Status::OK();
    }

    // Cannot do count push down if there are delete files
    if (!get_scan_range().table_format_params.paimon_params.__isset.row_count) {
        set_push_down_agg_type(TPushAggOp::NONE);
    }
    const auto& deletion_file = table_desc.deletion_file;

    Status create_status = Status::OK();

    std::string key;
    key.resize(deletion_file.path.size() + sizeof(deletion_file.offset));
    memcpy(key.data(), deletion_file.path.data(), deletion_file.path.size());
    memcpy(key.data() + deletion_file.path.size(), &deletion_file.offset,
           sizeof(deletion_file.offset));

    SCOPED_TIMER(_paimon_profile.delete_files_read_time);
    using DeleteRows = std::vector<int64_t>;
    _delete_rows = _kv_cache->get<DeleteRows>(key, [&]() -> DeleteRows* {
        auto* delete_rows = new DeleteRows;

        TFileRangeDesc delete_range;
        delete_range.__set_fs_name(get_scan_range().fs_name);
        delete_range.path = deletion_file.path;
        delete_range.start_offset = deletion_file.offset;
        delete_range.size = deletion_file.length + 4;
        delete_range.file_size = -1;

        DeletionVectorReader dv_reader(get_state(), get_profile(), get_scan_params(), delete_range,
                                       get_io_ctx());
        create_status = dv_reader.open();
        if (!create_status.ok()) [[unlikely]] {
            return nullptr;
        }

        size_t bytes_read = deletion_file.length + 4;
        std::vector<char> buffer(bytes_read);
        create_status = dv_reader.read_at(deletion_file.offset, {buffer.data(), bytes_read});
        if (!create_status.ok()) [[unlikely]] {
            return nullptr;
        }

        const char* buf = buffer.data();
        uint32_t actual_length;
        std::memcpy(reinterpret_cast<char*>(&actual_length), buf, 4);
        std::reverse(reinterpret_cast<char*>(&actual_length),
                     reinterpret_cast<char*>(&actual_length) + 4);
        buf += 4;
        if (actual_length != bytes_read - 4) [[unlikely]] {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: length not match, "
                    "actual length: {}, expect length: {}",
                    actual_length, bytes_read - 4);
            return nullptr;
        }
        uint32_t magic_number;
        std::memcpy(reinterpret_cast<char*>(&magic_number), buf, 4);
        std::reverse(reinterpret_cast<char*>(&magic_number),
                     reinterpret_cast<char*>(&magic_number) + 4);
        buf += 4;
        const static uint32_t MAGIC_NUMBER = 1581511376;
        if (magic_number != MAGIC_NUMBER) [[unlikely]] {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: invalid magic number {}", magic_number);
            return nullptr;
        }

        roaring::Roaring roaring_bitmap;
        SCOPED_TIMER(_paimon_profile.parse_deletion_vector_time);
        try {
            roaring_bitmap = roaring::Roaring::readSafe(buf, bytes_read - 4);
        } catch (const std::runtime_error& e) {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: failed to deserialize roaring bitmap, {}",
                    e.what());
            return nullptr;
        }
        delete_rows->reserve(roaring_bitmap.cardinality());
        for (auto it = roaring_bitmap.begin(); it != roaring_bitmap.end(); it++) {
            delete_rows->push_back(*it);
        }
        COUNTER_UPDATE(_paimon_profile.num_delete_rows, delete_rows->size());
        return delete_rows;
    });
    RETURN_IF_ERROR(create_status);
    if (!_delete_rows->empty()) [[likely]] {
        set_position_delete_rowids(_delete_rows);
    }
    return Status::OK();
}

// ============================================================================
// PaimonParquetReader
// ============================================================================
void PaimonParquetReader::_init_paimon_profile() {
    static const char* paimon_profile = "PaimonProfile";
    ADD_TIMER(get_profile(), paimon_profile);
    _paimon_profile.num_delete_rows =
            ADD_CHILD_COUNTER(get_profile(), "NumDeleteRows", TUnit::UNIT, paimon_profile);
    _paimon_profile.delete_files_read_time =
            ADD_CHILD_TIMER(get_profile(), "DeleteFileReadTime", paimon_profile);
    _paimon_profile.parse_deletion_vector_time =
            ADD_CHILD_TIMER(get_profile(), "ParseDeletionVectorTime", paimon_profile);
}

Status PaimonParquetReader::on_before_init_reader(ReaderInitContext* ctx) {
    _column_descs = ctx->column_descs;
    _fill_col_name_to_block_idx = ctx->col_name_to_block_idx;
    RETURN_IF_ERROR(_extract_partition_values(*ctx->range, ctx->tuple_descriptor,
                                              _fill_partition_values,
                                              &_fill_partition_value_is_null));
    const FieldDescriptor* field_desc = nullptr;
    RETURN_IF_ERROR(get_file_metadata_schema(&field_desc));
    DCHECK(field_desc != nullptr);

    RETURN_IF_ERROR(gen_table_info_node_by_field_id(
            get_scan_params(), get_scan_range().table_format_params.paimon_params.schema_id,
            get_tuple_descriptor(), *field_desc));
    ctx->table_info_node = table_info_node_ptr;

    for (const auto& desc : *ctx->column_descs) {
        if (desc.category == ColumnCategory::REGULAR ||
            desc.category == ColumnCategory::GENERATED) {
            ctx->column_names.push_back(desc.name);
        }
    }
    return Status::OK();
}

Status PaimonParquetReader::on_after_init_reader(ReaderInitContext* /*ctx*/) {
    return _init_deletion_vector();
}

Status PaimonParquetReader::_init_deletion_vector() {
    const auto& table_desc = get_scan_range().table_format_params.paimon_params;
    if (!table_desc.__isset.deletion_file) {
        return Status::OK();
    }

    if (!get_scan_range().table_format_params.paimon_params.__isset.row_count) {
        set_push_down_agg_type(TPushAggOp::NONE);
    }
    const auto& deletion_file = table_desc.deletion_file;

    Status create_status = Status::OK();

    std::string key;
    key.resize(deletion_file.path.size() + sizeof(deletion_file.offset));
    memcpy(key.data(), deletion_file.path.data(), deletion_file.path.size());
    memcpy(key.data() + deletion_file.path.size(), &deletion_file.offset,
           sizeof(deletion_file.offset));

    SCOPED_TIMER(_paimon_profile.delete_files_read_time);
    using DeleteRows = std::vector<int64_t>;
    _delete_rows = _kv_cache->get<DeleteRows>(key, [&]() -> DeleteRows* {
        auto* delete_rows = new DeleteRows;

        TFileRangeDesc delete_range;
        delete_range.__set_fs_name(get_scan_range().fs_name);
        delete_range.path = deletion_file.path;
        delete_range.start_offset = deletion_file.offset;
        delete_range.size = deletion_file.length + 4;
        delete_range.file_size = -1;

        DeletionVectorReader dv_reader(get_state(), get_profile(), get_scan_params(), delete_range,
                                       get_io_ctx());
        create_status = dv_reader.open();
        if (!create_status.ok()) [[unlikely]] {
            return nullptr;
        }

        size_t bytes_read = deletion_file.length + 4;
        std::vector<char> buffer(bytes_read);
        create_status = dv_reader.read_at(deletion_file.offset, {buffer.data(), bytes_read});
        if (!create_status.ok()) [[unlikely]] {
            return nullptr;
        }

        const char* buf = buffer.data();
        uint32_t actual_length;
        std::memcpy(reinterpret_cast<char*>(&actual_length), buf, 4);
        std::reverse(reinterpret_cast<char*>(&actual_length),
                     reinterpret_cast<char*>(&actual_length) + 4);
        buf += 4;
        if (actual_length != bytes_read - 4) [[unlikely]] {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: length not match, "
                    "actual length: {}, expect length: {}",
                    actual_length, bytes_read - 4);
            return nullptr;
        }
        uint32_t magic_number;
        std::memcpy(reinterpret_cast<char*>(&magic_number), buf, 4);
        std::reverse(reinterpret_cast<char*>(&magic_number),
                     reinterpret_cast<char*>(&magic_number) + 4);
        buf += 4;
        const static uint32_t MAGIC_NUMBER = 1581511376;
        if (magic_number != MAGIC_NUMBER) [[unlikely]] {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: invalid magic number {}", magic_number);
            return nullptr;
        }

        roaring::Roaring roaring_bitmap;
        SCOPED_TIMER(_paimon_profile.parse_deletion_vector_time);
        try {
            roaring_bitmap = roaring::Roaring::readSafe(buf, bytes_read - 4);
        } catch (const std::runtime_error& e) {
            create_status = Status::RuntimeError(
                    "DeletionVector deserialize error: failed to deserialize roaring bitmap, {}",
                    e.what());
            return nullptr;
        }
        delete_rows->reserve(roaring_bitmap.cardinality());
        for (auto it = roaring_bitmap.begin(); it != roaring_bitmap.end(); it++) {
            delete_rows->push_back(*it);
        }
        COUNTER_UPDATE(_paimon_profile.num_delete_rows, delete_rows->size());
        return delete_rows;
    });
    RETURN_IF_ERROR(create_status);
    if (!_delete_rows->empty()) [[likely]] {
        ParquetReader::set_delete_rows(_delete_rows);
    }
    return Status::OK();
}

} // namespace doris

Coverage Report

Created: 2026-06-05 15:29

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		#include "format/table/paimon_reader.h"
19
20		#include <vector>
21
22		#include "common/status.h"
23		#include "format/table/deletion_vector_reader.h"
24		#include "runtime/runtime_state.h"
25
26		namespace doris {
27
28		// ============================================================================
29		// PaimonOrcReader
30		// ============================================================================
31	1.03k	void PaimonOrcReader::_init_paimon_profile() {
32	1.03k	static const char* paimon_profile = "PaimonProfile";
33	1.03k	ADD_TIMER(get_profile(), paimon_profile);
34	1.03k	_paimon_profile.num_delete_rows =
35	1.03k	ADD_CHILD_COUNTER(get_profile(), "NumDeleteRows", TUnit::UNIT, paimon_profile);
36	1.03k	_paimon_profile.delete_files_read_time =
37	1.03k	ADD_CHILD_TIMER(get_profile(), "DeleteFileReadTime", paimon_profile);
38	1.03k	_paimon_profile.parse_deletion_vector_time =
39	1.03k	ADD_CHILD_TIMER(get_profile(), "ParseDeletionVectorTime", paimon_profile);
40	1.03k	}
41
42	1.04k	Status PaimonOrcReader::on_before_init_reader(ReaderInitContext* ctx) {
43	1.04k	_column_descs = ctx->column_descs;
44	1.04k	_fill_col_name_to_block_idx = ctx->col_name_to_block_idx;
45	1.04k	RETURN_IF_ERROR(_extract_partition_values(*ctx->range, ctx->tuple_descriptor,
46	1.04k	_fill_partition_values,
47	1.04k	&_fill_partition_value_is_null));
48	1.04k	const orc::Type* orc_type_ptr = nullptr;
49	1.04k	RETURN_IF_ERROR(get_file_type(&orc_type_ptr));
50
51	1.04k	RETURN_IF_ERROR(gen_table_info_node_by_field_id(
52	1.04k	get_scan_params(), get_scan_range().table_format_params.paimon_params.schema_id,
53	1.04k	get_tuple_descriptor(), orc_type_ptr));
54	1.04k	ctx->table_info_node = table_info_node_ptr;
55
56	6.21k	for (const auto& desc : *ctx->column_descs) {
57	6.21k	if (desc.category == ColumnCategory::REGULAR \|\|
58	6.21k	desc.category == ColumnCategory::GENERATED) {
59	6.12k	ctx->column_names.push_back(desc.name);
60	6.12k	}
61	6.21k	}
62	1.04k	return Status::OK();
63	1.04k	}
64
65	1.04k	Status PaimonOrcReader::on_after_init_reader(ReaderInitContext* /ctx/) {
66	1.04k	return _init_deletion_vector();
67	1.04k	}
68
69	1.04k	Status PaimonOrcReader::_init_deletion_vector() {
70	1.04k	const auto& table_desc = get_scan_range().table_format_params.paimon_params;
71	1.04k	if (!table_desc.__isset.deletion_file) {
72	1.03k	return Status::OK();
73	1.03k	}
74
75		// Cannot do count push down if there are delete files
76	10	if (!get_scan_range().table_format_params.paimon_params.__isset.row_count) {
77	10	set_push_down_agg_type(TPushAggOp::NONE);
78	10	}
79	10	const auto& deletion_file = table_desc.deletion_file;
80
81	10	Status create_status = Status::OK();
82
83	10	std::string key;
84	10	key.resize(deletion_file.path.size() + sizeof(deletion_file.offset));
85	10	memcpy(key.data(), deletion_file.path.data(), deletion_file.path.size());
86	10	memcpy(key.data() + deletion_file.path.size(), &deletion_file.offset,
87	10	sizeof(deletion_file.offset));
88
89	10	SCOPED_TIMER(_paimon_profile.delete_files_read_time);
90	10	using DeleteRows = std::vector<int64_t>;
91	10	_delete_rows = _kv_cache->get<DeleteRows>(key, [&]() -> DeleteRows* {
92	10	auto* delete_rows = new DeleteRows;
93
94	10	TFileRangeDesc delete_range;
95	10	delete_range.__set_fs_name(get_scan_range().fs_name);
96	10	delete_range.path = deletion_file.path;
97	10	delete_range.start_offset = deletion_file.offset;
98	10	delete_range.size = deletion_file.length + 4;
99	10	delete_range.file_size = -1;
100
101	10	DeletionVectorReader dv_reader(get_state(), get_profile(), get_scan_params(), delete_range,
102	10	get_io_ctx());
103	10	create_status = dv_reader.open();
104	10	if (!create_status.ok()) [[unlikely]] {
105	0	return nullptr;
106	0	}
107
108	10	size_t bytes_read = deletion_file.length + 4;
109	10	std::vector<char> buffer(bytes_read);
110	10	create_status = dv_reader.read_at(deletion_file.offset, {buffer.data(), bytes_read});
111	10	if (!create_status.ok()) [[unlikely]] {
112	0	return nullptr;
113	0	}
114
115	10	const char* buf = buffer.data();
116	10	uint32_t actual_length;
117	10	std::memcpy(reinterpret_cast<char*>(&actual_length), buf, 4);
118	10	std::reverse(reinterpret_cast<char*>(&actual_length),
119	10	reinterpret_cast<char*>(&actual_length) + 4);
120	10	buf += 4;
121	10	if (actual_length != bytes_read - 4) [[unlikely]] {
122	0	create_status = Status::RuntimeError(
123	0	"DeletionVector deserialize error: length not match, "
124	0	"actual length: {}, expect length: {}",
125	0	actual_length, bytes_read - 4);
126	0	return nullptr;
127	0	}
128	10	uint32_t magic_number;
129	10	std::memcpy(reinterpret_cast<char*>(&magic_number), buf, 4);
130	10	std::reverse(reinterpret_cast<char*>(&magic_number),
131	10	reinterpret_cast<char*>(&magic_number) + 4);
132	10	buf += 4;
133	10	const static uint32_t MAGIC_NUMBER = 1581511376;
134	10	if (magic_number != MAGIC_NUMBER) [[unlikely]] {
135	0	create_status = Status::RuntimeError(
136	0	"DeletionVector deserialize error: invalid magic number {}", magic_number);
137	0	return nullptr;
138	0	}
139
140	10	roaring::Roaring roaring_bitmap;
141	10	SCOPED_TIMER(_paimon_profile.parse_deletion_vector_time);
142	10	try {
143	10	roaring_bitmap = roaring::Roaring::readSafe(buf, bytes_read - 4);
144	10	} catch (const std::runtime_error& e) {
145	0	create_status = Status::RuntimeError(
146	0	"DeletionVector deserialize error: failed to deserialize roaring bitmap, {}",
147	0	e.what());
148	0	return nullptr;
149	0	}
150	10	delete_rows->reserve(roaring_bitmap.cardinality());
151	20	for (auto it = roaring_bitmap.begin(); it != roaring_bitmap.end(); it++) {
152	10	delete_rows->push_back(*it);
153	10	}
154	10	COUNTER_UPDATE(_paimon_profile.num_delete_rows, delete_rows->size());
155	10	return delete_rows;
156	10	});
157	10	RETURN_IF_ERROR(create_status);
158	10	if (!_delete_rows->empty()) [[likely]] {
159	10	set_position_delete_rowids(_delete_rows);
160	10	}
161	10	return Status::OK();
162	10	}
163
164		// ============================================================================
165		// PaimonParquetReader
166		// ============================================================================
167	1.22k	void PaimonParquetReader::_init_paimon_profile() {
168	1.22k	static const char* paimon_profile = "PaimonProfile";
169	1.22k	ADD_TIMER(get_profile(), paimon_profile);
170	1.22k	_paimon_profile.num_delete_rows =
171	1.22k	ADD_CHILD_COUNTER(get_profile(), "NumDeleteRows", TUnit::UNIT, paimon_profile);
172	1.22k	_paimon_profile.delete_files_read_time =
173	1.22k	ADD_CHILD_TIMER(get_profile(), "DeleteFileReadTime", paimon_profile);
174	1.22k	_paimon_profile.parse_deletion_vector_time =
175	1.22k	ADD_CHILD_TIMER(get_profile(), "ParseDeletionVectorTime", paimon_profile);
176	1.22k	}
177
178	1.22k	Status PaimonParquetReader::on_before_init_reader(ReaderInitContext* ctx) {
179	1.22k	_column_descs = ctx->column_descs;
180	1.22k	_fill_col_name_to_block_idx = ctx->col_name_to_block_idx;
181	1.22k	RETURN_IF_ERROR(_extract_partition_values(*ctx->range, ctx->tuple_descriptor,
182	1.22k	_fill_partition_values,
183	1.22k	&_fill_partition_value_is_null));
184	1.22k	const FieldDescriptor* field_desc = nullptr;
185	1.22k	RETURN_IF_ERROR(get_file_metadata_schema(&field_desc));
186	1.22k	DCHECK(field_desc != nullptr);
187
188	1.22k	RETURN_IF_ERROR(gen_table_info_node_by_field_id(
189	1.22k	get_scan_params(), get_scan_range().table_format_params.paimon_params.schema_id,
190	1.22k	get_tuple_descriptor(), *field_desc));
191	1.22k	ctx->table_info_node = table_info_node_ptr;
192
193	3.62k	for (const auto& desc : *ctx->column_descs) {
194	3.62k	if (desc.category == ColumnCategory::REGULAR \|\|
195	3.62k	desc.category == ColumnCategory::GENERATED) {
196	2.97k	ctx->column_names.push_back(desc.name);
197	2.97k	}
198	3.62k	}
199	1.22k	return Status::OK();
200	1.22k	}
201
202	1.21k	Status PaimonParquetReader::on_after_init_reader(ReaderInitContext* /ctx/) {
203	1.21k	return _init_deletion_vector();
204	1.21k	}
205
206	1.21k	Status PaimonParquetReader::_init_deletion_vector() {
207	1.21k	const auto& table_desc = get_scan_range().table_format_params.paimon_params;
208	1.21k	if (!table_desc.__isset.deletion_file) {
209	1.20k	return Status::OK();
210	1.20k	}
211
212	14	if (!get_scan_range().table_format_params.paimon_params.__isset.row_count) {
213	14	set_push_down_agg_type(TPushAggOp::NONE);
214	14	}
215	12	const auto& deletion_file = table_desc.deletion_file;
216
217	12	Status create_status = Status::OK();
218
219	12	std::string key;
220	12	key.resize(deletion_file.path.size() + sizeof(deletion_file.offset));
221	12	memcpy(key.data(), deletion_file.path.data(), deletion_file.path.size());
222	12	memcpy(key.data() + deletion_file.path.size(), &deletion_file.offset,
223	12	sizeof(deletion_file.offset));
224
225	12	SCOPED_TIMER(_paimon_profile.delete_files_read_time);
226	12	using DeleteRows = std::vector<int64_t>;
227	14	_delete_rows = _kv_cache->get<DeleteRows>(key, [&]() -> DeleteRows* {
228	14	auto* delete_rows = new DeleteRows;
229
230	14	TFileRangeDesc delete_range;
231	14	delete_range.__set_fs_name(get_scan_range().fs_name);
232	14	delete_range.path = deletion_file.path;
233	14	delete_range.start_offset = deletion_file.offset;
234	14	delete_range.size = deletion_file.length + 4;
235	14	delete_range.file_size = -1;
236
237	14	DeletionVectorReader dv_reader(get_state(), get_profile(), get_scan_params(), delete_range,
238	14	get_io_ctx());
239	14	create_status = dv_reader.open();
240	14	if (!create_status.ok()) [[unlikely]] {
241	0	return nullptr;
242	0	}
243
244	14	size_t bytes_read = deletion_file.length + 4;
245	14	std::vector<char> buffer(bytes_read);
246	14	create_status = dv_reader.read_at(deletion_file.offset, {buffer.data(), bytes_read});
247	14	if (!create_status.ok()) [[unlikely]] {
248	0	return nullptr;
249	0	}
250
251	14	const char* buf = buffer.data();
252	14	uint32_t actual_length;
253	14	std::memcpy(reinterpret_cast<char*>(&actual_length), buf, 4);
254	14	std::reverse(reinterpret_cast<char*>(&actual_length),
255	14	reinterpret_cast<char*>(&actual_length) + 4);
256	14	buf += 4;
257	14	if (actual_length != bytes_read - 4) [[unlikely]] {
258	0	create_status = Status::RuntimeError(
259	0	"DeletionVector deserialize error: length not match, "
260	0	"actual length: {}, expect length: {}",
261	0	actual_length, bytes_read - 4);
262	0	return nullptr;
263	0	}
264	14	uint32_t magic_number;
265	14	std::memcpy(reinterpret_cast<char*>(&magic_number), buf, 4);
266	14	std::reverse(reinterpret_cast<char*>(&magic_number),
267	14	reinterpret_cast<char*>(&magic_number) + 4);
268	14	buf += 4;
269	14	const static uint32_t MAGIC_NUMBER = 1581511376;
270	14	if (magic_number != MAGIC_NUMBER) [[unlikely]] {
271	0	create_status = Status::RuntimeError(
272	0	"DeletionVector deserialize error: invalid magic number {}", magic_number);
273	0	return nullptr;
274	0	}
275
276	14	roaring::Roaring roaring_bitmap;
277	14	SCOPED_TIMER(_paimon_profile.parse_deletion_vector_time);
278	14	try {
279	14	roaring_bitmap = roaring::Roaring::readSafe(buf, bytes_read - 4);
280	14	} catch (const std::runtime_error& e) {
281	0	create_status = Status::RuntimeError(
282	0	"DeletionVector deserialize error: failed to deserialize roaring bitmap, {}",
283	0	e.what());
284	0	return nullptr;
285	0	}
286	14	delete_rows->reserve(roaring_bitmap.cardinality());
287	28	for (auto it = roaring_bitmap.begin(); it != roaring_bitmap.end(); it++) {
288	14	delete_rows->push_back(*it);
289	14	}
290	14	COUNTER_UPDATE(_paimon_profile.num_delete_rows, delete_rows->size());
291	14	return delete_rows;
292	14	});
293	12	RETURN_IF_ERROR(create_status);
294	14	if (!_delete_rows->empty()) [[likely]] {
295	14	ParquetReader::set_delete_rows(_delete_rows);
296	14	}
297	12	return Status::OK();
298	12	}
299
300		} // namespace doris