duckdb 0.7.2-dev2867.0 → 0.7.2-dev3117.0

package/src/duckdb/src/include/duckdb/common/enums/join_type.hpp

@@ -29,13 +29,13 @@ enum class JoinType : uint8_t {
 	             // (and NULL if no partner is found)
 };
 
-//! Convert join type to string
-DUCKDB_API string JoinTypeToString(JoinType type);
-
 //! True if join is left or full outer join
 bool IsLeftOuterJoin(JoinType type);
 
 //! True if join is rght or full outer join
 bool IsRightOuterJoin(JoinType type);
 
+// **DEPRECATED**: Use EnumUtil directly instead.
+string JoinTypeToString(JoinType type);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp

@@ -14,25 +14,37 @@ namespace duckdb {
 
 //! The OperatorResultType is used to indicate how data should flow around a regular (i.e. non-sink and non-source)
 //! physical operator
-//! There are three possible results:
+//! There are four possible results:
 //! NEED_MORE_INPUT means the operator is done with the current input and can consume more input if available
 //! If there is more input the operator will be called with more input, otherwise the operator will not be called again.
 //! HAVE_MORE_OUTPUT means the operator is not finished yet with the current input.
 //! The operator will be called again with the same input.
 //! FINISHED means the operator has finished the entire pipeline and no more processing is necessary.
 //! The operator will not be called again, and neither will any other operators in this pipeline.
-enum class OperatorResultType : uint8_t { NEED_MORE_INPUT, HAVE_MORE_OUTPUT, FINISHED };
+//! BLOCKED means the operator does not want to be called right now. e.g. because its currently doing async I/O. The
+//! operator has set the interrupt state and the caller is expected to handle it. Note that intermediate operators
+//! should currently not emit this state.
+enum class OperatorResultType : uint8_t { NEED_MORE_INPUT, HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
 
 //! OperatorFinalizeResultType is used to indicate whether operators have finished flushing their cached results.
 //! FINISHED means the operator has flushed all cached data.
 //! HAVE_MORE_OUTPUT means the operator contains more results.
 enum class OperatorFinalizeResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED };
 
+//! SourceResultType is used to indicate the result of data being pulled out of a source.
+//! There are three possible results:
+//! HAVE_MORE_OUTPUT means the source has more output, this flag should only be set when data is returned, empty results
+//! should only occur for the FINISHED and BLOCKED flags
+//! FINISHED means the source is exhausted
+//! BLOCKED means the source is currently blocked, e.g. by some async I/O
+enum class SourceResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
+
 //! The SinkResultType is used to indicate the result of data flowing into a sink
-//! There are two possible results:
+//! There are three possible results:
 //! NEED_MORE_INPUT means the sink needs more input
 //! FINISHED means the sink is finished executing, and more input will not change the result any further
-enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED };
+//! BLOCKED means the sink is currently blocked, e.g. by some async I/O.
+enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED, BLOCKED };
 
 //! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
 //! There are two possible results:

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -30,6 +30,7 @@ enum class PhysicalOperatorType : uint8_t {
 	FILTER,
 	PROJECTION,
 	COPY_TO_FILE,
+	BATCH_COPY_TO_FILE,
 	RESERVOIR_SAMPLE,
 	STREAMING_SAMPLE,
 	STREAMING_WINDOW,

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -10,11 +10,11 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/exception_format_value.hpp"
-#include "duckdb/common/vector.hpp"
 #include "duckdb/common/shared_ptr.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/typedefs.hpp"
 
+#include <vector>
 #include <stdexcept>
 
 namespace duckdb {
@@ -105,14 +105,14 @@ public:
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
-		vector<ExceptionFormatValue> values;
+		std::vector<ExceptionFormatValue> values;
 		return ConstructMessageRecursive(msg, values, params...);
 	}
 
-	DUCKDB_API static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values);
+	DUCKDB_API static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values);
 
 	template <class T, typename... Args>
-	static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param,
+	static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values, T param,
 	                                        Args... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
 		return ConstructMessageRecursive(msg, values, params...);

package/src/duckdb/src/include/duckdb/common/exception_format_value.hpp

@@ -10,7 +10,8 @@
 
 #include "duckdb/common/string.hpp"
 #include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/vector.hpp"
+
+#include <vector>
 
 namespace duckdb {
 
@@ -40,7 +41,7 @@ public:
 	static ExceptionFormatValue CreateFormatValue(T value) {
 		return int64_t(value);
 	}
-	static string Format(const string &msg, vector<ExceptionFormatValue> &values);
+	static string Format(const string &msg, std::vector<ExceptionFormatValue> &values);
 };
 
 template <>

package/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/hive_partitioning.hpp"
+#include "re2/re2.h"
 
 namespace duckdb {
 class Serializer;
@@ -18,11 +20,53 @@ struct BindInfo;
 struct MultiFileReaderOptions {
 	bool filename = false;
 	bool hive_partitioning = false;
+	bool auto_detect_hive_partitioning = true;
 	bool union_by_name = false;
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
+
+	static bool AutoDetectHivePartitioning(const vector<string> &files) {
+		if (files.empty()) {
+			return false;
+		}
+
+		std::unordered_set<string> uset;
+		idx_t splits_size;
+		{
+			//	front file
+			auto splits = StringUtil::Split(files.front(), FileSystem::PathSeparator());
+			splits_size = splits.size();
+			if (splits.size() < 2) {
+				return false;
+			}
+			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
+				auto part = StringUtil::Split(*it, "=");
+				if (part.size() == 2) {
+					uset.insert(part.front());
+				}
+			}
+		}
+		if (uset.empty()) {
+			return false;
+		}
+		for (auto &file : files) {
+			auto splits = StringUtil::Split(file, FileSystem::PathSeparator());
+			if (splits.size() != splits_size) {
+				return false;
+			}
+			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
+				auto part = StringUtil::Split(*it, "=");
+				if (part.size() == 2) {
+					if (uset.find(part.front()) == uset.end()) {
+						return false;
+					}
+				}
+			}
+		}
+		return true;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/optional_idx.hpp

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/optional_idx.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+
+class optional_idx {
+	static constexpr const idx_t INVALID_INDEX = idx_t(-1);
+
+public:
+	optional_idx() : index(INVALID_INDEX) {
+	}
+	optional_idx(idx_t index) : index(index) { // NOLINT: allow implicit conversion from idx_t
+		if (index == INVALID_INDEX) {
+			throw InternalException("optional_idx cannot be initialized with an invalid index");
+		}
+	}
+
+	static optional_idx Invalid() {
+		return INVALID_INDEX;
+	}
+
+	bool IsValid() const {
+		return index != DConstants::INVALID_INDEX;
+	}
+	idx_t GetIndex() {
+		if (index == INVALID_INDEX) {
+			throw InternalException("Attempting to get the index of an optional_idx that is not set");
+		}
+		return index;
+	}
+
+private:
+	idx_t index;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -0,0 +1,93 @@
+#pragma once
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
+namespace duckdb {
+
+class BinaryDeserializer : public FormatDeserializer {
+public:
+	template <class T>
+	static unique_ptr<T> Deserialize(data_ptr_t ptr, idx_t length) {
+		BinaryDeserializer deserializer(ptr, length);
+		deserializer.OnObjectBegin();
+		auto result = T::FormatDeserialize(deserializer);
+		deserializer.OnObjectEnd();
+		return result;
+	}
+
+private:
+	explicit BinaryDeserializer(data_ptr_t ptr, idx_t length) : ptr(ptr), end_ptr(ptr + length) {
+		deserialize_enum_from_string = false;
+	}
+	struct State {
+		uint32_t expected_field_count;
+		idx_t expected_size;
+		uint32_t read_field_count;
+		State(uint32_t expected_field_count, idx_t expected_size)
+		    : expected_field_count(expected_field_count), expected_size(expected_size), read_field_count(0) {
+		}
+	};
+
+	const char *current_tag = nullptr;
+	data_ptr_t ptr;
+	data_ptr_t end_ptr;
+	vector<State> stack;
+
+	template <class T>
+	T ReadPrimitive() {
+		T value;
+		ReadData((data_ptr_t)&value, sizeof(T));
+		return value;
+	}
+
+	void ReadData(data_ptr_t buffer, idx_t read_size) {
+		if (ptr + read_size > end_ptr) {
+			throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
+		}
+		memcpy(buffer, ptr, read_size);
+		ptr += read_size;
+	}
+
+	// Set the 'tag' of the property to read
+	void SetTag(const char *tag) final;
+
+	//===--------------------------------------------------------------------===//
+	// Nested Types Hooks
+	//===--------------------------------------------------------------------===//
+	void OnObjectBegin() final;
+	void OnObjectEnd() final;
+	idx_t OnListBegin() final;
+	void OnListEnd() final;
+	idx_t OnMapBegin() final;
+	void OnMapEnd() final;
+	void OnMapEntryBegin() final;
+	void OnMapEntryEnd() final;
+	void OnMapKeyBegin() final;
+	void OnMapValueBegin() final;
+	bool OnOptionalBegin() final;
+
+	void OnPairBegin() final;
+	void OnPairKeyBegin() final;
+	void OnPairValueBegin() final;
+	void OnPairEnd() final;
+
+	//===--------------------------------------------------------------------===//
+	// Primitive Types
+	//===--------------------------------------------------------------------===//
+	bool ReadBool() final;
+	int8_t ReadSignedInt8() final;
+	uint8_t ReadUnsignedInt8() final;
+	int16_t ReadSignedInt16() final;
+	uint16_t ReadUnsignedInt16() final;
+	int32_t ReadSignedInt32() final;
+	uint32_t ReadUnsignedInt32() final;
+	int64_t ReadSignedInt64() final;
+	uint64_t ReadUnsignedInt64() final;
+	float ReadFloat() final;
+	double ReadDouble() final;
+	string ReadString() final;
+	interval_t ReadInterval() final;
+	hugeint_t ReadHugeInt() final;
+	void ReadDataPtr(data_ptr_t &ptr, idx_t count) final;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+
+namespace duckdb {
+
+struct BinarySerializer : public FormatSerializer {
+
+private:
+	struct State {
+		// how many fields are present in the object
+		uint32_t field_count;
+		// the size of the object
+		uint64_t size;
+		// the offset of the object start in the buffer
+		uint64_t offset;
+	};
+
+	const char *current_tag;
+
+	vector<data_t> data;
+	vector<State> stack;
+
+	template <class T>
+	void Write(T element) {
+		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
+		WriteData((const_data_ptr_t)&element, sizeof(T));
+	}
+	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
+		data.insert(data.end(), buffer, buffer + write_size);
+		stack.back().size += write_size;
+	}
+
+	explicit BinarySerializer() {
+		serialize_enum_as_string = false;
+	}
+
+public:
+	template <class T>
+	static vector<data_t> Serialize(T &obj) {
+		BinarySerializer serializer;
+		serializer.OnObjectBegin();
+		obj.FormatSerialize(serializer);
+		serializer.OnObjectEnd();
+		return std::move(serializer.data);
+	}
+
+	void SetTag(const char *tag) final;
+
+	//===--------------------------------------------------------------------===//
+	// Nested Types Hooks
+	//===--------------------------------------------------------------------===//
+	void OnOptionalBegin(bool present) final;
+	void OnListBegin(idx_t count) final;
+	void OnListEnd(idx_t count) final;
+	void OnMapBegin(idx_t count) final;
+	void OnMapEntryBegin() final;
+	void OnMapEntryEnd() final;
+	void OnMapKeyBegin() final;
+	void OnMapValueBegin() final;
+	void OnMapEnd(idx_t count) final;
+	void OnObjectBegin() final;
+	void OnObjectEnd() final;
+	void OnPairBegin() final;
+	void OnPairKeyBegin() final;
+	void OnPairValueBegin() final;
+	void OnPairEnd() final;
+
+	//===--------------------------------------------------------------------===//
+	// Primitive Types
+	//===--------------------------------------------------------------------===//
+	void WriteNull() final;
+	void WriteValue(uint8_t value) final;
+	void WriteValue(int8_t value) final;
+	void WriteValue(uint16_t value) final;
+	void WriteValue(int16_t value) final;
+	void WriteValue(uint32_t value) final;
+	void WriteValue(int32_t value) final;
+	void WriteValue(uint64_t value) final;
+	void WriteValue(int64_t value) final;
+	void WriteValue(hugeint_t value) final;
+	void WriteValue(float value) final;
+	void WriteValue(double value) final;
+	void WriteValue(interval_t value) final;
+	void WriteValue(const string_t value) final;
+	void WriteValue(const string &value) final;
+	void WriteValue(const char *value) final;
+	void WriteValue(bool value) final;
+	void WriteDataPtr(const_data_ptr_t ptr, idx_t count) final;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -294,8 +294,12 @@ private:
 	// Deserialize a Enum
 	template <typename T = void>
 	inline typename std::enable_if<std::is_enum<T>::value, T>::type Read() {
-		auto str = ReadString();
-		return EnumSerializer::StringToEnum<T>(str.c_str());
+		if (deserialize_enum_from_string) {
+			auto str = ReadString();
+			return EnumUtil::FromString<T>(str.c_str());
+		} else {
+			return (T)Read<typename std::underlying_type<T>::type>();
+		}
 	}
 
 	// Deserialize a interval_t

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -39,7 +39,7 @@ public:
 		SetTag(tag);
 		if (serialize_enum_as_string) {
 			// Use the enum serializer to lookup tostring function
-			auto str = EnumSerializer::EnumToString(value);
+			auto str = EnumUtil::ToChars(value);
 			WriteValue(str);
 		} else {
 			// Use the underlying type

package/src/duckdb/src/include/duckdb/common/set.hpp

@@ -11,5 +11,6 @@
 #include <set>
 
 namespace duckdb {
+using std::multiset;
 using std::set;
-}
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -229,7 +229,7 @@ private:
 	//! The number of entries stored in the TupleDataCollection
 	idx_t count;
 	//! The data segments of the TupleDataCollection
-	vector<TupleDataSegment> segments;
+	unsafe_vector<TupleDataSegment> segments;
 	//! The set of scatter functions
 	vector<TupleDataScatterFunction> scatter_functions;
 	//! The set of gather functions

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp

@@ -109,7 +109,7 @@ public:
 	//! The allocator for this segment
 	shared_ptr<TupleDataAllocator> allocator;
 	//! The chunks of this segment
-	vector<TupleDataChunk> chunks;
+	unsafe_vector<TupleDataChunk> chunks;
 	//! The tuple count of this segment
 	idx_t count;
 

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -457,6 +457,7 @@ struct AggregateStateType {
 	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
 };
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
 
 DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str);

package/src/duckdb/src/include/duckdb/common/vector.hpp

@@ -10,22 +10,31 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/likely.hpp"
+#include "duckdb/common/exception.hpp"
 #include <vector>
 
 namespace duckdb {
 
-// TODO: inline this, needs changes to 'exception.hpp' and other headers to avoid circular dependency
-void AssertIndexInBounds(idx_t index, idx_t size);
-
-template <class _Tp, class _Allocator = std::allocator<_Tp>>
-class vector : public std::vector<_Tp, _Allocator> {
+template <class _Tp, bool SAFE = true>
+class vector : public std::vector<_Tp, std::allocator<_Tp>> {
 public:
-	using original = std::vector<_Tp, _Allocator>;
+	using original = std::vector<_Tp, std::allocator<_Tp>>;
 	using original::original;
 	using size_type = typename original::size_type;
 	using const_reference = typename original::const_reference;
 	using reference = typename original::reference;
 
+	static inline void AssertIndexInBounds(idx_t index, idx_t size) {
+#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
+		return;
+#else
+		if (DUCKDB_UNLIKELY(index >= size)) {
+			throw InternalException("Attempted to access index %ld within vector of size %ld", index, size);
+		}
+#endif
+	}
+
 #ifdef DUCKDB_CLANG_TIDY
 	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
 	[[clang::reinitializes]]
@@ -40,19 +49,57 @@ public:
 	vector() = default;
 	vector(original &&other) : original(std::move(other)) {
 	}
+	template <bool _SAFE>
+	vector(vector<_Tp, _SAFE> &&other) : original(std::move(other)) {
+	}
 
-	typename original::reference operator[](typename original::size_type __n) {
-#ifdef DEBUG
-		AssertIndexInBounds(__n, original::size());
-#endif
+	template <bool _SAFE = false>
+	inline typename original::reference get(typename original::size_type __n) {
+		if (_SAFE) {
+			AssertIndexInBounds(__n, original::size());
+		}
 		return original::operator[](__n);
 	}
-	typename original::const_reference operator[](typename original::size_type __n) const {
-#ifdef DEBUG
-		AssertIndexInBounds(__n, original::size());
-#endif
+
+	template <bool _SAFE = false>
+	inline typename original::const_reference get(typename original::size_type __n) const {
+		if (_SAFE) {
+			AssertIndexInBounds(__n, original::size());
+		}
 		return original::operator[](__n);
 	}
+
+	typename original::reference operator[](typename original::size_type __n) {
+		return get<SAFE>(__n);
+	}
+	typename original::const_reference operator[](typename original::size_type __n) const {
+		return get<SAFE>(__n);
+	}
+
+	typename original::reference front() {
+		return get<SAFE>(0);
+	}
+
+	typename original::const_reference front() const {
+		return get<SAFE>(0);
+	}
+
+	typename original::reference back() {
+		if (original::empty()) {
+			throw InternalException("'back' called on an empty vector!");
+		}
+		return get<SAFE>(original::size() - 1);
+	}
+
+	typename original::const_reference back() const {
+		if (original::empty()) {
+			throw InternalException("'back' called on an empty vector!");
+		}
+		return get<SAFE>(original::size() - 1);
+	}
 };
 
+template <typename T>
+using unsafe_vector = vector<T, false>;
+
 } // namespace duckdb

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

@@ -88,6 +88,21 @@ struct FormatFun {
 	static ScalarFunction GetFunction();
 };
 
+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 *Example = "format_bytes(1000 * 16)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct FormatreadabledecimalsizeFun {
+	using ALIAS = FormatBytesFun;
+
+	static constexpr const char *Name = "formatReadableDecimalSize";
+};
+
 struct HammingFun {
 	static constexpr const char *Name = "hamming";
 	static constexpr const char *Parameters = "str1,str2";

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

@@ -102,9 +102,10 @@ public:
 	//! Add the given data to the HT, computing the aggregates grouped by the
 	//! data in the group chunk. When resize = true, aggregates will not be
 	//! computed but instead just assigned.
-	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload, const vector<idx_t> &filter);
+	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload,
+	               const unsafe_vector<idx_t> &filter);
 	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes, DataChunk &payload,
-	               const vector<idx_t> &filter);
+	               const unsafe_vector<idx_t> &filter);
 	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload, AggregateType filter);
 
 	//! Scan the HT starting from the scan_position until the result and group

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

@@ -70,6 +70,12 @@ public:
 	//! Flush a thread context into the client context
 	void Flush(ThreadContext &context);
 
+	//! Reschedules a task that was blocked
+	void RescheduleTask(shared_ptr<Task> &task);
+
+	//! Add the task to be rescheduled
+	void AddToBeRescheduled(shared_ptr<Task> &task);
+
 	//! Returns the progress of the pipelines
 	bool GetPipelinesProgress(double &current_progress);
 
@@ -146,6 +152,9 @@ private:
 	//! The last pending execution result (if any)
 	PendingExecutionResult execution_result;
 	//! The current task in process (if any)
-	unique_ptr<Task> task;
+	shared_ptr<Task> task;
+
+	//! Task that have been descheduled
+	unordered_map<Task *, shared_ptr<Task>> to_be_rescheduled_tasks;
 };
 } // namespace duckdb