Update vendored DuckDB sources to eade9cb

Author: duckdblabs-bot

src/duckdb/extension/core_functions/scalar/list/list_value.cpp

@@ -52,6 +52,59 @@ static void TemplatedListValueFunction(DataChunk &args, Vector &result) {
 	ListVector::SetListSize(result, args.size() * list_size);
 }
 
+static void ListValueListFunction(DataChunk &args, Vector &result) {
+	const idx_t list_size = args.ColumnCount();
+	ListVector::Reserve(result, args.size() * list_size);
+
+	vector<idx_t> col_offsets;
+	idx_t offset_sum = 0;
+	for (idx_t i = 0; i < list_size; i++) {
+		col_offsets.push_back(offset_sum);
+		auto &list = args.data[i];
+		const auto length = ListVector::GetListSize(list);
+		offset_sum += length;
+	}
+
+	auto &result_list = ListVector::GetEntry(result);
+	ListVector::Reserve(result_list, offset_sum);
+
+	auto &result_child_vector = ListVector::GetEntry(result_list);
+	for (idx_t i = 0; i < list_size; i++) {
+		auto list = args.data[i];
+		const auto length = ListVector::GetListSize(list);
+		if (length == 0) {
+			continue;
+		}
+		auto &child_vector = ListVector::GetEntry(list);
+		VectorOperations::Copy(child_vector, result_child_vector, length, 0, col_offsets[i]);
+	}
+
+	const auto result_data = FlatVector::GetData<list_entry_t>(result);
+	const auto result_list_data = FlatVector::GetData<list_entry_t>(result_list);
+	auto &result_list_validity = FlatVector::Validity(result_list);
+
+	const auto args_unified_format = args.ToUnifiedFormat();
+	for (idx_t r = 0; r < args.size(); r++) {
+		for (idx_t c = 0; c < list_size; c++) {
+			const auto input_idx = args_unified_format[c].sel->get_index(r);
+			const auto result_idx = r * list_size + c;
+			const auto input_data = UnifiedVectorFormat::GetData<list_entry_t>(args_unified_format[c]);
+			if (args_unified_format[c].validity.RowIsValid(input_idx)) {
+				const auto length = input_data[input_idx].length;
+				const auto offset = col_offsets[c] + input_data[input_idx].offset;
+				result_list_data[result_idx] = list_entry_t(offset, length);
+			} else {
+				result_list_validity.SetInvalid(result_idx);
+			}
+		}
+		result_data[r].offset = r * list_size;
+		result_data[r].length = list_size;
+	}
+
+	ListVector::SetListSize(result, args.size() * list_size);
+	ListVector::SetListSize(result_list, offset_sum);
+}
+
 static void TemplatedListValueFunctionFallback(DataChunk &args, Vector &result) {
 	auto &child_type = ListType::GetChildType(result.GetType());
 	auto result_data = FlatVector::GetData<list_entry_t>(result);
@@ -125,6 +178,9 @@ static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &r
 	case PhysicalType::VARCHAR:
 		TemplatedListValueFunction<string_t, ListValueStringAssign>(args, result);
 		break;
+	case PhysicalType::LIST:
+		ListValueListFunction(args, result);
+		break;
 	default: {
 		TemplatedListValueFunctionFallback(args, result);
 		break;

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

@@ -15,11 +15,14 @@ namespace duckdb {
 class BssEncoder {
 public:
 	explicit BssEncoder(const idx_t total_value_count_p, const idx_t bit_width_p)
-	    : total_value_count(total_value_count_p), bit_width(bit_width_p), count(0),
-	      buffer(Allocator::DefaultAllocator().Allocate(total_value_count * bit_width + 1)) {
+	    : total_value_count(total_value_count_p), bit_width(bit_width_p), count(0) {
 	}
 
 public:
+	void BeginWrite(Allocator &allocator) {
+		buffer = allocator.Allocate(total_value_count * bit_width + 1);
+	}
+
 	template <class T>
 	void WriteValue(const T &value) {
 		D_ASSERT(sizeof(T) == bit_width);
@@ -41,23 +44,4 @@ class BssEncoder {
 	AllocatedData buffer;
 };
 
-namespace bss_encoder {
-
-template <class T>
-void WriteValue(BssEncoder &encoder, const T &value) {
-	throw InternalException("Can't write type to BYTE_STREAM_SPLIT column");
-}
-
-template <>
-void WriteValue(BssEncoder &encoder, const float &value) {
-	encoder.WriteValue(value);
-}
-
-template <>
-void WriteValue(BssEncoder &encoder, const double &value) {
-	encoder.WriteValue(value);
-}
-
-} // namespace bss_encoder
-
 } // namespace duckdb

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

@@ -23,7 +23,27 @@ class DbpEncoder {
 	}
 
 public:
-	void BeginWrite(WriteStream &writer, const int64_t &first_value) {
+	template <class T>
+	void BeginWrite(WriteStream &writer, const T &first_value) {
+		throw InternalException("DbpEncoder should only be used with integers");
+	}
+
+	template <class T>
+	void WriteValue(WriteStream &writer, const T &value) {
+		throw InternalException("DbpEncoder should only be used with integers");
+	}
+
+	void FinishWrite(WriteStream &writer) {
+		if (count + block_count != total_value_count) {
+			throw InternalException("value count mismatch when writing DELTA_BINARY_PACKED");
+		}
+		if (block_count != 0) {
+			WriteBlock(writer);
+		}
+	}
+
+private:
+	void BeginWriteInternal(WriteStream &writer, const int64_t &first_value) {
 		// <block size in values> <number of miniblocks in a block> <total value count> <first value>
 
 		// the block size is a multiple of 128; it is stored as a ULEB128 int
@@ -50,7 +70,7 @@ class DbpEncoder {
 		block_count = 0;
 	}
 
-	void WriteValue(WriteStream &writer, const int64_t &value) {
+	void WriteValueInternal(WriteStream &writer, const int64_t &value) {
 		// 1. Compute the differences between consecutive elements. For the first element in the block,
 		// use the last element in the previous block or, in the case of the first block,
 		// use the first value of the whole sequence, stored in the header.
@@ -72,16 +92,6 @@ class DbpEncoder {
 		}
 	}
 
-	void FinishWrite(WriteStream &writer) {
-		if (count + block_count != total_value_count) {
-			throw InternalException("value count mismatch when writing DELTA_BINARY_PACKED");
-		}
-		if (block_count != 0) {
-			WriteBlock(writer);
-		}
-	}
-
-private:
 	void WriteBlock(WriteStream &writer) {
 		D_ASSERT(count + block_count == total_value_count || block_count == BLOCK_SIZE_IN_VALUES);
 		const auto number_of_miniblocks =
@@ -176,58 +186,44 @@ class DbpEncoder {
 	data_t data_packed[NUMBER_OF_VALUES_IN_A_MINIBLOCK * sizeof(int64_t)];
 };
 
-namespace dbp_encoder {
-
-template <class T>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const T &first_value) {
-	throw InternalException("Can't write type to DELTA_BINARY_PACKED column");
-}
-
 template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const int64_t &first_value) {
-	encoder.BeginWrite(writer, first_value);
+inline void DbpEncoder::BeginWrite(WriteStream &writer, const int32_t &first_value) {
+	BeginWriteInternal(writer, first_value);
 }
 
 template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const int32_t &first_value) {
-	BeginWrite(encoder, writer, UnsafeNumericCast<int64_t>(first_value));
+inline void DbpEncoder::BeginWrite(WriteStream &writer, const int64_t &first_value) {
+	BeginWriteInternal(writer, first_value);
 }
 
 template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const uint64_t &first_value) {
-	encoder.BeginWrite(writer, UnsafeNumericCast<int64_t>(first_value));
+inline void DbpEncoder::BeginWrite(WriteStream &writer, const uint32_t &first_value) {
+	BeginWriteInternal(writer, first_value);
 }
 
 template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const uint32_t &first_value) {
-	BeginWrite(encoder, writer, UnsafeNumericCast<int64_t>(first_value));
-}
-
-template <class T>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const T &value) {
-	throw InternalException("Can't write type to DELTA_BINARY_PACKED column");
+inline void DbpEncoder::BeginWrite(WriteStream &writer, const uint64_t &first_value) {
+	BeginWriteInternal(writer, first_value);
 }
 
 template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const int64_t &value) {
-	encoder.WriteValue(writer, value);
+inline void DbpEncoder::WriteValue(WriteStream &writer, const int32_t &first_value) {
+	WriteValueInternal(writer, first_value);
 }
 
 template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const int32_t &value) {
-	WriteValue(encoder, writer, UnsafeNumericCast<int64_t>(value));
+inline void DbpEncoder::WriteValue(WriteStream &writer, const int64_t &first_value) {
+	WriteValueInternal(writer, first_value);
 }
 
 template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const uint64_t &value) {
-	encoder.WriteValue(writer, UnsafeNumericCast<int64_t>(value));
+inline void DbpEncoder::WriteValue(WriteStream &writer, const uint32_t &first_value) {
+	WriteValueInternal(writer, first_value);
 }
 
 template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const uint32_t &value) {
-	WriteValue(encoder, writer, UnsafeNumericCast<int64_t>(value));
+inline void DbpEncoder::WriteValue(WriteStream &writer, const uint64_t &first_value) {
+	WriteValueInternal(writer, first_value);
 }
 
-} // namespace dbp_encoder
-
 } // namespace duckdb

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

@@ -16,67 +16,54 @@ namespace duckdb {
 class DlbaEncoder {
 public:
 	DlbaEncoder(const idx_t total_value_count_p, const idx_t total_string_size_p)
-	    : dbp_encoder(total_value_count_p), total_string_size(total_string_size_p),
-	      buffer(Allocator::DefaultAllocator().Allocate(total_string_size + 1)),
-	      stream(make_unsafe_uniq<MemoryStream>(buffer.get(), buffer.GetSize())) {
+	    : dbp_encoder(total_value_count_p), total_string_size(total_string_size_p) {
 	}
 
 public:
-	void BeginWrite(WriteStream &writer, const string_t &first_value) {
-		dbp_encoder.BeginWrite(writer, UnsafeNumericCast<int64_t>(first_value.GetSize()));
-		stream->WriteData(const_data_ptr_cast(first_value.GetData()), first_value.GetSize());
+	template <class T>
+	void BeginWrite(Allocator &, WriteStream &, const T &) {
+		throw InternalException("DlbaEncoder should only be used with strings");
 	}
 
-	void WriteValue(WriteStream &writer, const string_t &value) {
-		dbp_encoder.WriteValue(writer, UnsafeNumericCast<int64_t>(value.GetSize()));
-		stream->WriteData(const_data_ptr_cast(value.GetData()), value.GetSize());
+	template <class T>
+	void WriteValue(WriteStream &, const T &) {
+		throw InternalException("DlbaEncoder should only be used with strings");
 	}
 
 	void FinishWrite(WriteStream &writer) {
 		dbp_encoder.FinishWrite(writer);
 		writer.WriteData(buffer.get(), stream->GetPosition());
 	}
 
+	template <class SRC>
+	static idx_t GetStringSize(const SRC &) {
+		return 0;
+	}
+
 private:
 	DbpEncoder dbp_encoder;
 	const idx_t total_string_size;
 	AllocatedData buffer;
 	unsafe_unique_ptr<MemoryStream> stream;
 };
 
-namespace dlba_encoder {
-
-template <class T>
-void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const T &first_value) {
-	throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column");
-}
-
 template <>
-void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const string_t &first_value) {
-	encoder.BeginWrite(writer, first_value);
-}
-
-template <class T>
-void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const T &value) {
-	throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column");
+inline void DlbaEncoder::BeginWrite(Allocator &allocator, WriteStream &writer, const string_t &first_value) {
+	buffer = allocator.Allocate(total_string_size + 1);
+	stream = make_unsafe_uniq<MemoryStream>(buffer.get(), buffer.GetSize());
+	dbp_encoder.BeginWrite(writer, UnsafeNumericCast<int64_t>(first_value.GetSize()));
+	stream->WriteData(const_data_ptr_cast(first_value.GetData()), first_value.GetSize());
 }
 
 template <>
-void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const string_t &value) {
-	encoder.WriteValue(writer, value);
-}
-
-// helpers to get size from strings
-template <class SRC>
-static idx_t GetDlbaStringSize(const SRC &) {
-	return 0;
+inline void DlbaEncoder::WriteValue(WriteStream &writer, const string_t &value) {
+	dbp_encoder.WriteValue(writer, UnsafeNumericCast<int64_t>(value.GetSize()));
+	stream->WriteData(const_data_ptr_cast(value.GetData()), value.GetSize());
 }
 
 template <>
-idx_t GetDlbaStringSize(const string_t &src_value) {
+inline idx_t DlbaEncoder::GetStringSize(const string_t &src_value) {
 	return src_value.GetSize();
 }
 
-} // namespace dlba_encoder
-
 } // namespace duckdb

src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp

@@ -63,16 +63,10 @@ class PrimitiveColumnWriter : public ColumnWriter {
 
 	//! We limit the uncompressed page size to 100MB
 	//! The max size in Parquet is 2GB, but we choose a more conservative limit
-	static constexpr const idx_t MAX_UNCOMPRESSED_PAGE_SIZE = 100000000;
+	static constexpr const idx_t MAX_UNCOMPRESSED_PAGE_SIZE = 104857600ULL;
 	//! Dictionary pages must be below 2GB. Unlike data pages, there's only one dictionary page.
 	//! For this reason we go with a much higher, but still a conservative upper bound of 1GB;
-	static constexpr const idx_t MAX_UNCOMPRESSED_DICT_PAGE_SIZE = 1e9;
-	//! If the dictionary has this many entries, we stop creating the dictionary
-	static constexpr const idx_t DICTIONARY_ANALYZE_THRESHOLD = 1e4;
-	//! The maximum size a key entry in an RLE page takes
-	static constexpr const idx_t MAX_DICTIONARY_KEY_SIZE = sizeof(uint32_t);
-	//! The size of encoding the string length
-	static constexpr const idx_t STRING_LENGTH_SIZE = sizeof(uint32_t);
+	static constexpr const idx_t MAX_UNCOMPRESSED_DICT_PAGE_SIZE = 1073741824ULL;
 
 public:
 	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override;