vendor: Update vendored sources to duckdb/duckdb@2d530ad

Use Adaptive Filters in the Parquet reader (duckdb/duckdb#16133)
[Julia] Add support for named params in prepared statements (duckdb/duckdb#15621)

Author: krlmlr

src/duckdb/extension/parquet/include/parquet_reader.hpp

@@ -9,24 +9,19 @@
 #pragma once
 
 #include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/encryption_state.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#endif
 #include "column_reader.hpp"
 #include "parquet_file_metadata_cache.hpp"
 #include "parquet_rle_bp_decoder.hpp"
 #include "parquet_types.h"
 #include "resizable_buffer.hpp"
+#include "duckdb/execution/adaptive_filter.hpp"
 
 #include <exception>
 
@@ -48,6 +43,14 @@ struct ParquetReaderPrefetchConfig {
 	static constexpr double WHOLE_GROUP_PREFETCH_MINIMUM_SCAN = 0.95;
 };
 
+struct ParquetScanFilter {
+	ParquetScanFilter(idx_t filter_idx, TableFilter &filter) : filter_idx(filter_idx), filter(filter) {
+	}
+
+	idx_t filter_idx;
+	TableFilter &filter;
+};
+
 struct ParquetReaderScanState {
 	vector<idx_t> group_idx_list;
 	int64_t current_group;
@@ -64,6 +67,11 @@ struct ParquetReaderScanState {
 
 	bool prefetch_mode = false;
 	bool current_group_prefetched = false;
+
+	//! Adaptive filter
+	unique_ptr<AdaptiveFilter> adaptive_filter;
+	//! Table filter list
+	vector<ParquetScanFilter> scan_filters;
 };
 
 struct ParquetColumnDefinition {

src/duckdb/extension/parquet/include/reader/string_column_reader.hpp

@@ -31,8 +31,8 @@ class StringColumnReader : public ColumnReader {
 	idx_t fixed_width_string_length;
 
 public:
-	static uint32_t VerifyString(const char *str_data, uint32_t str_len, const bool isVarchar);
-	uint32_t VerifyString(const char *str_data, uint32_t str_len);
+	static void VerifyString(const char *str_data, uint32_t str_len, const bool isVarchar);
+	void VerifyString(const char *str_data, uint32_t str_len);
 
 protected:
 	void Plain(ByteBuffer &plain_data, uint8_t *defines, idx_t num_values, idx_t result_offset,

src/duckdb/extension/parquet/parquet_reader.cpp

@@ -854,7 +854,6 @@ void ParquetReader::InitializeScan(ClientContext &context, ParquetReaderScanStat
 
 		state.file_handle = fs.OpenFile(file_handle->path, flags);
 	}
-
 	state.thrift_file_proto = CreateThriftFileProtocol(allocator, *state.file_handle, state.prefetch_mode);
 	state.root_reader = CreateReader(context);
 	state.define_buf.resize(allocator, STANDARD_VECTOR_SIZE);
@@ -979,18 +978,28 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		vector<bool> need_to_read(reader_data.column_ids.size(), true);
 
 		state.sel.Initialize(nullptr);
+		if (state.scan_filters.empty()) {
+			state.adaptive_filter = make_uniq<AdaptiveFilter>(*reader_data.filters);
+			for (auto &entry : reader_data.filters->filters) {
+				state.scan_filters.emplace_back(entry.first, *entry.second);
+			}
+		}
+		D_ASSERT(state.scan_filters.size() == reader_data.filters->filters.size());
+
 		// first load the columns that are used in filters
-		for (auto &filter_col : reader_data.filters->filters) {
+		auto filter_state = state.adaptive_filter->BeginFilter();
+		for (idx_t i = 0; i < state.scan_filters.size(); i++) {
 			if (filter_count == 0) {
 				// if no rows are left we can stop checking filters
 				break;
 			}
-			auto filter_entry = reader_data.filter_map[filter_col.first];
+			auto &scan_filter = state.scan_filters[state.adaptive_filter->permutation[i]];
+			auto filter_entry = reader_data.filter_map[scan_filter.filter_idx];
 			if (filter_entry.is_constant) {
 				// this is a constant vector, look for the constant
 				auto &constant = reader_data.constant_map[filter_entry.index].value;
 				Vector constant_vector(constant);
-				ApplyFilter(constant_vector, *filter_col.second, scan_count, state.sel, filter_count);
+				ApplyFilter(constant_vector, scan_filter.filter, scan_count, state.sel, filter_count);
 			} else {
 				auto id = filter_entry.index;
 				auto file_col_idx = reader_data.column_ids[id];
@@ -999,10 +1008,11 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				auto &result_vector = result.data[result_idx];
 				auto &child_reader = root_reader.GetChildReader(file_col_idx);
 				child_reader.Read(scan_count, define_ptr, repeat_ptr, result_vector);
-				ApplyFilter(result_vector, *filter_col.second, scan_count, state.sel, filter_count);
+				ApplyFilter(result_vector, scan_filter.filter, scan_count, state.sel, filter_count);
 				need_to_read[id] = false;
 			}
 		}
+		state.adaptive_filter->EndFilter(filter_state);
 
 		// we still may have to read some cols
 		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {

src/duckdb/extension/parquet/reader/string_column_reader.cpp

@@ -18,9 +18,9 @@ StringColumnReader::StringColumnReader(ParquetReader &reader, LogicalType type_p
 	}
 }
 
-uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len, const bool is_varchar) {
+void StringColumnReader::VerifyString(const char *str_data, uint32_t str_len, const bool is_varchar) {
 	if (!is_varchar) {
-		return str_len;
+		return;
 	}
 	// verify if a string is actually UTF8, and if there are no null bytes in the middle of the string
 	// technically Parquet should guarantee this, but reality is often disappointing
@@ -31,11 +31,10 @@ uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len
 		throw InvalidInputException("Invalid string encoding found in Parquet file: value \"" +
 		                            Blob::ToString(string_t(str_data, str_len)) + "\" is not valid UTF8!");
 	}
-	return str_len;
 }
 
-uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len) {
-	return VerifyString(str_data, str_len, Type() == LogicalTypeId::VARCHAR);
+void StringColumnReader::VerifyString(const char *str_data, uint32_t str_len) {
+	VerifyString(str_data, str_len, Type().id() == LogicalTypeId::VARCHAR);
 }
 
 class ParquetStringVectorBuffer : public VectorBuffer {
@@ -63,8 +62,8 @@ string_t StringParquetValueConversion::PlainRead(ByteBuffer &plain_data, ColumnR
 	uint32_t str_len = scr.fixed_width_string_length == 0 ? plain_data.read<uint32_t>() : scr.fixed_width_string_length;
 	plain_data.available(str_len);
 	auto plain_str = char_ptr_cast(plain_data.ptr);
-	auto actual_str_len = reader.Cast<StringColumnReader>().VerifyString(plain_str, str_len);
-	auto ret_str = string_t(plain_str, actual_str_len);
+	scr.VerifyString(plain_str, str_len);
+	auto ret_str = string_t(plain_str, str_len);
 	plain_data.inc(str_len);
 	return ret_str;
 }

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "1-dev128"
+#define DUCKDB_PATCH_VERSION "1-dev140"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 2
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.2.1-dev128"
+#define DUCKDB_VERSION "v1.2.1-dev140"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "9c2cce521f"
+#define DUCKDB_SOURCE_ID "2d530ad365"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"