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-08 08:15

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