duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -29,6 +29,7 @@
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
 #include "duckdb/planner/filter/struct_filter.hpp"
+#include "duckdb/planner/filter/optional_filter.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/object_cache.hpp"
 #endif
@@ -40,15 +41,15 @@
 
 namespace duckdb {
 
-using duckdb_parquet::format::ColumnChunk;
-using duckdb_parquet::format::ConvertedType;
-using duckdb_parquet::format::FieldRepetitionType;
-using duckdb_parquet::format::FileCryptoMetaData;
-using duckdb_parquet::format::FileMetaData;
-using ParquetRowGroup = duckdb_parquet::format::RowGroup;
-using duckdb_parquet::format::SchemaElement;
-using duckdb_parquet::format::Statistics;
-using duckdb_parquet::format::Type;
+using duckdb_parquet::ColumnChunk;
+using duckdb_parquet::ConvertedType;
+using duckdb_parquet::FieldRepetitionType;
+using duckdb_parquet::FileCryptoMetaData;
+using duckdb_parquet::FileMetaData;
+using ParquetRowGroup = duckdb_parquet::RowGroup;
+using duckdb_parquet::SchemaElement;
+using duckdb_parquet::Statistics;
+using duckdb_parquet::Type;
 
 static unique_ptr<duckdb_apache::thrift::protocol::TProtocol>
 CreateThriftFileProtocol(Allocator &allocator, FileHandle &file_handle, bool prefetch_mode) {
@@ -147,6 +148,10 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool bi
 		}
 	}
 	if (s_ele.__isset.converted_type) {
+		// Legacy NULL type, does no longer exist, but files are still around of course
+		if (static_cast<uint8_t>(s_ele.converted_type) == 24) {
+			return LogicalTypeId::SQLNULL;
+		}
 		switch (s_ele.converted_type) {
 		case ConvertedType::INT_8:
 			if (s_ele.type == Type::INT32) {
@@ -251,8 +256,6 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool bi
 			return LogicalType::INTERVAL;
 		case ConvertedType::JSON:
 			return LogicalType::JSON();
-		case ConvertedType::NULL_TYPE:
-			return LogicalTypeId::SQLNULL;
 		case ConvertedType::MAP:
 		case ConvertedType::MAP_KEY_VALUE:
 		case ConvertedType::LIST:
@@ -292,9 +295,10 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele) {
 	return DeriveLogicalType(s_ele, parquet_options.binary_as_string);
 }
 
-unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &context, idx_t depth, idx_t max_define,
-                                                              idx_t max_repeat, idx_t &next_schema_idx,
-                                                              idx_t &next_file_idx) {
+unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &context,
+                                                              const vector<ColumnIndex> &indexes, idx_t depth,
+                                                              idx_t max_define, idx_t max_repeat,
+                                                              idx_t &next_schema_idx, idx_t &next_file_idx) {
 	auto file_meta_data = GetFileMetadata();
 	D_ASSERT(file_meta_data);
 	D_ASSERT(next_schema_idx < file_meta_data->schema.size());
@@ -324,6 +328,12 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &con
 	if (s_ele.__isset.num_children && s_ele.num_children > 0) { // inner node
 		child_list_t<LogicalType> child_types;
 		vector<unique_ptr<ColumnReader>> child_readers;
+		// this type is a nested type - it has child columns specified
+		// create a mapping for which column readers we should create
+		unordered_map<idx_t, vector<ColumnIndex>> required_readers;
+		for (auto &index : indexes) {
+			required_readers.insert(make_pair(index.GetPrimaryIndex(), index.GetChildIndexes()));
+		}
 
 		idx_t c_idx = 0;
 		while (c_idx < (idx_t)s_ele.num_children) {
@@ -331,10 +341,23 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &con
 
 			auto &child_ele = file_meta_data->schema[next_schema_idx];
 
-			auto child_reader =
-			    CreateReaderRecursive(context, depth + 1, max_define, max_repeat, next_schema_idx, next_file_idx);
+			// figure out which child columns we should read of this child column
+			vector<ColumnIndex> child_indexes;
+			auto entry = required_readers.find(c_idx);
+			if (entry != required_readers.end()) {
+				child_indexes = entry->second;
+			}
+			auto child_reader = CreateReaderRecursive(context, child_indexes, depth + 1, max_define, max_repeat,
+			                                          next_schema_idx, next_file_idx);
 			child_types.push_back(make_pair(child_ele.name, child_reader->Type()));
-			child_readers.push_back(std::move(child_reader));
+			if (indexes.empty() || entry != required_readers.end()) {
+				// either (1) indexes is empty, meaning we need to read all child columns, or (2) we need to read this
+				// column
+				child_readers.push_back(std::move(child_reader));
+			} else {
+				// this column was explicitly not required - push an empty child reader here
+				child_readers.push_back(nullptr);
+			}
 
 			c_idx++;
 		}
@@ -395,9 +418,10 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &con
 		}
 		if (is_repeated) {
 			result_type = LogicalType::LIST(result_type);
-			return make_uniq<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                   std::move(result));
+			result = make_uniq<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
+			                                     std::move(result));
 		}
+		result->SetParentSchema(s_ele);
 		return result;
 	} else { // leaf node
 		if (!s_ele.__isset.type) {
@@ -432,7 +456,7 @@ unique_ptr<ColumnReader> ParquetReader::CreateReader(ClientContext &context) {
 	if (file_meta_data->schema[0].num_children == 0) {
 		throw IOException("Parquet reader: root schema element has no children");
 	}
-	auto ret = CreateReaderRecursive(context, 0, 0, 0, next_schema_idx, next_file_idx);
+	auto ret = CreateReaderRecursive(context, reader_data.column_indexes, 0, 0, 0, next_schema_idx, next_file_idx);
 	if (ret->Type().id() != LogicalTypeId::STRUCT) {
 		throw InvalidInputException("Root element of Parquet file must be a struct");
 	}
@@ -449,8 +473,6 @@ unique_ptr<ColumnReader> ParquetReader::CreateReader(ClientContext &context) {
 		root_struct_reader.child_readers[column_idx] = std::move(cast_reader);
 	}
 	if (parquet_options.file_row_number) {
-		file_row_number_idx = root_struct_reader.child_readers.size();
-
 		generated_column_schema.push_back(SchemaElement());
 		root_struct_reader.child_readers.push_back(make_uniq<RowNumberColumnReader>(
 		    *this, LogicalType::BIGINT, generated_column_schema.back(), next_file_idx, 0, 0));
@@ -475,20 +497,39 @@ void ParquetReader::InitializeSchema(ClientContext &context) {
 	root_reader = CreateReader(context);
 	auto &root_type = root_reader->Type();
 	auto &child_types = StructType::GetChildTypes(root_type);
+
+	auto &struct_reader = root_reader->Cast<StructColumnReader>();
+	auto &child_readers = struct_reader.child_readers;
 	D_ASSERT(root_type.id() == LogicalTypeId::STRUCT);
-	for (auto &type_pair : child_types) {
-		names.push_back(type_pair.first);
-		return_types.push_back(type_pair.second);
+
+	D_ASSERT(child_readers.size() >= child_types.size());
+	for (idx_t i = 0; i < child_types.size(); i++) {
+		auto &type_pair = child_types[i];
+		auto column = MultiFileReaderColumnDefinition(type_pair.first, type_pair.second);
+		auto &column_reader = *child_readers[i];
+		auto &column_schema = column_reader.Schema();
+
+		if (column_schema.__isset.field_id) {
+			column.identifier = Value::INTEGER(column_schema.field_id);
+		} else if (column_reader.GetParentSchema()) {
+			auto &parent_column_schema = *column_reader.GetParentSchema();
+			if (parent_column_schema.__isset.field_id) {
+				column.identifier = Value::INTEGER(parent_column_schema.field_id);
+			}
+		}
+		columns.emplace_back(std::move(column));
 	}
 
 	// Add generated constant column for row number
 	if (parquet_options.file_row_number) {
-		if (StringUtil::CIFind(names, "file_row_number") != DConstants::INVALID_INDEX) {
-			throw BinderException(
-			    "Using file_row_number option on file with column named file_row_number is not supported");
+		for (auto &column : columns) {
+			auto &name = column.name;
+			if (StringUtil::CIEquals(name, "file_row_number")) {
+				throw BinderException(
+				    "Using file_row_number option on file with column named file_row_number is not supported");
+			}
 		}
-		return_types.emplace_back(LogicalType::BIGINT);
-		names.emplace_back("file_row_number");
+		columns.emplace_back("file_row_number", LogicalType::BIGINT);
 	}
 }
 
@@ -501,7 +542,8 @@ ParquetOptions::ParquetOptions(ClientContext &context) {
 
 ParquetColumnDefinition ParquetColumnDefinition::FromSchemaValue(ClientContext &context, const Value &column_value) {
 	ParquetColumnDefinition result;
-	result.field_id = IntegerValue::Get(StructValue::GetChildren(column_value)[0]);
+	auto &identifier = StructValue::GetChildren(column_value)[0];
+	result.identifier = identifier;
 
 	const auto &column_def = StructValue::GetChildren(column_value)[1];
 	D_ASSERT(column_def.type().id() == LogicalTypeId::STRUCT);
@@ -538,11 +580,13 @@ ParquetReader::ParquetReader(ClientContext &context_p, string file_name_p, Parqu
 		encryption_util = make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESGCMStateMBEDTLSFactory>();
 	}
 
-	// If object cached is disabled
+	// If metadata cached is disabled
 	// or if this file has cached metadata
 	// or if the cached version already expired
 	if (!metadata_p) {
-		if (!ObjectCache::ObjectCacheEnabled(context_p)) {
+		Value metadata_cache = false;
+		context_p.TryGetCurrentSetting("parquet_metadata_cache", metadata_cache);
+		if (!metadata_cache.GetValue<bool>()) {
 			metadata =
 			    LoadMetadata(context_p, allocator, *file_handle, parquet_options.encryption_config, *encryption_util);
 		} else {
@@ -581,22 +625,22 @@ const FileMetaData *ParquetReader::GetFileMetadata() {
 
 unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(const string &name) {
 	idx_t file_col_idx;
-	for (file_col_idx = 0; file_col_idx < names.size(); file_col_idx++) {
-		if (names[file_col_idx] == name) {
+	for (file_col_idx = 0; file_col_idx < columns.size(); file_col_idx++) {
+		if (columns[file_col_idx].name == name) {
 			break;
 		}
 	}
-	if (file_col_idx == names.size()) {
+	if (file_col_idx == columns.size()) {
 		return nullptr;
 	}
 
 	unique_ptr<BaseStatistics> column_stats;
 	auto file_meta_data = GetFileMetadata();
-	auto column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
+	auto &column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
 
 	for (idx_t row_group_idx = 0; row_group_idx < file_meta_data->row_groups.size(); row_group_idx++) {
 		auto &row_group = file_meta_data->row_groups[row_group_idx];
-		auto chunk_stats = column_reader->Stats(row_group_idx, row_group.columns);
+		auto chunk_stats = column_reader.Stats(row_group_idx, row_group.columns);
 		if (!chunk_stats) {
 			return nullptr;
 		}
@@ -719,22 +763,30 @@ static FilterPropagateResult CheckParquetStringFilter(BaseStatistics &stats, con
 void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t col_idx) {
 	auto &group = GetGroup(state);
 	auto column_id = reader_data.column_ids[col_idx];
-	auto column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
+	auto &column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
 
 	// TODO move this to columnreader too
 	if (reader_data.filters) {
-		auto stats = column_reader->Stats(state.group_idx_list[state.current_group], group.columns);
+		auto stats = column_reader.Stats(state.group_idx_list[state.current_group], group.columns);
 		// filters contain output chunk index, not file col idx!
 		auto global_id = reader_data.column_mapping[col_idx];
 		auto filter_entry = reader_data.filters->filters.find(global_id);
+
 		if (stats && filter_entry != reader_data.filters->filters.end()) {
-			bool skip_chunk = false;
 			auto &filter = *filter_entry->second;
 
 			FilterPropagateResult prune_result;
-			if (column_reader->Type().id() == LogicalTypeId::VARCHAR &&
-			    group.columns[column_reader->FileIdx()].meta_data.statistics.__isset.min_value &&
-			    group.columns[column_reader->FileIdx()].meta_data.statistics.__isset.max_value) {
+			// TODO we might not have stats but STILL a bloom filter so move this up
+			// check the bloom filter if present
+			if (!column_reader.Type().IsNested() &&
+			    ParquetStatisticsUtils::BloomFilterSupported(column_reader.Type().id()) &&
+			    ParquetStatisticsUtils::BloomFilterExcludes(filter, group.columns[column_reader.FileIdx()].meta_data,
+			                                                *state.thrift_file_proto, allocator)) {
+				prune_result = FilterPropagateResult::FILTER_ALWAYS_FALSE;
+			} else if (column_reader.Type().id() == LogicalTypeId::VARCHAR &&
+			           group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.min_value &&
+			           group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.max_value) {
+
 				// our StringStats only store the first 8 bytes of strings (even if Parquet has longer string stats)
 				// however, when reading remote Parquet files, skipping row groups is really important
 				// here, we implement a special case to check the full length for string filters
@@ -743,7 +795,7 @@ void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t c
 					auto and_result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
 					for (auto &child_filter : and_filter.child_filters) {
 						auto child_prune_result = CheckParquetStringFilter(
-						    *stats, group.columns[column_reader->FileIdx()].meta_data.statistics, *child_filter);
+						    *stats, group.columns[column_reader.FileIdx()].meta_data.statistics, *child_filter);
 						if (child_prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
 							and_result = FilterPropagateResult::FILTER_ALWAYS_FALSE;
 							break;
@@ -754,16 +806,13 @@ void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t c
 					prune_result = and_result;
 				} else {
 					prune_result = CheckParquetStringFilter(
-					    *stats, group.columns[column_reader->FileIdx()].meta_data.statistics, filter);
+					    *stats, group.columns[column_reader.FileIdx()].meta_data.statistics, filter);
 				}
 			} else {
 				prune_result = filter.CheckStatistics(*stats);
 			}
 
 			if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-				skip_chunk = true;
-			}
-			if (skip_chunk) {
 				// this effectively will skip this chunk
 				state.group_offset = group.num_rows;
 				return;
@@ -793,7 +842,14 @@ void ParquetReader::InitializeScan(ClientContext &context, ParquetReaderScanStat
 	if (!state.file_handle || state.file_handle->path != file_handle->path) {
 		auto flags = FileFlags::FILE_FLAGS_READ;
 
-		if (!file_handle->OnDiskFile() && file_handle->CanSeek()) {
+		Value disable_prefetch = false;
+		Value prefetch_all_files = false;
+		context.TryGetCurrentSetting("disable_parquet_prefetching", disable_prefetch);
+		context.TryGetCurrentSetting("prefetch_all_parquet_files", prefetch_all_files);
+		bool should_prefetch = !file_handle->OnDiskFile() || prefetch_all_files.GetValue<bool>();
+		bool can_prefetch = file_handle->CanSeek() && !disable_prefetch.GetValue<bool>();
+
+		if (should_prefetch && can_prefetch) {
 			state.prefetch_mode = true;
 			flags |= FileFlags::FILE_FLAGS_DIRECT_IO;
 		} else {
@@ -817,15 +873,16 @@ void FilterIsNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
 		}
 		return;
 	}
-	D_ASSERT(v.GetVectorType() == VectorType::FLAT_VECTOR);
 
-	auto &mask = FlatVector::Validity(v);
-	if (mask.AllValid()) {
+	UnifiedVectorFormat unified;
+	v.ToUnifiedFormat(count, unified);
+
+	if (unified.validity.AllValid()) {
 		filter_mask.reset();
 	} else {
 		for (idx_t i = 0; i < count; i++) {
 			if (filter_mask.test(i)) {
-				filter_mask.set(i, !mask.RowIsValid(i));
+				filter_mask.set(i, !unified.validity.RowIsValid(unified.sel->get_index(i)));
 			}
 		}
 	}
@@ -839,13 +896,14 @@ void FilterIsNotNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
 		}
 		return;
 	}
-	D_ASSERT(v.GetVectorType() == VectorType::FLAT_VECTOR);
 
-	auto &mask = FlatVector::Validity(v);
-	if (!mask.AllValid()) {
+	UnifiedVectorFormat unified;
+	v.ToUnifiedFormat(count, unified);
+
+	if (!unified.validity.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
 			if (filter_mask.test(i)) {
-				filter_mask.set(i, mask.RowIsValid(i));
+				filter_mask.set(i, unified.validity.RowIsValid(unified.sel->get_index(i)));
 			}
 		}
 	}
@@ -861,24 +919,32 @@ void TemplatedFilterOperation(Vector &v, T constant, parquet_filter_t &filter_ma
 			if (!OP::Operation(v_ptr[0], constant)) {
 				filter_mask.reset();
 			}
+		} else {
+			filter_mask.reset();
 		}
 		return;
 	}
 
-	D_ASSERT(v.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto v_ptr = FlatVector::GetData<T>(v);
-	auto &mask = FlatVector::Validity(v);
+	UnifiedVectorFormat unified;
+	v.ToUnifiedFormat(count, unified);
+	auto data_ptr = UnifiedVectorFormat::GetData<T>(unified);
 
-	if (!mask.AllValid()) {
+	if (!unified.validity.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			if (filter_mask.test(i) && mask.RowIsValid(i)) {
-				filter_mask.set(i, OP::Operation(v_ptr[i], constant));
+			if (filter_mask.test(i)) {
+				auto idx = unified.sel->get_index(i);
+				bool is_valid = unified.validity.RowIsValid(idx);
+				if (is_valid) {
+					filter_mask.set(i, OP::Operation(data_ptr[idx], constant));
+				} else {
+					filter_mask.set(i, false);
+				}
 			}
 		}
 	} else {
 		for (idx_t i = 0; i < count; i++) {
 			if (filter_mask.test(i)) {
-				filter_mask.set(i, OP::Operation(v_ptr[i], constant));
+				filter_mask.set(i, OP::Operation(data_ptr[unified.sel->get_index(i)], constant));
 			}
 		}
 	}
@@ -977,8 +1043,11 @@ static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 			FilterOperationSwitch<GreaterThanEquals>(v, constant_filter.constant, filter_mask, count);
 			break;
+		case ExpressionType::COMPARE_NOTEQUAL:
+			FilterOperationSwitch<NotEquals>(v, constant_filter.constant, filter_mask, count);
+			break;
 		default:
-			D_ASSERT(0);
+			throw InternalException("Unsupported comparison for Parquet filter pushdown");
 		}
 		break;
 	}
@@ -992,7 +1061,12 @@ static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter
 		auto &struct_filter = filter.Cast<StructFilter>();
 		auto &child = StructVector::GetEntries(v)[struct_filter.child_idx];
 		ApplyFilter(*child, *struct_filter.child_filter, filter_mask, count);
-	} break;
+	}
+	case TableFilterType::OPTIONAL_FILTER: {
+		// we don't execute zone map filters here - we only consider them for zone map pruning
+		// do nothing to the mask.
+		break;
+	}
 	default:
 		D_ASSERT(0);
 		break;
@@ -1034,19 +1108,21 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 			auto file_col_idx = reader_data.column_ids[col_idx];
 
 			auto &root_reader = state.root_reader->Cast<StructColumnReader>();
-			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx)->TotalCompressedSize();
+			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx).TotalCompressedSize();
 		}
 
 		auto &group = GetGroup(state);
 		if (state.prefetch_mode && state.group_offset != (idx_t)group.num_rows) {
-
 			uint64_t total_row_group_span = GetGroupSpan(state);
 
 			double scan_percentage = (double)(to_scan_compressed_bytes) / static_cast<double>(total_row_group_span);
 
 			if (to_scan_compressed_bytes > total_row_group_span) {
-				throw InvalidInputException(
-				    "Malformed parquet file: sum of total compressed bytes of columns seems incorrect");
+				throw IOException(
+				    "The parquet file '%s' seems to have incorrectly set page offsets. This interferes with DuckDB's "
+				    "prefetching optimization. DuckDB may still be able to scan this file by manually disabling the "
+				    "prefetching mechanism using: 'SET disable_parquet_prefetching=true'.",
+				    file_name);
 			}
 
 			if (!reader_data.filters &&
@@ -1074,7 +1150,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 						auto entry = reader_data.filters->filters.find(reader_data.column_mapping[col_idx]);
 						has_filter = entry != reader_data.filters->filters.end();
 					}
-					root_reader.GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
+					root_reader.GetChildReader(file_col_idx).RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
 				}
 
 				trans.FinalizeRegistration();
@@ -1134,8 +1210,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				auto result_idx = reader_data.column_mapping[id];
 
 				auto &result_vector = result.data[result_idx];
-				auto child_reader = root_reader.GetChildReader(file_col_idx);
-				child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
+				auto &child_reader = root_reader.GetChildReader(file_col_idx);
+				child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 				need_to_read[id] = false;
 
 				ApplyFilter(result_vector, *filter_col.second, filter_mask, this_output_chunk_rows);
@@ -1149,12 +1225,12 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 			}
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			if (filter_mask.none()) {
-				root_reader.GetChildReader(file_col_idx)->Skip(result.size());
+				root_reader.GetChildReader(file_col_idx).Skip(result.size());
 				continue;
 			}
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader.GetChildReader(file_col_idx);
-			child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
+			auto &child_reader = root_reader.GetChildReader(file_col_idx);
+			child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 		}
 
 		idx_t sel_size = 0;
@@ -1169,8 +1245,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader.GetChildReader(file_col_idx);
-			auto rows_read = child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
+			auto &child_reader = root_reader.GetChildReader(file_col_idx);
+			auto rows_read = child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 			if (rows_read != result.size()) {
 				throw InvalidInputException("Mismatch in parquet read for column %llu, expected %llu rows, got %llu",
 				                            file_col_idx, result.size(), rows_read);