duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_memory_manager.hpp

@@ -0,0 +1,165 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/batch_memory_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/storage/temporary_memory_manager.hpp"
+#include "duckdb/parallel/interrupt.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+class BatchMemoryManager {
+public:
+	BatchMemoryManager(ClientContext &context, idx_t initial_memory_request)
+	    : context(context), unflushed_memory_usage(0), min_batch_index(0), available_memory(0),
+	      can_increase_memory(true) {
+		memory_state = TemporaryMemoryManager::Get(context).Register(context);
+		SetMemorySize(initial_memory_request);
+	}
+
+private:
+	ClientContext &context;
+	//! Temporary memory state
+	unique_ptr<TemporaryMemoryState> memory_state;
+	//! Total memory usage of unflushed rows
+	atomic<idx_t> unflushed_memory_usage;
+	//! Minimum batch size
+	atomic<idx_t> min_batch_index;
+	//! The available memory for unflushed rows
+	atomic<idx_t> available_memory;
+	//! Blocked task lock
+	mutex blocked_task_lock;
+	//! The set of blocked tasks
+	vector<InterruptState> blocked_tasks;
+	//! Whether or not we can request additional memory
+	bool can_increase_memory;
+
+public:
+	void SetMemorySize(idx_t size) {
+		// request at most 1/4th of all available memory
+		idx_t total_max_memory = BufferManager::GetBufferManager(context).GetQueryMaxMemory();
+		idx_t request_cap = total_max_memory / 4;
+
+		size = MinValue<idx_t>(size, request_cap);
+		if (size <= available_memory) {
+			return;
+		}
+
+		memory_state->SetRemainingSize(context, size);
+		auto next_reservation = memory_state->GetReservation();
+		if (available_memory >= next_reservation) {
+			// we tried to ask for more memory but were declined
+			// stop asking for more memory
+			can_increase_memory = false;
+		}
+		available_memory = next_reservation;
+	}
+
+	void IncreaseMemory() {
+		if (!can_increase_memory) {
+			return;
+		}
+		SetMemorySize(available_memory * 2);
+	}
+
+	bool OutOfMemory(idx_t batch_index) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+		// alternative verify - always report that we are out of memory to test this code path
+		return true;
+#else
+		if (unflushed_memory_usage >= available_memory) {
+			lock_guard<mutex> l(blocked_task_lock);
+			if (batch_index > min_batch_index) {
+				// exceeded available memory and we are not the minimum batch index- try to increase it
+				IncreaseMemory();
+				if (unflushed_memory_usage >= available_memory) {
+					// STILL out of memory
+					return true;
+				}
+			}
+		}
+		return false;
+#endif
+	}
+
+	void BlockTask(InterruptState &state) {
+		blocked_tasks.push_back(state);
+	}
+
+	bool UnblockTasks() {
+		lock_guard<mutex> l(blocked_task_lock);
+		return UnblockTasksInternal();
+	}
+
+	bool UnblockTasksInternal() {
+		if (blocked_tasks.empty()) {
+			return false;
+		}
+		for (auto &entry : blocked_tasks) {
+			entry.Callback();
+		}
+		blocked_tasks.clear();
+		return true;
+	}
+
+	void UpdateMinBatchIndex(idx_t current_min_batch_index) {
+		if (min_batch_index >= current_min_batch_index) {
+			return;
+		}
+		lock_guard<mutex> l(blocked_task_lock);
+		auto new_batch_index = MaxValue<idx_t>(min_batch_index, current_min_batch_index);
+		if (new_batch_index != min_batch_index) {
+			// new batch index! unblock all tasks
+			min_batch_index = new_batch_index;
+			UnblockTasksInternal();
+		}
+	}
+
+	idx_t AvailableMemory() const {
+		return available_memory;
+	}
+
+	idx_t GetMinimumBatchIndex() const {
+		return min_batch_index;
+	}
+
+	mutex &GetBlockedTaskLock() {
+		return blocked_task_lock;
+	}
+
+	idx_t GetUnflushedMemory() {
+		return unflushed_memory_usage;
+	}
+
+	void IncreaseUnflushedMemory(idx_t memory_increase) {
+		unflushed_memory_usage += memory_increase;
+	}
+
+	void ReduceUnflushedMemory(idx_t memory_reduction) {
+		if (unflushed_memory_usage < memory_reduction) {
+			throw InternalException("Reducing unflushed memory usage below zero!?");
+		} else {
+			unflushed_memory_usage -= memory_reduction;
+		}
+	}
+
+	bool IsMinimumBatchIndex(idx_t batch_index) {
+		return batch_index <= min_batch_index;
+	}
+
+	void FinalCheck() {
+		if (unflushed_memory_usage != 0) {
+			throw InternalException("Unflushed memory usage is not zero at finalize but %llu",
+			                        unflushed_memory_usage.load());
+		}
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_task_manager.hpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/batch_task_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/storage/temporary_memory_manager.hpp"
+#include "duckdb/parallel/interrupt.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/queue.hpp"
+
+namespace duckdb {
+
+template <class TASK>
+class BatchTaskManager {
+public:
+	void AddTask(unique_ptr<TASK> task) {
+		lock_guard<mutex> l(task_lock);
+		task_queue.push(std::move(task));
+	}
+
+	unique_ptr<TASK> GetTask() {
+		lock_guard<mutex> l(task_lock);
+		if (task_queue.empty()) {
+			return nullptr;
+		}
+		auto entry = std::move(task_queue.front());
+		task_queue.pop();
+		return entry;
+	}
+
+	idx_t TaskCount() {
+		lock_guard<mutex> l(task_lock);
+		return task_queue.size();
+	}
+
+private:
+	mutex task_lock;
+	//! The task queue for the batch copy to file
+	queue<unique_ptr<TASK>> task_queue;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp
+// duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -15,8 +15,8 @@
 #include "duckdb/common/filename_pattern.hpp"
 
 namespace duckdb {
+struct FixedRawBatchData;
 
-//! Copy the contents of a query into a table
 class PhysicalBatchCopyToFile : public PhysicalOperator {
 public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_COPY_TO_FILE;
@@ -60,22 +60,15 @@ public:
 		return true;
 	}
 
-private:
-	void PrepareBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
-	                      unique_ptr<ColumnDataCollection> collection) const;
+public:
+	void AddLocalBatch(ClientContext &context, GlobalSinkState &gstate, LocalSinkState &state) const;
+	void AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
+	                     unique_ptr<FixedRawBatchData> collection) const;
+	void RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index,
+	                        bool final = false) const;
 	void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const;
+	bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const;
+	void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const;
 	SinkFinalizeType FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const;
 };
-
-struct ActiveFlushGuard {
-	explicit ActiveFlushGuard(atomic<bool> &bool_value_p) : bool_value(bool_value_p) {
-		bool_value = true;
-	}
-	~ActiveFlushGuard() {
-		bool_value = false;
-	}
-
-	atomic<bool> &bool_value;
-};
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp

@@ -69,6 +69,10 @@ public:
 	bool ParallelSink() const override {
 		return true;
 	}
+
+private:
+	bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const;
+	void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp

@@ -72,6 +72,8 @@ public:
 
 	static void MoveTmpFile(ClientContext &context, const string &tmp_file_path);
 
+	string GetTrimmedPath(ClientContext &context) const;
+
 private:
 	unique_ptr<GlobalFunctionData> CreateFileState(ClientContext &context, GlobalSinkState &sink) const;
 };

package/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp

@@ -47,7 +47,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -64,7 +64,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -85,7 +85,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -93,6 +93,10 @@ public:
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
 		return reinterpret_cast<const TARGET &>(*this);
 	}
+
+	virtual idx_t MaxThreads(idx_t source_max_threads) {
+		return source_max_threads;
+	}
 };
 
 class LocalSinkState {
@@ -105,7 +109,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -126,7 +130,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -143,7 +147,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -12,7 +12,6 @@
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/logical_tokens.hpp"
-#include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/joinside.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/common/unordered_map.hpp"
@@ -71,7 +70,6 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalFilter &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalGet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimit &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimitPercent &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalOrder &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalTopN &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalPositionalJoin &op);

package/src/duckdb/src/include/duckdb/execution/window_executor.hpp

@@ -39,6 +39,7 @@ struct WindowInputExpression {
 			chunk.Reset();
 			executor.Execute(input_chunk, chunk);
 			chunk.Verify();
+			chunk.Flatten();
 		}
 	}
 
@@ -125,7 +126,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/execution/window_segment_tree.hpp

@@ -26,7 +26,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp

@@ -26,6 +26,7 @@ struct GetCastFunctionInput {
 	}
 
 	optional_ptr<ClientContext> context;
+	optional_idx query_location;
 };
 
 struct BindCastFunction {

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -25,7 +25,7 @@ struct BindCastInfo {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -43,7 +43,7 @@ struct BoundCastData {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -56,13 +56,17 @@ struct BoundCastData {
 struct CastParameters {
 	CastParameters() {
 	}
+	CastParameters(bool strict, string *error_message) : CastParameters(nullptr, strict, error_message, nullptr) {
+	}
 	CastParameters(BoundCastData *cast_data, bool strict, string *error_message,
-	               optional_ptr<FunctionLocalState> local_state)
-	    : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state) {
+	               optional_ptr<FunctionLocalState> local_state, bool nullify_parent_p = false)
+	    : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state),
+	      nullify_parent(nullify_parent_p) {
 	}
 	CastParameters(CastParameters &parent, optional_ptr<BoundCastData> cast_data,
 	               optional_ptr<FunctionLocalState> local_state)
-	    : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message), local_state(local_state) {
+	    : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message), local_state(local_state),
+	      query_location(parent.query_location) {
 	}
 
 	//! The bound cast data (if any)
@@ -73,6 +77,10 @@ struct CastParameters {
 	string *error_message = nullptr;
 	//! Local state
 	optional_ptr<FunctionLocalState> local_state;
+	//! Query location (if any)
+	optional_idx query_location;
+	//! In the case of a nested type, when facing a cast error, if we nullify the parent
+	bool nullify_parent = false;
 };
 
 struct CastLocalStateParameters {
@@ -114,6 +122,7 @@ struct BindCastInput {
 	CastFunctionSet &function_set;
 	optional_ptr<BindCastInfo> info;
 	optional_ptr<ClientContext> context;
+	optional_idx query_location;
 
 public:
 	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target);

package/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp

@@ -26,17 +26,6 @@ struct VectorStringCastOperator {
 	}
 };
 
-struct VectorTryCastData {
-	VectorTryCastData(Vector &result_p, string *error_message_p, bool strict_p)
-	    : result(result_p), error_message(error_message_p), strict(strict_p) {
-	}
-
-	Vector &result;
-	string *error_message;
-	bool strict;
-	bool all_converted = true;
-};
-
 template <class OP>
 struct VectorTryCastOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -47,7 +36,7 @@ struct VectorTryCastOperator {
 		}
 		auto data = (VectorTryCastData *)dataptr;
 		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
+		                                                     idx, *data);
 	}
 };
 
@@ -57,11 +46,11 @@ struct VectorTryCastStrictOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (VectorTryCastData *)dataptr;
 		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->strict))) {
+		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters.strict))) {
 			return output;
 		}
 		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
+		                                                     idx, *data);
 	}
 };
 
@@ -71,14 +60,13 @@ struct VectorTryCastErrorOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (VectorTryCastData *)dataptr;
 		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(
-		        OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->error_message, data->strict))) {
+		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters))) {
 			return output;
 		}
-		bool has_error = data->error_message && !data->error_message->empty();
+		bool has_error = data->parameters.error_message && !data->parameters.error_message->empty();
 		return HandleVectorCastError::Operation<RESULT_TYPE>(
-		    has_error ? *data->error_message : CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask, idx,
-		    data->error_message, data->all_converted);
+		    has_error ? *data->parameters.error_message : CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask, idx,
+		    *data);
 	}
 };
 
@@ -88,24 +76,23 @@ struct VectorTryCastStringOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (VectorTryCastData *)dataptr;
 		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->result,
-		                                                                  data->error_message, data->strict))) {
+		if (DUCKDB_LIKELY(
+		        OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->result, data->parameters))) {
 			return output;
 		}
 		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
+		                                                     idx, *data);
 	}
 };
 
 struct VectorDecimalCastData {
-	VectorDecimalCastData(string *error_message_p, uint8_t width_p, uint8_t scale_p)
-	    : error_message(error_message_p), width(width_p), scale(scale_p) {
+	VectorDecimalCastData(Vector &result, CastParameters &parameters, uint8_t width_p, uint8_t scale_p)
+	    : vector_cast_data(result, parameters), width(width_p), scale(scale_p) {
 	}
 
-	string *error_message;
+	VectorTryCastData vector_cast_data;
 	uint8_t width;
 	uint8_t scale;
-	bool all_converted = true;
 };
 
 template <class OP>
@@ -114,10 +101,10 @@ struct VectorDecimalCastOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (VectorDecimalCastData *)dataptr;
 		RESULT_TYPE result_value;
-		if (!OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, result_value, data->error_message, data->width,
-		                                                     data->scale)) {
+		if (!OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, result_value, data->vector_cast_data.parameters,
+		                                                     data->width, data->scale)) {
 			return HandleVectorCastError::Operation<RESULT_TYPE>("Failed to cast decimal value", mask, idx,
-			                                                     data->error_message, data->all_converted);
+			                                                     data->vector_cast_data);
 		}
 		return result_value;
 	}
@@ -132,7 +119,7 @@ struct VectorCastHelpers {
 
 	template <class SRC, class DST, class OP>
 	static bool TemplatedTryCastLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		VectorTryCastData input(result, parameters.error_message, parameters.strict);
+		VectorTryCastData input(result, parameters);
 		UnaryExecutor::GenericExecute<SRC, DST, OP>(source, result, count, &input, parameters.error_message);
 		return input.all_converted;
 	}
@@ -166,12 +153,12 @@ struct VectorCastHelpers {
 	}
 
 	template <class SRC, class T, class OP>
-	static bool TemplatedDecimalCast(Vector &source, Vector &result, idx_t count, string *error_message, uint8_t width,
-	                                 uint8_t scale) {
-		VectorDecimalCastData input(error_message, width, scale);
+	static bool TemplatedDecimalCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters,
+	                                 uint8_t width, uint8_t scale) {
+		VectorDecimalCastData input(result, parameters, width, scale);
 		UnaryExecutor::GenericExecute<SRC, T, VectorDecimalCastOperator<OP>>(source, result, count, (void *)&input,
-		                                                                     error_message);
-		return input.all_converted;
+		                                                                     parameters.error_message);
+		return input.vector_cast_data.all_converted;
 	}
 
 	template <class T>
@@ -181,17 +168,14 @@ struct VectorCastHelpers {
 		auto scale = DecimalType::GetScale(result_type);
 		switch (result_type.InternalType()) {
 		case PhysicalType::INT16:
-			return TemplatedDecimalCast<T, int16_t, TryCastToDecimal>(source, result, count, parameters.error_message,
-			                                                          width, scale);
+			return TemplatedDecimalCast<T, int16_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
 		case PhysicalType::INT32:
-			return TemplatedDecimalCast<T, int32_t, TryCastToDecimal>(source, result, count, parameters.error_message,
-			                                                          width, scale);
+			return TemplatedDecimalCast<T, int32_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
 		case PhysicalType::INT64:
-			return TemplatedDecimalCast<T, int64_t, TryCastToDecimal>(source, result, count, parameters.error_message,
-			                                                          width, scale);
+			return TemplatedDecimalCast<T, int64_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
 		case PhysicalType::INT128:
-			return TemplatedDecimalCast<T, hugeint_t, TryCastToDecimal>(source, result, count, parameters.error_message,
-			                                                            width, scale);
+			return TemplatedDecimalCast<T, hugeint_t, TryCastToDecimal>(source, result, count, parameters, width,
+			                                                            scale);
 		default:
 			throw InternalException("Unimplemented internal type for decimal");
 		}

package/src/duckdb/src/include/duckdb/function/compression_function.hpp

@@ -34,7 +34,7 @@ struct AnalyzeState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -50,7 +50,7 @@ struct CompressionState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -71,7 +71,7 @@ struct CompressedSegmentState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -91,7 +91,7 @@ struct CompressionAppendState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/function/copy_function.hpp

@@ -26,7 +26,7 @@ struct LocalFunctionData {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -42,7 +42,7 @@ struct GlobalFunctionData {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -58,7 +58,7 @@ struct PreparedBatchData {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>