duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/core_functions/lambda_functions.hpp

@@ -0,0 +1,131 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/lambda_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function.hpp"
+#include "duckdb/execution/expression_executor_state.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+
+namespace duckdb {
+
+struct ListLambdaBindData : public FunctionData {
+public:
+	ListLambdaBindData(const LogicalType &return_type, unique_ptr<Expression> lambda_expr, const bool has_index = false)
+	    : return_type(return_type), lambda_expr(std::move(lambda_expr)), has_index(has_index) {};
+
+	//! Return type of the scalar function
+	LogicalType return_type;
+	//! Lambda expression that the expression executor executes
+	unique_ptr<Expression> lambda_expr;
+	//! True, if the last parameter in a lambda parameter list represents the index of the current list element
+	bool has_index;
+
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
+
+	//! Serializes a lambda function's bind data
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function);
+	//! Deserializes a lambda function's bind data
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &);
+};
+
+class LambdaFunctions {
+public:
+	//! Returns the parameter type for binary lambdas
+	static LogicalType BindBinaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type);
+	//! Returns the parameter type for ternary lambdas
+	static LogicalType BindTernaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type);
+
+	//! Checks for NULL list parameter and prepared statements and adds bound cast expression
+	static unique_ptr<FunctionData> ListLambdaPrepareBind(vector<unique_ptr<Expression>> &arguments,
+	                                                      ClientContext &context, ScalarFunction &bound_function);
+
+	//! Returns the ListLambdaBindData containing the lambda expression
+	static unique_ptr<FunctionData> ListLambdaBind(ClientContext &, ScalarFunction &bound_function,
+	                                               vector<unique_ptr<Expression>> &arguments,
+	                                               const bool has_index = false);
+
+	//! Internally executes list_transform
+	static void ListTransformFunction(DataChunk &args, ExpressionState &state, Vector &result);
+	//! Internally executes list_filter
+	static void ListFilterFunction(DataChunk &args, ExpressionState &state, Vector &result);
+	//! Internally executes list_reduce
+	static void ListReduceFunction(DataChunk &args, ExpressionState &state, Vector &result);
+
+public:
+	//! Lambda expressions can only be executed on one STANDARD_VECTOR_SIZE list child elements at a time, so for
+	//! list_transform and list_filter we need to prepare the input vectors for the lambda expression.  In list_reduce
+	//! the input size can never exceed row_count so it doesn't need ColumnInfo.
+	struct ColumnInfo {
+		explicit ColumnInfo(Vector &vector) : vector(vector), sel(SelectionVector(STANDARD_VECTOR_SIZE)) {};
+
+		//! The original vector taken from args
+		reference<Vector> vector;
+		//! The selection vector to slice the original vector
+		SelectionVector sel;
+		//! The unified vector format of the original vector
+		UnifiedVectorFormat format;
+	};
+
+	//! LambdaInfo sets up and stores the information needed by all lambda functions
+	struct LambdaInfo {
+		explicit LambdaInfo(DataChunk &args, ExpressionState &state, Vector &result, bool &result_is_null)
+		    : result(result), row_count(args.size()), is_all_constant(args.AllConstant()) {
+			Vector &list_column = args.data[0];
+
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+			result_validity = &FlatVector::Validity(result);
+
+			if (list_column.GetType().id() == LogicalTypeId::SQLNULL) {
+				result_validity->SetInvalid(0);
+				result_is_null = true;
+				return;
+			}
+
+			// get the lambda expression
+			auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+			auto &bind_info = func_expr.bind_info->Cast<ListLambdaBindData>();
+			lambda_expr = bind_info.lambda_expr;
+			is_volatile = lambda_expr->IsVolatile();
+			has_index = bind_info.has_index;
+
+			// get the list column entries
+			list_column.ToUnifiedFormat(row_count, list_column_format);
+			list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_column_format);
+
+			child_vector = &ListVector::GetEntry(list_column);
+
+			// get the lambda column data for all other input vectors
+			column_infos = LambdaFunctions::GetColumnInfo(args, row_count);
+		};
+
+		const list_entry_t *list_entries;
+		UnifiedVectorFormat list_column_format;
+		optional_ptr<Vector> child_vector;
+		Vector &result;
+		optional_ptr<ValidityMask> result_validity;
+		vector<ColumnInfo> column_infos;
+		optional_ptr<Expression> lambda_expr;
+
+		const idx_t row_count;
+		bool has_index;
+		bool is_volatile;
+		const bool is_all_constant;
+	};
+
+	static vector<ColumnInfo> GetColumnInfo(DataChunk &args, const idx_t row_count);
+	static vector<reference<ColumnInfo>> GetInconstantColumnInfo(vector<ColumnInfo> &data);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/scalar/array_functions.hpp

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/scalar/array_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct ArrayValueFun {
+	static constexpr const char *Name = "array_value";
+	static constexpr const char *Parameters = "any,...";
+	static constexpr const char *Description = "Create an ARRAY containing the argument values.";
+	static constexpr const char *Example = "array_value(4, 5, 6)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct ArrayCrossProductFun {
+	static constexpr const char *Name = "array_cross_product";
+	static constexpr const char *Parameters = "array, array";
+	static constexpr const char *Description = "Compute the cross product of two arrays of size 3. The array elements can not be NULL.";
+	static constexpr const char *Example = "array_cross_product([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayCosineSimilarityFun {
+	static constexpr const char *Name = "array_cosine_similarity";
+	static constexpr const char *Parameters = "array1,array2";
+	static constexpr const char *Description = "Compute the cosine similarity between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_cosine_similarity([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayDistanceFun {
+	static constexpr const char *Name = "array_distance";
+	static constexpr const char *Parameters = "array1,array2";
+	static constexpr const char *Description = "Compute the distance between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_distance([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayInnerProductFun {
+	static constexpr const char *Name = "array_inner_product";
+	static constexpr const char *Parameters = "array1,array2";
+	static constexpr const char *Description = "Compute the inner product between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_inner_product([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayDotProductFun {
+	using ALIAS = ArrayInnerProductFun;
+
+	static constexpr const char *Name = "array_dot_product";
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp

@@ -57,4 +57,13 @@ struct Base64Fun {
 	static constexpr const char *Name = "base64";
 };
 
+struct CreateSortKeyFun {
+	static constexpr const char *Name = "create_sort_key";
+	static constexpr const char *Parameters = "parameters...";
+	static constexpr const char *Description = "Constructs a binary-comparable sort key based on a set of input parameters and sort qualifiers";
+	static constexpr const char *Example = "create_sort_key('A', 'DESC')";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

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

@@ -435,6 +435,15 @@ struct TimezoneMinuteFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct ToCenturiesFun {
+	static constexpr const char *Name = "to_centuries";
+	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Description = "Construct a century interval";
+	static constexpr const char *Example = "to_centuries(5)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToDaysFun {
 	static constexpr const char *Name = "to_days";
 	static constexpr const char *Parameters = "integer";
@@ -444,6 +453,15 @@ struct ToDaysFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ToDecadesFun {
+	static constexpr const char *Name = "to_decades";
+	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Description = "Construct a decade interval";
+	static constexpr const char *Example = "to_decades(5)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToHoursFun {
 	static constexpr const char *Name = "to_hours";
 	static constexpr const char *Parameters = "integer";
@@ -462,11 +480,20 @@ struct ToMicrosecondsFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ToMillenniaFun {
+	static constexpr const char *Name = "to_millennia";
+	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Description = "Construct a millenium interval";
+	static constexpr const char *Example = "to_millennia(1)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToMillisecondsFun {
 	static constexpr const char *Name = "to_milliseconds";
-	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Parameters = "double";
 	static constexpr const char *Description = "Construct a millisecond interval";
-	static constexpr const char *Example = "to_milliseconds(5)";
+	static constexpr const char *Example = "to_milliseconds(5.5)";
 
 	static ScalarFunction GetFunction();
 };
@@ -491,9 +518,9 @@ struct ToMonthsFun {
 
 struct ToSecondsFun {
 	static constexpr const char *Name = "to_seconds";
-	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Parameters = "double";
 	static constexpr const char *Description = "Construct a second interval";
-	static constexpr const char *Example = "to_seconds(5)";
+	static constexpr const char *Example = "to_seconds(5.5)";
 
 	static ScalarFunction GetFunction();
 };
@@ -507,6 +534,15 @@ struct ToTimestampFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ToWeeksFun {
+	static constexpr const char *Name = "to_weeks";
+	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Description = "Construct a week interval";
+	static constexpr const char *Example = "to_weeks(5)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToYearsFun {
 	static constexpr const char *Name = "to_years";
 	static constexpr const char *Parameters = "integer";

package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp

@@ -132,6 +132,27 @@ struct ArraySortFun {
 	static constexpr const char *Name = "array_sort";
 };
 
+struct ListGradeUpFun {
+	static constexpr const char *Name = "list_grade_up";
+	static constexpr const char *Parameters = "list";
+	static constexpr const char *Description = "Returns the index of their sorted position.";
+	static constexpr const char *Example = "list_grade_up([3, 6, 1, 2])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayGradeUpFun {
+	using ALIAS = ListGradeUpFun;
+
+	static constexpr const char *Name = "array_grade_up";
+};
+
+struct GradeUpFun {
+	using ALIAS = ListGradeUpFun;
+
+	static constexpr const char *Name = "grade_up";
+};
+
 struct ListReverseSortFun {
 	static constexpr const char *Name = "list_reverse_sort";
 	static constexpr const char *Parameters = "list";
@@ -201,6 +222,27 @@ struct FilterFun {
 	static constexpr const char *Name = "filter";
 };
 
+struct ListReduceFun {
+	static constexpr const char *Name = "list_reduce";
+	static constexpr const char *Parameters = "list,lambda";
+	static constexpr const char *Description = "Returns a single value that is the result of applying the lambda function to each element of the input list, starting with the first element and then repeatedly applying the lambda function to the result of the previous application and the next element of the list.";
+	static constexpr const char *Example = "list_reduce([1, 2, 3], (x, y) -> x + y)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct ArrayReduceFun {
+	using ALIAS = ListReduceFun;
+
+	static constexpr const char *Name = "array_reduce";
+};
+
+struct ReduceFun {
+	using ALIAS = ListReduceFun;
+
+	static constexpr const char *Name = "reduce";
+};
+
 struct GenerateSeriesFun {
 	static constexpr const char *Name = "generate_series";
 	static constexpr const char *Parameters = "start,stop,step";

package/src/duckdb/src/include/duckdb/core_functions/scalar/secret_functions.hpp

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/scalar/secret_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct WhichSecretFun {
+	static constexpr const char *Name = "which_secret";
+	static constexpr const char *Parameters = "path,type";
+	static constexpr const char *Description = "Print out the name of the secret that will be used for reading a path";
+	static constexpr const char *Example = "which_secret('s3://some/authenticated/path.csv', 's3')";
+
+	static ScalarFunction GetFunction();
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -93,16 +93,25 @@ struct FormatFun {
 struct FormatBytesFun {
 	static constexpr const char *Name = "format_bytes";
 	static constexpr const char *Parameters = "bytes";
-	static constexpr const char *Description = "Converts bytes to a human-readable presentation (e.g. 16000 -> 16KB)";
+	static constexpr const char *Description = "Converts bytes to a human-readable presentation (e.g. 16000 -> 15.6 KiB)";
 	static constexpr const char *Example = "format_bytes(1000 * 16)";
 
 	static ScalarFunction GetFunction();
 };
 
-struct FormatreadabledecimalsizeFun {
+struct FormatreadablesizeFun {
 	using ALIAS = FormatBytesFun;
 
+	static constexpr const char *Name = "formatReadableSize";
+};
+
+struct FormatreadabledecimalsizeFun {
 	static constexpr const char *Name = "formatReadableDecimalSize";
+	static constexpr const char *Parameters = "bytes";
+	static constexpr const char *Description = "Converts bytes to a human-readable presentation (e.g. 16000 -> 16.0 KB)";
+	static constexpr const char *Example = "format_bytes(1000 * 16)";
+
+	static ScalarFunction GetFunction();
 };
 
 struct HammingFun {
@@ -270,6 +279,42 @@ struct MD5NumberUpperFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ParseDirnameFun {
+	static constexpr const char *Name = "parse_dirname";
+	static constexpr const char *Parameters = "string,separator";
+	static constexpr const char *Description = "Returns the top-level directory name. separator options: system, both_slash (default), forward_slash, backslash";
+	static constexpr const char *Example = "parse_dirname('path/to/file.csv', 'system')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ParseDirpathFun {
+	static constexpr const char *Name = "parse_dirpath";
+	static constexpr const char *Parameters = "string,separator";
+	static constexpr const char *Description = "Returns the head of the path similarly to Python's os.path.dirname. separator options: system, both_slash (default), forward_slash, backslash";
+	static constexpr const char *Example = "parse_dirpath('path/to/file.csv', 'system')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ParseFilenameFun {
+	static constexpr const char *Name = "parse_filename";
+	static constexpr const char *Parameters = "string,trim_extension,separator";
+	static constexpr const char *Description = "Returns the last component of the path similarly to Python's os.path.basename. If trim_extension is true, the file extension will be removed (it defaults to false). separator options: system, both_slash (default), forward_slash, backslash";
+	static constexpr const char *Example = "parse_filename('path/to/file.csv', true, 'forward_slash')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ParsePathFun {
+	static constexpr const char *Name = "parse_path";
+	static constexpr const char *Parameters = "string,separator";
+	static constexpr const char *Description = "Returns a list of the components (directories and filename) in the path similarly to Python's pathlib.PurePath::parts. separator options: system, both_slash (default), forward_slash, backslash";
+	static constexpr const char *Example = "parse_path('path/to/file.csv', 'system')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct PrintfFun {
 	static constexpr const char *Name = "printf";
 	static constexpr const char *Parameters = "format,parameters...";
@@ -471,4 +516,13 @@ struct ToBaseFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct RegexpEscapeFun {
+	static constexpr const char *Name = "regexp_escape";
+	static constexpr const char *Parameters = "string";
+	static constexpr const char *Description = "Escapes all potentially meaningful regexp characters in the input string";
+	static constexpr const char *Example = "regexp_escape('https://duckdb.org')";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/to_interval.hpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/to_interval.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/common/operator/multiply.hpp"
+
+namespace duckdb {
+
+struct ToSecondsOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		interval_t result;
+		result.months = 0;
+		result.days = 0;
+		if (!TryMultiplyOperator::Operation<TA, int64_t, int64_t>(input, Interval::MICROS_PER_SEC, result.micros)) {
+			throw OutOfRangeException("Interval value %s seconds out of range", NumericHelper::ToString(input));
+		}
+		return result;
+	}
+};
+
+} // namespace duckdb

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

@@ -89,7 +89,7 @@ public:
 
 public:
 	//! The hash table load factor, when a resize is triggered
-	constexpr static float LOAD_FACTOR = 1.5;
+	constexpr static double LOAD_FACTOR = 1.5;
 
 	//! Get the layout of this HT
 	const TupleDataLayout &GetLayout() const;
@@ -138,7 +138,7 @@ public:
 
 	//! Executes the filter(if any) and update the aggregates
 	void Combine(GroupedAggregateHashTable &other);
-	void Combine(TupleDataCollection &other_data);
+	void Combine(TupleDataCollection &other_data, optional_ptr<atomic<double>> progress = nullptr);
 
 	//! Unpins the data blocks
 	void UnpinData();

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

@@ -13,6 +13,7 @@
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/reference_map.hpp"
+#include "duckdb/execution/task_error_manager.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 
 namespace duckdb {
@@ -47,16 +48,16 @@ public:
 	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
 
 	void CancelTasks();
-	PendingExecutionResult ExecuteTask();
+	PendingExecutionResult ExecuteTask(bool dry_run = false);
 
 	void Reset();
 
 	vector<LogicalType> GetTypes();
 
-	unique_ptr<DataChunk> FetchChunk();
-
 	//! Push a new error
-	void PushError(PreservedError exception);
+	void PushError(ErrorData exception);
+
+	ErrorData GetError();
 
 	//! True if an error has been thrown
 	bool HasError();
@@ -77,7 +78,7 @@ public:
 	void AddToBeRescheduled(shared_ptr<Task> &task);
 
 	//! Returns the progress of the pipelines
-	bool GetPipelinesProgress(double &current_progress);
+	bool GetPipelinesProgress(double &current_progress, uint64_t &current_cardinality, uint64_t &total_cardinality);
 
 	void CompletePipeline() {
 		completed_pipelines++;
@@ -88,7 +89,6 @@ public:
 	void AddEvent(shared_ptr<Event> event);
 
 	void AddRecursiveCTE(PhysicalOperator &rec_cte);
-	void AddMaterializedCTE(PhysicalOperator &mat_cte);
 	void ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines, vector<shared_ptr<Event>> &events);
 
 	//! Whether or not the root of the pipeline is a result collector object
@@ -100,14 +100,15 @@ public:
 	bool ExecutionIsFinished();
 
 private:
+	bool ResultCollectorIsBlocked();
 	void InitializeInternal(PhysicalOperator &physical_plan);
 
 	void ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipelines);
 	static void ScheduleEventsInternal(ScheduleEventData &event_data);
 
 	static void VerifyScheduledEvents(const ScheduleEventData &event_data);
-	static void VerifyScheduledEventsInternal(const idx_t i, const vector<Event *> &vertices, vector<bool> &visited,
-	                                          vector<bool> &recursion_stack);
+	static void VerifyScheduledEventsInternal(const idx_t i, const vector<reference<Event>> &vertices,
+	                                          vector<bool> &visited, vector<bool> &recursion_stack);
 
 	static void SchedulePipeline(const shared_ptr<MetaPipeline> &pipeline, ScheduleEventData &event_data);
 
@@ -123,27 +124,24 @@ private:
 	unique_ptr<PhysicalOperator> owned_plan;
 
 	mutex executor_lock;
-	mutex error_lock;
 	//! All pipelines of the query plan
 	vector<shared_ptr<Pipeline>> pipelines;
 	//! The root pipelines of the query
 	vector<shared_ptr<Pipeline>> root_pipelines;
 	//! The recursive CTE's in this query plan
 	vector<reference<PhysicalOperator>> recursive_ctes;
-	//! The materialized CTE's in this query plan
-	vector<reference<PhysicalOperator>> materialized_ctes;
 	//! The pipeline executor for the root pipeline
 	unique_ptr<PipelineExecutor> root_executor;
 	//! The current root pipeline index
 	idx_t root_pipeline_idx;
 	//! The producer of this query
 	unique_ptr<ProducerToken> producer;
-	//! Exceptions that occurred during the execution of the current query
-	vector<PreservedError> exceptions;
 	//! List of events
 	vector<shared_ptr<Event>> events;
 	//! The query profiler
 	shared_ptr<QueryProfiler> profiler;
+	//! Task error manager
+	TaskErrorManager error_manager;
 
 	//! The amount of completed pipelines of the query
 	atomic<idx_t> completed_pipelines;