vendor: Update vendored sources to duckdb/duckdb@3240832

V1.2 histrionicus (duckdb/duckdb#16024)

Author: krlmlr

src/duckdb/extension/core_functions/function_list.cpp

@@ -136,7 +136,6 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION(CovarPopFun),
 	DUCKDB_AGGREGATE_FUNCTION(CovarSampFun),
 	DUCKDB_SCALAR_FUNCTION(CurrentDatabaseFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentDateFun),
 	DUCKDB_SCALAR_FUNCTION(CurrentQueryFun),
 	DUCKDB_SCALAR_FUNCTION(CurrentSchemaFun),
 	DUCKDB_SCALAR_FUNCTION(CurrentSchemasFun),
@@ -193,7 +192,6 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_ALIAS(GenRandomUuidFun),
 	DUCKDB_SCALAR_FUNCTION_SET(GenerateSeriesFun),
 	DUCKDB_SCALAR_FUNCTION(GetBitFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentTimeFun),
 	DUCKDB_SCALAR_FUNCTION(GetCurrentTimestampFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(GradeUpFun),
 	DUCKDB_SCALAR_FUNCTION_SET(GreatestFun),
@@ -371,7 +369,6 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(ToTimestampFun),
 	DUCKDB_SCALAR_FUNCTION(ToWeeksFun),
 	DUCKDB_SCALAR_FUNCTION(ToYearsFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(TodayFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(TransactionTimestampFun),
 	DUCKDB_SCALAR_FUNCTION(TranslateFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TrimFun),

src/duckdb/extension/core_functions/include/core_functions/scalar/date_functions.hpp

@@ -33,21 +33,6 @@ struct CenturyFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct CurrentDateFun {
-	static constexpr const char *Name = "current_date";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the current date";
-	static constexpr const char *Example = "current_date()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TodayFun {
-	using ALIAS = CurrentDateFun;
-
-	static constexpr const char *Name = "today";
-};
-
 struct DateDiffFun {
 	static constexpr const char *Name = "date_diff";
 	static constexpr const char *Parameters = "part,startdate,enddate";
@@ -198,15 +183,6 @@ struct EpochNsFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct CurrentTimeFun {
-	static constexpr const char *Name = "get_current_time";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the current time";
-	static constexpr const char *Example = "get_current_time()";
-
-	static ScalarFunction GetFunction();
-};
-
 struct EraFun {
 	static constexpr const char *Name = "era";
 	static constexpr const char *Parameters = "ts";

src/duckdb/extension/core_functions/scalar/date/current.cpp

@@ -27,41 +27,4 @@ ScalarFunction GetCurrentTimestampFun::GetFunction() {
 	return current_timestamp;
 }
 
-static unique_ptr<Expression> CurrentTimeExpr(FunctionBindExpressionInput &input) {
-	auto timestamp = GetCurrentTimestampFun::GetFunction();
-	timestamp.name = GetCurrentTimestampFun::Name;
-
-	vector<unique_ptr<Expression>> args;
-
-	auto func = make_uniq_base<Expression, BoundFunctionExpression>(LogicalType::TIMESTAMP_TZ, timestamp,
-	                                                                std::move(args), nullptr);
-
-	return BoundCastExpression::AddCastToType(input.context, std::move(func), LogicalType::TIME_TZ);
-}
-
-static unique_ptr<Expression> CurrentDateExpr(FunctionBindExpressionInput &input) {
-	auto timestamp = GetCurrentTimestampFun::GetFunction();
-	timestamp.name = GetCurrentTimestampFun::Name;
-
-	vector<unique_ptr<Expression>> args;
-
-	auto func = make_uniq_base<Expression, BoundFunctionExpression>(LogicalType::TIMESTAMP_TZ, timestamp,
-	                                                                std::move(args), nullptr);
-	return BoundCastExpression::AddCastToType(input.context, std::move(func), LogicalType::DATE);
-}
-
-ScalarFunction CurrentTimeFun::GetFunction() {
-	ScalarFunction current_time({}, LogicalType::TIME_TZ, nullptr);
-	current_time.bind_expression = CurrentTimeExpr;
-	current_time.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_time;
-}
-
-ScalarFunction CurrentDateFun::GetFunction() {
-	ScalarFunction current_date({}, LogicalType::DATE, nullptr);
-	current_date.bind_expression = CurrentDateExpr;
-	current_date.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_date;
-}
-
 } // namespace duckdb

src/duckdb/extension/parquet/column_writer.cpp

@@ -498,6 +498,7 @@ void BasicColumnWriter::BeginWrite(ColumnWriterState &state_p) {
 		hdr.data_page_header.repetition_level_encoding = Encoding::RLE;
 
 		write_info.temp_writer = make_uniq<MemoryStream>(
+		    Allocator::Get(writer.GetContext()),
 		    MaxValue<idx_t>(NextPowerOfTwo(page_info.estimated_page_size), MemoryStream::DEFAULT_INITIAL_CAPACITY));
 		write_info.write_count = page_info.empty_count;
 		write_info.max_write_count = page_info.row_count;
@@ -1469,8 +1470,9 @@ class StandardColumnWriter : public BasicColumnWriter {
 		    make_uniq<ParquetBloomFilter>(state.dictionary.size(), writer.BloomFilterFalsePositiveRatio());
 
 		// first write the contents of the dictionary page to a temporary buffer
-		auto temp_writer = make_uniq<MemoryStream>(MaxValue<idx_t>(
-		    NextPowerOfTwo(state.dictionary.size() * sizeof(TGT)), MemoryStream::DEFAULT_INITIAL_CAPACITY));
+		auto temp_writer = make_uniq<MemoryStream>(
+		    Allocator::Get(writer.GetContext()), MaxValue<idx_t>(NextPowerOfTwo(state.dictionary.size() * sizeof(TGT)),
+		                                                         MemoryStream::DEFAULT_INITIAL_CAPACITY));
 		for (idx_t r = 0; r < values.size(); r++) {
 			const TGT target_value = OP::template Operation<SRC, TGT>(values[r]);
 			// update the statistics
@@ -1844,7 +1846,7 @@ class EnumColumnWriter : public BasicColumnWriter {
 		auto enum_count = EnumType::GetSize(enum_type);
 		auto string_values = FlatVector::GetData<string_t>(enum_values);
 		// first write the contents of the dictionary page to a temporary buffer
-		auto temp_writer = make_uniq<MemoryStream>();
+		auto temp_writer = make_uniq<MemoryStream>(Allocator::Get(writer.GetContext()));
 		for (idx_t r = 0; r < enum_count; r++) {
 			D_ASSERT(!FlatVector::IsNull(enum_values, r));
 			// update the statistics

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

@@ -91,6 +91,9 @@ class ParquetWriter {
 	static duckdb_parquet::Type::type DuckDBTypeToParquetType(const LogicalType &duckdb_type);
 	static void SetSchemaProperties(const LogicalType &duckdb_type, duckdb_parquet::SchemaElement &schema_ele);
 
+	ClientContext &GetContext() {
+		return context;
+	}
 	duckdb_apache::thrift::protocol::TProtocol *GetProtocol() {
 		return protocol.get();
 	}
@@ -138,6 +141,7 @@ class ParquetWriter {
 	void BufferBloomFilter(idx_t col_idx, unique_ptr<ParquetBloomFilter> bloom_filter);
 
 private:
+	ClientContext &context;
 	string file_name;
 	vector<LogicalType> sql_types;
 	vector<string> column_names;

src/duckdb/extension/parquet/parquet_writer.cpp

@@ -322,9 +322,9 @@ ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file
                              shared_ptr<ParquetEncryptionConfig> encryption_config_p, idx_t dictionary_size_limit_p,
                              double bloom_filter_false_positive_ratio_p, int64_t compression_level_p,
                              bool debug_use_openssl_p, ParquetVersion parquet_version)
-    : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec),
-      field_ids(std::move(field_ids_p)), encryption_config(std::move(encryption_config_p)),
-      dictionary_size_limit(dictionary_size_limit_p),
+    : context(context), file_name(std::move(file_name_p)), sql_types(std::move(types_p)),
+      column_names(std::move(names_p)), codec(codec), field_ids(std::move(field_ids_p)),
+      encryption_config(std::move(encryption_config_p)), dictionary_size_limit(dictionary_size_limit_p),
       bloom_filter_false_positive_ratio(bloom_filter_false_positive_ratio_p), compression_level(compression_level_p),
       debug_use_openssl(debug_use_openssl_p), parquet_version(parquet_version) {
 

src/duckdb/src/catalog/catalog_set.cpp

@@ -353,7 +353,7 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		// serialize the AlterInfo into a temporary buffer
-		MemoryStream stream;
+		MemoryStream stream(Allocator::Get(*transaction.db));
 		BinarySerializer serializer(stream);
 		serializer.Begin();
 		serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());

src/duckdb/src/common/serializer/memory_stream.cpp

@@ -4,18 +4,21 @@
 
 namespace duckdb {
 
-MemoryStream::MemoryStream(idx_t capacity) : position(0), capacity(capacity), owns_data(true) {
+MemoryStream::MemoryStream(Allocator &allocator_p, idx_t capacity)
+    : allocator(&allocator_p), position(0), capacity(capacity) {
 	D_ASSERT(capacity != 0 && IsPowerOfTwo(capacity));
-	data = Allocator::DefaultAllocatorReference()->AllocateData(capacity);
+	data = allocator_p.AllocateData(capacity);
 }
 
-MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity)
-    : position(0), capacity(capacity), owns_data(false), data(buffer) {
+MemoryStream::MemoryStream(idx_t capacity) : MemoryStream(Allocator::DefaultAllocator(), capacity) {
+}
+
+MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity) : position(0), capacity(capacity), data(buffer) {
 }
 
 MemoryStream::~MemoryStream() {
-	if (owns_data) {
-		Allocator::DefaultAllocatorReference()->FreeData(data, capacity);
+	if (allocator && data) {
+		allocator->FreeData(data, capacity);
 	}
 }
 
@@ -24,48 +27,48 @@ MemoryStream::MemoryStream(MemoryStream &&other) noexcept {
 	data = other.data;
 	position = other.position;
 	capacity = other.capacity;
-	owns_data = other.owns_data;
+	allocator = other.allocator;
 
 	// Reset the other stream
 	other.data = nullptr;
 	other.position = 0;
 	other.capacity = 0;
-	other.owns_data = false;
+	other.allocator = nullptr;
 }
 
 MemoryStream &MemoryStream::operator=(MemoryStream &&other) noexcept {
 	if (this != &other) {
 		// Free the current data
-		if (owns_data) {
-			Allocator::DefaultAllocatorReference()->FreeData(data, capacity);
+		if (allocator) {
+			allocator->FreeData(data, capacity);
 		}
 
 		// Move the data from the other stream into this stream
 		data = other.data;
 		position = other.position;
 		capacity = other.capacity;
-		owns_data = other.owns_data;
+		allocator = other.allocator;
 
 		// Reset the other stream
 		other.data = nullptr;
 		other.position = 0;
 		other.capacity = 0;
-		other.owns_data = false;
+		other.allocator = nullptr;
 	}
 	return *this;
 }
 
 void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) {
 	const auto old_capacity = capacity;
 	while (position + write_size > capacity) {
-		if (owns_data) {
+		if (allocator) {
 			capacity *= 2;
 		} else {
 			throw SerializationException("Failed to serialize: not enough space in buffer to fulfill write request");
 		}
 	}
 	if (capacity != old_capacity) {
-		data = Allocator::DefaultAllocatorReference()->ReallocateData(data, old_capacity, capacity);
+		data = allocator->ReallocateData(data, old_capacity, capacity);
 	}
 	memcpy(data + position, source, write_size);
 	position += write_size;
@@ -84,7 +87,7 @@ void MemoryStream::Rewind() {
 }
 
 void MemoryStream::Release() {
-	owns_data = false;
+	allocator = nullptr;
 }
 
 data_ptr_t MemoryStream::GetData() const {

src/duckdb/src/common/types/bit.cpp

@@ -179,7 +179,7 @@ void Bit::BitToBlob(bitstring_t bit, string_t &output_blob) {
 	auto output = output_blob.GetDataWriteable();
 	idx_t size = output_blob.GetSize();
 
-	output[0] = UnsafeNumericCast<char>(GetFirstByte(bit));
+	output[0] = static_cast<char>(GetFirstByte(bit));
 	if (size >= 2) {
 		++output;
 		// First byte in bitstring contains amount of padded bits,

src/duckdb/src/common/types/data_chunk.cpp

@@ -369,7 +369,8 @@ void DataChunk::Verify() {
 	}
 
 	// verify that we can round-trip chunk serialization
-	MemoryStream mem_stream;
+	Allocator allocator;
+	MemoryStream mem_stream(allocator);
 	BinarySerializer serializer(mem_stream);
 
 	serializer.Begin();