duckdb 0.3.2-dev633.0 → 0.3.2-dev665.0

package/src/duckdb.cpp

@@ -7200,7 +7200,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
 		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.is_open) {
+		if (!stream_result.IsOpen()) {
 			my_stream->last_error = "Query Stream is closed";
 			return -1;
 		}
@@ -7221,7 +7221,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
 		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.is_open) {
+		if (!stream_result.IsOpen()) {
 			my_stream->last_error = "Query Stream is closed";
 			return -1;
 		}
@@ -24080,51 +24080,43 @@ bool Printer::IsTerminal() {
 
 namespace duckdb {
 
-void ProgressBar::ProgressBarThread() {
-#ifndef DUCKDB_NO_THREADS
-	WaitFor(std::chrono::milliseconds(show_progress_after));
-	while (!stop) {
-		int new_percentage;
-		supported = executor->GetPipelinesProgress(new_percentage);
-		current_percentage = new_percentage;
-		if (supported && current_percentage > -1 && ClientConfig::GetConfig(executor->context).print_progress_bar) {
-			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
-		}
-		WaitFor(std::chrono::milliseconds(time_update_bar));
-	}
-#endif
+ProgressBar::ProgressBar(Executor &executor, idx_t show_progress_after)
+    : executor(executor), show_progress_after(show_progress_after), current_percentage(-1) {
 }
 
-int ProgressBar::GetCurrentPercentage() {
+double ProgressBar::GetCurrentPercentage() {
 	return current_percentage;
 }
 
 void ProgressBar::Start() {
-#ifndef DUCKDB_NO_THREADS
-	Stop(false);
-	stop = false;
+	profiler.Start();
 	current_percentage = 0;
-	progress_bar_thread = thread(&ProgressBar::ProgressBarThread, this);
-#endif
-}
-
-ProgressBar::~ProgressBar() {
-	Stop();
+	supported = true;
 }
 
-void ProgressBar::Stop(bool success) {
-#ifndef DUCKDB_NO_THREADS
-	if (progress_bar_thread.joinable()) {
-		stop = true;
-		c.notify_one();
-		progress_bar_thread.join();
-		if (success && supported && current_percentage > 0 &&
-		    ClientConfig::GetConfig(executor->context).print_progress_bar) {
+void ProgressBar::Update(bool final) {
+	if (!supported) {
+		return;
+	}
+	double new_percentage;
+	supported = executor.GetPipelinesProgress(new_percentage);
+	if (!supported) {
+		return;
+	}
+	auto sufficient_time_elapsed = profiler.Elapsed() > show_progress_after / 1000.0;
+	auto print_progress = ClientConfig::GetConfig(executor.context).print_progress_bar;
+	if (new_percentage > current_percentage) {
+		current_percentage = new_percentage;
+	}
+	if (supported && print_progress && sufficient_time_elapsed && current_percentage > -1 && print_progress) {
+		if (final) {
 			Printer::FinishProgressBarPrint(PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
+		} else {
+			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
 		}
 	}
-#endif
 }
+
 } // namespace duckdb
 
 
@@ -24923,8 +24915,8 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
-	data_ptr_t data_locations[STANDARD_VECTOR_SIZE];
-	data_ptr_t mask_locations[STANDARD_VECTOR_SIZE];
+	auto data_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
+	auto mask_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
 		mask_locations[i] = ptrs[row_idx];
@@ -24932,7 +24924,7 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	}
 
 	// Deserialise into the selected locations
-	RowOperations::HeapGather(col, count, col_sel, col_no, data_locations, mask_locations);
+	RowOperations::HeapGather(col, count, col_sel, col_no, data_locations.get(), mask_locations.get());
 }
 
 void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
@@ -30394,54 +30386,6 @@ string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const s
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The profiler can be used to measure elapsed time
-template <typename T>
-class Profiler {
-public:
-	//! Starts the timer
-	void Start() {
-		finished = false;
-		start = Tick();
-	}
-	//! Finishes timing
-	void End() {
-		end = Tick();
-		finished = true;
-	}
-
-	//! Returns the elapsed time in seconds. If End() has been called, returns
-	//! the total elapsed time. Otherwise returns how far along the timer is
-	//! right now.
-	double Elapsed() const {
-		auto _end = finished ? end : Tick();
-		return std::chrono::duration_cast<std::chrono::duration<double>>(_end - start).count();
-	}
-
-private:
-	time_point<T> Tick() const {
-		return T::now();
-	}
-	time_point<T> start;
-	time_point<T> end;
-	bool finished = false;
-};
-
-} // namespace duckdb
 
 
 
@@ -30454,6 +30398,7 @@ private:
 
 
 namespace duckdb {
+class ClientContext;
 class ExpressionExecutor;
 class PhysicalOperator;
 class SQLStatement;
@@ -30545,7 +30490,7 @@ private:
 	//! Whether or not the profiler is enabled
 	bool enabled;
 	//! The timer used to time the execution time of the individual Physical Operators
-	Profiler<system_clock> op;
+	Profiler op;
 	//! The stack of Physical Operators that are currently active
 	const PhysicalOperator *active_operator;
 	//! A mapping of physical operators to recorded timings
@@ -30555,17 +30500,7 @@ private:
 //! The QueryProfiler can be used to measure timings of queries
 class QueryProfiler {
 public:
-	DUCKDB_API QueryProfiler()
-	    : automatic_print_format(ProfilerPrintFormat::NONE), enabled(false), detailed_enabled(false), running(false),
-	      query_requires_profiling(false), is_explain_analyze(false), stored_enabled(false),
-	      stored_automatic_print_format(ProfilerPrintFormat::NONE) {
-	}
-
-	//! The format to automatically print query profiling information in (default: disabled)
-	ProfilerPrintFormat automatic_print_format;
-	//! The file to save query profiling information to, instead of printing it to the console (empty = print to
-	//! console)
-	string save_location;
+	DUCKDB_API QueryProfiler(ClientContext &context);
 
 public:
 	struct TreeNode {
@@ -30589,26 +30524,12 @@ private:
 	mutex flush_lock;
 
 public:
-	DUCKDB_API void Enable() {
-		enabled = true;
-		detailed_enabled = false;
-	}
+	DUCKDB_API bool IsEnabled() const;
+	DUCKDB_API bool IsDetailedEnabled() const;
+	DUCKDB_API ProfilerPrintFormat GetPrintFormat() const;
+	DUCKDB_API string GetSaveLocation() const;
 
-	DUCKDB_API void DetailedEnable() {
-		detailed_enabled = true;
-	}
-
-	DUCKDB_API void Disable() {
-		enabled = false;
-	}
-
-	DUCKDB_API bool IsEnabled() {
-		return enabled;
-	}
-
-	bool IsDetailedEnabled() const {
-		return detailed_enabled;
-	}
+	DUCKDB_API static QueryProfiler &Get(ClientContext &context);
 
 	DUCKDB_API void StartQuery(string query, bool is_explain_analyze = false);
 	DUCKDB_API void EndQuery();
@@ -30637,13 +30558,12 @@ public:
 	void Finalize(TreeNode &node);
 
 private:
-	//! Whether or not query profiling is enabled
-	bool enabled;
-	//! Whether or not detailed query profiling is enabled
-	bool detailed_enabled;
+	ClientContext &context;
+
 	//! Whether or not the query profiler is running
 	bool running;
 
+	//! Whether or not the query requires profiling
 	bool query_requires_profiling;
 
 	//! The root of the query tree
@@ -30651,14 +30571,11 @@ private:
 	//! The query string
 	string query;
 	//! The timer used to time the execution time of the entire query
-	Profiler<system_clock> main_query;
+	Profiler main_query;
 	//! A map of a Physical Operator pointer to a tree node
 	TreeMap tree_map;
 
 	bool is_explain_analyze;
-	bool stored_enabled;
-	ProfilerPrintFormat stored_automatic_print_format;
-	string stored_save_location;
 
 public:
 	const TreeMap &GetTreeMap() const {
@@ -30667,7 +30584,7 @@ public:
 
 private:
 	//! The timer used to time the individual phases of the planning process
-	Profiler<system_clock> phase_profiler;
+	Profiler phase_profiler;
 	//! A mapping of the phase names to the timings
 	using PhaseTimingStorage = unordered_map<string, double>;
 	PhaseTimingStorage phase_timings;
@@ -37730,6 +37647,19 @@ T Value::GetValueInternal() const {
 		return Cast::Operation<interval_t, T>(value_.interval);
 	case LogicalTypeId::DECIMAL:
 		return CastAs(LogicalType::DOUBLE).GetValueInternal<T>();
+	case LogicalTypeId::ENUM: {
+		switch (type_.InternalType()) {
+		case PhysicalType::UINT8:
+			return Cast::Operation<uint8_t, T>(value_.utinyint);
+		case PhysicalType::UINT16:
+			return Cast::Operation<uint16_t, T>(value_.usmallint);
+		case PhysicalType::UINT32:
+			return Cast::Operation<uint32_t, T>(value_.uinteger);
+		default:
+			throw InternalException("Invalid Internal Type for ENUMs");
+		}
+	}
+
 	default:
 		throw NotImplementedException("Unimplemented type \"%s\" for GetValue()", type_.ToString());
 	}
@@ -41627,12 +41557,15 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	const auto &left_type = left.type();
 	const auto &right_type = right.type();
 	if (left_type != right_type) {
-		try {
-			LogicalType comparison_type = BoundComparisonExpression::BindComparison(left_type, right_type);
-			return TemplatedBooleanOperation<OP>(left.CastAs(comparison_type), right.CastAs(comparison_type));
-		} catch (...) {
+		Value left_copy = left;
+		Value right_copy = right;
+
+		LogicalType comparison_type = BoundComparisonExpression::BindComparison(left_type, right_type);
+		if (!left_copy.TryCastAs(comparison_type) || !right_copy.TryCastAs(comparison_type)) {
 			return false;
 		}
+		D_ASSERT(left_copy.type() == right_copy.type());
+		return TemplatedBooleanOperation<OP>(left_copy, right_copy);
 	}
 	switch (left_type.InternalType()) {
 	case PhysicalType::BOOL:
@@ -52680,8 +52613,9 @@ void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState
 		aggregate.function.combine(source_state, dest_state, 1);
 	}
 
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &source.child_executor, "child_executor", 0);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 SinkFinalizeType PhysicalSimpleAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -54486,7 +54420,8 @@ SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSin
 SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
 	auto &gstate = (ExplainAnalyzeStateGlobalState &)gstate_p;
-	gstate.analyzed_plan = context.profiler->ToString();
+	auto &profiler = QueryProfiler::Get(context);
+	gstate.analyzed_plan = profiler.ToString();
 	return SinkFinalizeType::READY;
 }
 
@@ -57267,8 +57202,9 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, GlobalSinkState
 
 void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (HashJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.build_executor, "build_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -58032,8 +57968,10 @@ SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, GlobalSin
 
 void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (NestedLoopJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
+
 	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 SinkFinalizeType PhysicalNestedLoopJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -58465,8 +58403,10 @@ SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, Globa
 void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate,
                                          LocalSinkState &lstate) const {
 	auto &state = (MergeJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
+
 	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -59051,12 +58991,13 @@ public:
 	    : ExecutorTask(context), event(move(event_p)), context(context), state(state) {
 	}
 
-	void ExecuteTask() override {
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
 		// Initialize merge sorted and iterate until done
 		auto &global_sort_state = state.global_sort_state;
 		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
 		merge_sorter.PerformInMergeRound();
 		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 
 private:
@@ -62392,8 +62333,9 @@ unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &c
 
 void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (InsertLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -62599,8 +62541,9 @@ unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &c
 
 void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (UpdateLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -65567,6 +65510,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalChunkGet &
 
 
 
+
 namespace duckdb {
 
 static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_data, PhysicalTableScan &scan) {
@@ -65586,6 +65530,30 @@ static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_d
 	return true;
 }
 
+bool ExtractNumericValue(Value val, int64_t &result) {
+	if (!val.type().IsIntegral()) {
+		switch (val.type().InternalType()) {
+		case PhysicalType::INT16:
+			result = val.GetValueUnsafe<int16_t>();
+			break;
+		case PhysicalType::INT32:
+			result = val.GetValueUnsafe<int32_t>();
+			break;
+		case PhysicalType::INT64:
+			result = val.GetValueUnsafe<int64_t>();
+			break;
+		default:
+			return false;
+		}
+	} else {
+		if (!val.TryCastAs(LogicalType::BIGINT)) {
+			return false;
+		}
+		result = val.GetValue<int64_t>();
+	}
+	return true;
+}
+
 void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &join_state) {
 	// we only do this optimization for inner joins
 	if (op.join_type != JoinType::INNER) {
@@ -65618,7 +65586,14 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	if (stats_build->min.is_null || stats_build->max.is_null) {
 		return;
 	}
-	auto build_range = stats_build->max - stats_build->min; // Join Keys Range
+	int64_t min_value, max_value;
+	if (!ExtractNumericValue(stats_build->min, min_value) || !ExtractNumericValue(stats_build->max, max_value)) {
+		return;
+	}
+	int64_t build_range;
+	if (!TrySubtractOperator::Operation(max_value, min_value, build_range)) {
+		return;
+	}
 
 	// Fill join_stats for invisible join
 	auto stats_probe = reinterpret_cast<NumericStatistics *>(op.join_stats[1].get()); // rhs stats
@@ -65630,26 +65605,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	join_state.build_min = stats_build->min;
 	join_state.build_max = stats_build->max;
 	join_state.estimated_cardinality = op.estimated_cardinality;
-	if (!build_range.type().IsIntegral()) {
-		switch (build_range.type().InternalType()) {
-		case PhysicalType::INT16:
-			join_state.build_range = build_range.value_.smallint;
-			break;
-		case PhysicalType::INT32:
-			join_state.build_range = build_range.value_.integer;
-			break;
-		case PhysicalType::INT64:
-			join_state.build_range = build_range.value_.bigint;
-			break;
-		case PhysicalType::INT128:
-			// we do not support hugeint for this optimization
-			return;
-		default:
-			throw InternalException("Invalid Physical Type for Decimals");
-		}
-	} else {
-		join_state.build_range = build_range.GetValue<idx_t>(); // cast integer types into idx_t
-	}
+	join_state.build_range = build_range;
 	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.is_null || stats_probe->min.is_null) {
 		return;
 	}
@@ -68596,25 +68552,27 @@ private:
 };
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(unique_ptr<LogicalOperator> op) {
+	auto &profiler = QueryProfiler::Get(context);
+
 	// first resolve column references
-	context.profiler->StartPhase("column_binding");
+	profiler.StartPhase("column_binding");
 	ColumnBindingResolver resolver;
 	resolver.VisitOperator(*op);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	// now resolve types of all the operators
-	context.profiler->StartPhase("resolve_types");
+	profiler.StartPhase("resolve_types");
 	op->ResolveOperatorTypes();
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	// extract dependencies from the logical plan
 	DependencyExtractor extractor(dependencies);
 	extractor.VisitOperator(*op);
 
 	// then create the main physical plan
-	context.profiler->StartPhase("create_plan");
+	profiler.StartPhase("create_plan");
 	auto plan = CreatePlan(*op);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 	return plan;
 }
 
@@ -68976,6 +68934,7 @@ public:
 	                           idx_t radix_p)
 	    : ExecutorTask(executor), event(move(event_p)), state(state_p), radix(radix_p) {
 	}
+
 	static void FinalizeHT(RadixHTGlobalState &gstate, idx_t radix) {
 		D_ASSERT(gstate.partition_info.n_partitions <= gstate.finalized_hts.size());
 		D_ASSERT(gstate.finalized_hts[radix]);
@@ -68988,9 +68947,10 @@ public:
 		gstate.finalized_hts[radix]->Finalize();
 	}
 
-	void ExecuteTask() override {
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
 		FinalizeHT(state, radix);
 		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 
 private:
@@ -77592,6 +77552,7 @@ void BuiltinFunctions::Initialize() {
 	RegisterRegressiveAggregates();
 
 	RegisterDateFunctions();
+	RegisterEnumFunctions();
 	RegisterGenericFunctions();
 	RegisterMathFunctions();
 	RegisterOperators();
@@ -78092,8 +78053,9 @@ struct PragmaFunctions {
 namespace duckdb {
 
 static void PragmaEnableProfilingStatement(ClientContext &context, const FunctionParameters &parameters) {
-	context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE;
-	context.profiler->Enable();
+	auto &config = ClientConfig::GetConfig(context);
+	config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
+	config.enable_profiler = true;
 }
 
 void RegisterEnableProfiling(BuiltinFunctions &set) {
@@ -78105,8 +78067,9 @@ void RegisterEnableProfiling(BuiltinFunctions &set) {
 }
 
 static void PragmaDisableProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	context.profiler->Disable();
-	context.profiler->automatic_print_format = ProfilerPrintFormat::NONE;
+	auto &config = ClientConfig::GetConfig(context);
+	config.enable_profiler = false;
+	config.profiler_print_format = ProfilerPrintFormat::NONE;
 }
 
 static void PragmaEnableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
@@ -82094,6 +82057,163 @@ void BuiltinFunctions::RegisterDateFunctions() {
 	Register<ToIntervalFun>();
 }
 
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/enum_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct EnumFirst {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumLast {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumRange {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumRangeBoundary {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+static void EnumFirstFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto val = Value(enum_vector.GetValue(0));
+	result.Reference(val);
+}
+
+static void EnumLastFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto val = Value(enum_vector.GetValue(enum_size - 1));
+	result.Reference(val);
+}
+
+static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	vector<Value> enum_values;
+	for (idx_t i = 0; i < enum_size; i++) {
+		enum_values.emplace_back(enum_vector.GetValue(i));
+	}
+	auto val = Value::LIST(enum_values);
+	result.Reference(val);
+}
+
+static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 2);
+	idx_t start, end;
+	auto first_param = input.GetValue(0, 0);
+	auto second_param = input.GetValue(1, 0);
+
+	auto &enum_vector = first_param.is_null ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
+	                                        : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+
+	if (first_param.is_null) {
+		start = 0;
+	} else {
+		start = first_param.GetValue<uint32_t>();
+	}
+	if (second_param.is_null) {
+		end = EnumType::GetSize(input.GetTypes()[0]);
+	} else {
+		end = second_param.GetValue<uint32_t>() + 1;
+	}
+	vector<Value> enum_values;
+	for (idx_t i = start; i < end; i++) {
+		enum_values.emplace_back(enum_vector.GetValue(i));
+	}
+	Value val;
+	if (enum_values.empty()) {
+		val = Value::EMPTYLIST(LogicalType::VARCHAR);
+	} else {
+		val = Value::LIST(enum_values);
+	}
+	result.Reference(val);
+}
+
+unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
+                                          vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	return nullptr;
+}
+
+unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                       vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM && arguments[0]->return_type != LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[1]->return_type.id() != LogicalTypeId::ENUM && arguments[1]->return_type != LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[0]->return_type == LogicalType::SQLNULL && arguments[1]->return_type == LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[0]->return_type.id() == LogicalTypeId::ENUM &&
+	    arguments[1]->return_type.id() == LogicalTypeId::ENUM &&
+	    arguments[0]->return_type != arguments[1]->return_type) {
+
+		throw BinderException("The parameters need to link to ONLY one enum OR be NULL ");
+	}
+	return nullptr;
+}
+
+void EnumFirst::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_first", {LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, false,
+	                               BindEnumFunction));
+}
+
+void EnumLast::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_last", {LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, false,
+	                               BindEnumFunction));
+}
+
+void EnumRange::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_range", {LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
+	                               EnumRangeFunction, false, BindEnumFunction));
+}
+
+void EnumRangeBoundary::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_range_boundary", {LogicalType::ANY, LogicalType::ANY},
+	                               LogicalType::LIST(LogicalType::VARCHAR), EnumRangeBoundaryFunction, false,
+	                               BindEnumRangeBoundaryFunction));
+}
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+void BuiltinFunctions::RegisterEnumFunctions() {
+	Register<EnumFirst>();
+	Register<EnumLast>();
+	Register<EnumRange>();
+	Register<EnumRangeBoundary>();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -91738,8 +91858,7 @@ unique_ptr<FunctionData> BindSystemFunction(ClientContext &context, ScalarFuncti
 
 static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &info = SystemBindData::GetFrom(state);
-
-	Value val(info.context.query);
+	Value val(info.context.GetCurrentQuery());
 	result.Reference(val);
 }
 
@@ -91981,6 +92100,21 @@ void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vecto
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/thread.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <thread>
+
+namespace duckdb {
+using std::thread;
+}
 
 #include <map>
 #include <condition_variable>
@@ -92126,7 +92260,7 @@ private:
 	//! Gets Arrow Table's Cardinality
 	static unique_ptr<NodeStatistics> ArrowScanCardinality(ClientContext &context, const FunctionData *bind_data);
 	//! Gets the progress on the table scan, used for Progress Bars
-	static int ArrowProgress(ClientContext &context, const FunctionData *bind_data_p);
+	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data_p);
 };
 
 } // namespace duckdb
@@ -93225,12 +93359,12 @@ unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContex
 	return make_unique<NodeStatistics>(bind_data.number_of_rows, bind_data.number_of_rows);
 }
 
-int ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
 	if (bind_data.number_of_rows == 0) {
 		return 100;
 	}
-	auto percentage = bind_data.lines_read * 100 / bind_data.number_of_rows;
+	auto percentage = bind_data.lines_read * 100.0 / bind_data.number_of_rows;
 	return percentage;
 }
 
@@ -94915,12 +95049,12 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["skip"] = LogicalType::BIGINT;
 }
 
-int CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (ReadCSVData &)*bind_data_p;
 	if (bind_data.file_size == 0) {
 		return 100;
 	}
-	auto percentage = bind_data.bytes_read * 100 / bind_data.file_size;
+	auto percentage = (bind_data.bytes_read * 100.0) / bind_data.file_size;
 	return percentage;
 }
 
@@ -98134,14 +98268,14 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	                                                  state.column_ids);
 }
 
-int TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
 	idx_t total_rows = bind_data.table->storage->GetTotalRows();
 	if (total_rows == 0 || total_rows < STANDARD_VECTOR_SIZE) {
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
 	}
-	auto percentage = (bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100) / total_rows;
+	auto percentage = double(bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100.0) / total_rows;
 	if (percentage > 100) {
 		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
 		//! It means we finished this table.
@@ -100877,28 +101011,27 @@ private:
 
 namespace duckdb {
 
-class ClientContextLock {
-public:
-	explicit ClientContextLock(mutex &context_lock) : client_guard(context_lock) {
-	}
-
-	~ClientContextLock() {
-	}
-
-private:
-	lock_guard<mutex> client_guard;
+struct ActiveQueryContext {
+	//! The query that is currently being executed
+	string query;
+	//! The currently open result
+	BaseQueryResult *open_result = nullptr;
+	//! Prepared statement data
+	shared_ptr<PreparedStatementData> prepared;
+	//! The query executor
+	unique_ptr<Executor> executor;
+	//! The progress bar
+	unique_ptr<ProgressBar> progress_bar;
 };
 
 ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : profiler(make_unique<QueryProfiler>()), query_profiler_history(make_unique<QueryProfilerHistory>()),
-      db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false), executor(*this),
+    : profiler(make_unique<QueryProfiler>(*this)), query_profiler_history(make_unique<QueryProfilerHistory>()),
+      db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false),
       temporary_objects(make_unique<SchemaCatalogEntry>(&db->GetCatalog(), TEMP_SCHEMA, true)),
       catalog_search_path(make_unique<CatalogSearchPath>(*this)),
-      file_opener(make_unique<ClientContextFileOpener>(*this)), open_result(nullptr) {
+      file_opener(make_unique<ClientContextFileOpener>(*this)) {
 	std::random_device rd;
 	random_engine.seed(rd());
-
-	progress_bar = make_unique<ProgressBar>(&executor, config.wait_time);
 }
 
 ClientContext::~ClientContext() {
@@ -100925,87 +101058,162 @@ void ClientContext::Destroy() {
 	CleanupInternal(*lock);
 }
 
-void ClientContext::Cleanup() {
-	auto lock = LockContext();
-	CleanupInternal(*lock);
+unique_ptr<DataChunk> ClientContext::Fetch(ClientContextLock &lock, StreamQueryResult &result) {
+	D_ASSERT(IsActiveResult(lock, &result));
+	D_ASSERT(active_query->executor);
+	return FetchInternal(lock, *active_query->executor, result);
 }
 
-unique_ptr<DataChunk> ClientContext::Fetch() {
-	auto lock = LockContext();
-	if (!open_result) {
-		throw InternalException("Fetch was called, but there is no open result (or the result was previously closed)");
-	}
+unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &lock, Executor &executor,
+                                                   BaseQueryResult &result) {
+	bool invalidate_query = true;
 	try {
 		// fetch the chunk and return it
-		auto chunk = FetchInternal(*lock);
+		auto chunk = executor.FetchChunk();
+		if (!chunk || chunk->size() == 0) {
+			CleanupInternal(lock, &result);
+		}
 		return chunk;
+	} catch (StandardException &ex) {
+		// standard exceptions do not invalidate the current transaction
+		result.error = ex.what();
+		invalidate_query = false;
 	} catch (std::exception &ex) {
-		open_result->error = ex.what();
+		result.error = ex.what();
 	} catch (...) { // LCOV_EXCL_START
-		open_result->error = "Unhandled exception in Fetch";
+		result.error = "Unhandled exception in FetchInternal";
 	} // LCOV_EXCL_STOP
-	open_result->success = false;
-	CleanupInternal(*lock);
+	result.success = false;
+	CleanupInternal(lock, &result, invalidate_query);
 	return nullptr;
 }
 
-string ClientContext::FinalizeQuery(ClientContextLock &lock, bool success) {
+void ClientContext::BeginTransactionInternal(ClientContextLock &lock, bool requires_valid_transaction) {
+	// check if we are on AutoCommit. In this case we should start a transaction
+	D_ASSERT(!active_query);
+	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
+	    transaction.ActiveTransaction().IsInvalidated()) {
+		throw Exception("Failed: transaction has been invalidated!");
+	}
+	active_query = make_unique<ActiveQueryContext>();
+	if (transaction.IsAutoCommit()) {
+		transaction.BeginTransaction();
+	}
+}
+
+void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &query) {
+	BeginTransactionInternal(lock, false);
+	LogQueryInternal(lock, query);
+	active_query->query = query;
+	query_progress = -1;
+	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
+}
+
+string ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction) {
 	profiler->EndQuery();
-	executor.Reset();
 
+	D_ASSERT(active_query.get());
 	string error;
-	if (transaction.HasActiveTransaction()) {
-		ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
-		// Move the query profiler into the history
-		auto &prev_profilers = query_profiler_history->GetPrevProfilers();
-		prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(profiler));
-		// Reinitialize the query profiler
-		profiler = make_unique<QueryProfiler>();
-		// Propagate settings of the saved query into the new profiler.
-		profiler->Propagate(*prev_profilers.back().second);
-		if (prev_profilers.size() >= query_profiler_history->GetPrevProfilersSize()) {
-			prev_profilers.pop_front();
-		}
-		try {
+	try {
+		if (transaction.HasActiveTransaction()) {
+			// Move the query profiler into the history
+			auto &prev_profilers = query_profiler_history->GetPrevProfilers();
+			prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(profiler));
+			// Reinitialize the query profiler
+			profiler = make_unique<QueryProfiler>(*this);
+			// Propagate settings of the saved query into the new profiler.
+			profiler->Propagate(*prev_profilers.back().second);
+			if (prev_profilers.size() >= query_profiler_history->GetPrevProfilersSize()) {
+				prev_profilers.pop_front();
+			}
+
+			ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
 			if (transaction.IsAutoCommit()) {
 				if (success) {
-					// query was successful: commit
 					transaction.Commit();
 				} else {
-					// query was unsuccessful: rollback
 					transaction.Rollback();
 				}
+			} else if (invalidate_transaction) {
+				D_ASSERT(!success);
+				ActiveTransaction().Invalidate();
 			}
-		} catch (std::exception &ex) {
-			error = ex.what();
-		} catch (...) { // LCOV_EXCL_START
-			error = "Unhandled exception!";
-		} // LCOV_EXCL_STOP
-	}
+		}
+	} catch (std::exception &ex) {
+		error = ex.what();
+	} catch (...) { // LCOV_EXCL_START
+		error = "Unhandled exception!";
+	} // LCOV_EXCL_STOP
+	active_query.reset();
+	query_progress = -1;
 	return error;
 }
 
-void ClientContext::CleanupInternal(ClientContextLock &lock) {
-	if (!open_result) {
-		// no result currently open
+void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
+	if (!active_query) {
+		// no query currently active
 		return;
 	}
+	if (active_query->executor) {
+		active_query->executor->CancelTasks();
+	}
+	active_query->progress_bar.reset();
 
-	auto error = FinalizeQuery(lock, open_result->success);
-	if (open_result->success) {
+	auto error = EndQueryInternal(lock, result ? result->success : false, invalidate_transaction);
+	if (result && result->success) {
 		// if an error occurred while committing report it in the result
-		open_result->error = error;
-		open_result->success = error.empty();
+		result->error = error;
+		result->success = error.empty();
 	}
+	D_ASSERT(!active_query);
+}
 
-	open_result->is_open = false;
-	open_result = nullptr;
+Executor &ClientContext::GetExecutor() {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->executor);
+	return *active_query->executor;
+}
 
-	this->query = string();
+const string &ClientContext::GetCurrentQuery() {
+	D_ASSERT(active_query);
+	return active_query->query;
 }
 
-unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &) {
-	return executor.FetchChunk();
+unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending,
+                                                           bool allow_stream_result) {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->open_result == &pending);
+	D_ASSERT(active_query->prepared);
+	auto &prepared = *active_query->prepared;
+	bool create_stream_result = prepared.allow_stream_result && allow_stream_result;
+	if (create_stream_result) {
+		active_query->progress_bar.reset();
+		query_progress = -1;
+
+		// successfully compiled SELECT clause and it is the last statement
+		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
+		auto stream_result =
+		    make_unique<StreamQueryResult>(pending.statement_type, shared_from_this(), pending.types, pending.names);
+		active_query->open_result = stream_result.get();
+		return move(stream_result);
+	}
+	// create a materialized result by continuously fetching
+	auto result = make_unique<MaterializedQueryResult>(pending.statement_type, pending.types, pending.names);
+	while (true) {
+		auto chunk = FetchInternal(lock, GetExecutor(), *result);
+		if (!chunk || chunk->size() == 0) {
+			break;
+		}
+#ifdef DEBUG
+		for (idx_t i = 0; i < chunk->ColumnCount(); i++) {
+			if (pending.types[i].id() == LogicalTypeId::VARCHAR) {
+				chunk->data[i].UTFVerify(chunk->size());
+			}
+		}
+#endif
+		result->collection.Append(*chunk);
+	}
+	return move(result);
 }
 
 shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query,
@@ -101013,11 +101221,12 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	StatementType statement_type = statement->type;
 	auto result = make_shared<PreparedStatementData>(statement_type);
 
-	profiler->StartPhase("planner");
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartPhase("planner");
 	Planner planner(*this);
 	planner.CreatePlan(move(statement));
 	D_ASSERT(planner.plan);
-	profiler->EndPhase();
+	profiler.EndPhase();
 
 	auto plan = move(planner.plan);
 #ifdef DEBUG
@@ -101033,22 +101242,22 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	result->catalog_version = Transaction::GetTransaction(*this).catalog_version;
 
 	if (config.enable_optimizer) {
-		profiler->StartPhase("optimizer");
+		profiler.StartPhase("optimizer");
 		Optimizer optimizer(*planner.binder, *this);
 		plan = optimizer.Optimize(move(plan));
 		D_ASSERT(plan);
-		profiler->EndPhase();
+		profiler.EndPhase();
 
 #ifdef DEBUG
 		plan->Verify();
 #endif
 	}
 
-	profiler->StartPhase("physical_planner");
+	profiler.StartPhase("physical_planner");
 	// now convert logical query plan into a physical query plan
 	PhysicalPlanGenerator physical_planner(*this);
 	auto physical_plan = physical_planner.CreatePlan(move(plan));
-	profiler->EndPhase();
+	profiler.EndPhase();
 
 #ifdef DEBUG
 	D_ASSERT(!physical_plan->ToString().empty());
@@ -101057,14 +101266,14 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	return result;
 }
 
-int ClientContext::GetProgress() {
-	D_ASSERT(progress_bar);
-	return progress_bar->GetCurrentPercentage();
+double ClientContext::GetProgress() {
+	return query_progress.load();
 }
 
-unique_ptr<QueryResult> ClientContext::ExecutePreparedStatement(ClientContextLock &lock, const string &query,
-                                                                shared_ptr<PreparedStatementData> statement_p,
-                                                                vector<Value> bound_values, bool allow_stream_result) {
+unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
+                                                                       shared_ptr<PreparedStatementData> statement_p,
+                                                                       vector<Value> bound_values) {
+	D_ASSERT(active_query);
 	auto &statement = *statement_p;
 	if (ActiveTransaction().IsInvalidated() && statement.requires_valid_transaction) {
 		throw Exception("Current transaction is aborted (please ROLLBACK)");
@@ -101078,47 +101287,42 @@ unique_ptr<QueryResult> ClientContext::ExecutePreparedStatement(ClientContextLoc
 	// bind the bound values before execution
 	statement.Bind(move(bound_values));
 
-	bool create_stream_result = statement.allow_stream_result && allow_stream_result;
+	active_query->executor = make_unique<Executor>(*this);
+	auto &executor = *active_query->executor;
 	if (config.enable_progress_bar) {
-		progress_bar->Initialize(config.wait_time);
-		progress_bar->Start();
+		active_query->progress_bar = make_unique<ProgressBar>(executor, config.wait_time);
+		active_query->progress_bar->Start();
+		query_progress = 0;
 	}
-	// store the physical plan in the context for calls to Fetch()
 	executor.Initialize(statement.plan.get());
-
 	auto types = executor.GetTypes();
-
 	D_ASSERT(types == statement.types);
+	D_ASSERT(!active_query->open_result);
 
-	if (create_stream_result) {
-		if (config.enable_progress_bar) {
-			progress_bar->Stop();
-		}
-		// successfully compiled SELECT clause and it is the last statement
-		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
-		return make_unique<StreamQueryResult>(statement.statement_type, shared_from_this(), statement.types,
-		                                      statement.names, move(statement_p));
-	}
-	// create a materialized result by continuously fetching
-	auto result = make_unique<MaterializedQueryResult>(statement.statement_type, statement.types, statement.names);
-	while (true) {
-		auto chunk = FetchInternal(lock);
-		if (chunk->size() == 0) {
-			break;
-		}
-#ifdef DEBUG
-		for (idx_t i = 0; i < chunk->ColumnCount(); i++) {
-			if (statement.types[i].id() == LogicalTypeId::VARCHAR) {
-				chunk->data[i].UTFVerify(chunk->size());
-			}
+	auto pending_result = make_unique<PendingQueryResult>(shared_from_this(), *statement_p, move(types));
+	active_query->prepared = move(statement_p);
+	active_query->open_result = pending_result.get();
+	return pending_result;
+}
+
+PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, PendingQueryResult &result) {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->open_result == &result);
+	try {
+		auto result = active_query->executor->ExecuteTask();
+		if (active_query->progress_bar) {
+			active_query->progress_bar->Update(result == PendingExecutionResult::RESULT_READY);
+			query_progress = active_query->progress_bar->GetCurrentPercentage();
 		}
-#endif
-		result->collection.Append(*chunk);
-	}
-	if (config.enable_progress_bar) {
-		progress_bar->Stop();
-	}
-	return move(result);
+		return result;
+	} catch (std::exception &ex) {
+		result.error = ex.what();
+	} catch (...) { // LCOV_EXCL_START
+		result.error = "Unhandled exception in ExecuteTaskInternal";
+	} // LCOV_EXCL_STOP
+	EndQueryInternal(lock, false, true);
+	result.success = false;
+	return PendingExecutionResult::EXECUTION_ERROR;
 }
 
 void ClientContext::InitialCleanup(ClientContextLock &lock) {
@@ -101221,27 +101425,58 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
 	}
 }
 
+unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
+                                                                           shared_ptr<PreparedStatementData> &prepared,
+                                                                           vector<Value> &values) {
+	try {
+		InitialCleanup(lock);
+	} catch (std::exception &ex) {
+		return make_unique<PendingQueryResult>(ex.what());
+	}
+	return PendingStatementOrPreparedStatementInternal(lock, query, nullptr, prepared, &values);
+}
+
+unique_ptr<PendingQueryResult>
+ClientContext::PendingQuery(const string &query, shared_ptr<PreparedStatementData> &prepared, vector<Value> &values) {
+	auto lock = LockContext();
+	return PendingQueryPreparedInternal(*lock, query, prepared, values);
+}
+
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
                                                vector<Value> &values, bool allow_stream_result) {
 	auto lock = LockContext();
-	try {
-		InitialCleanup(*lock);
-	} catch (std::exception &ex) {
-		return make_unique<MaterializedQueryResult>(ex.what());
+	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, values);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(pending->error);
 	}
-	LogQueryInternal(*lock, query);
-	return RunStatementOrPreparedStatement(*lock, query, nullptr, prepared, &values, allow_stream_result);
+	return pending->ExecuteInternal(*lock, allow_stream_result);
 }
 
-unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
-                                                            unique_ptr<SQLStatement> statement,
-                                                            bool allow_stream_result) {
+unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
+                                                                       unique_ptr<SQLStatement> statement) {
 	// prepare the query for execution
 	auto prepared = CreatePreparedStatement(lock, query, move(statement));
 	// by default, no values are bound
 	vector<Value> bound_values;
 	// execute the prepared statement
-	return ExecutePreparedStatement(lock, query, move(prepared), move(bound_values), allow_stream_result);
+	return PendingPreparedStatement(lock, move(prepared), move(bound_values));
+}
+
+unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
+                                                            unique_ptr<SQLStatement> statement,
+                                                            bool allow_stream_result, bool verify) {
+	auto pending = PendingQueryInternal(lock, move(statement), verify);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(move(pending->error));
+	}
+	return ExecutePendingQueryInternal(lock, *pending, allow_stream_result);
+}
+
+bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult *result) {
+	if (!active_query) {
+		return false;
+	}
+	return active_query->open_result == result;
 }
 
 static bool IsExplainAnalyze(SQLStatement *statement) {
@@ -101255,19 +101490,10 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
 }
 
-unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
-                                                                       unique_ptr<SQLStatement> statement,
-                                                                       shared_ptr<PreparedStatementData> &prepared,
-                                                                       vector<Value> *values,
-                                                                       bool allow_stream_result) {
-	this->query = query;
-
-	unique_ptr<QueryResult> result;
+unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
+    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+    shared_ptr<PreparedStatementData> &prepared, vector<Value> *values) {
 	// check if we are on AutoCommit. In this case we should start a transaction.
-	if (transaction.IsAutoCommit()) {
-		transaction.BeginTransaction();
-	}
-	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
 	if (statement && config.query_verification_enabled) {
 		// query verification is enabled
 		// create a copy of the statement, and use the copy
@@ -101277,19 +101503,29 @@ unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientCon
 			// in case this is a select query, we verify the original statement
 			string error = VerifyQuery(lock, query, move(statement));
 			if (!error.empty()) {
-				// query failed: abort now
-				FinalizeQuery(lock, false);
 				// error in verifying query
-				return make_unique<MaterializedQueryResult>(error);
+				return make_unique<PendingQueryResult>(error);
 			}
 		}
 		statement = move(copied_statement);
 	}
+	return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, values);
+}
+
+unique_ptr<PendingQueryResult>
+ClientContext::PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
+                                                   unique_ptr<SQLStatement> statement,
+                                                   shared_ptr<PreparedStatementData> &prepared, vector<Value> *values) {
+	unique_ptr<PendingQueryResult> result;
+
+	BeginQueryInternal(lock, query);
 	// start the profiler
-	profiler->StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+	bool invalidate_query = true;
 	try {
 		if (statement) {
-			result = RunStatementInternal(lock, query, move(statement), allow_stream_result);
+			result = PendingStatementInternal(lock, query, move(statement));
 		} else {
 			auto &catalog = Catalog::GetCatalog(*this);
 			if (prepared->unbound_statement && catalog.GetCatalogVersion() != prepared->catalog_version) {
@@ -101302,68 +101538,22 @@ unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientCon
 				new_prepared->unbound_statement = move(prepared->unbound_statement);
 				prepared = move(new_prepared);
 			}
-			result = ExecutePreparedStatement(lock, query, prepared, *values, allow_stream_result);
+			result = PendingPreparedStatement(lock, prepared, *values);
 		}
 	} catch (StandardException &ex) {
 		// standard exceptions do not invalidate the current transaction
-		result = make_unique<MaterializedQueryResult>(ex.what());
+		result = make_unique<PendingQueryResult>(ex.what());
+		invalidate_query = false;
 	} catch (std::exception &ex) {
 		// other types of exceptions do invalidate the current transaction
-		if (transaction.HasActiveTransaction()) {
-			ActiveTransaction().Invalidate();
-		}
-		result = make_unique<MaterializedQueryResult>(ex.what());
+		result = make_unique<PendingQueryResult>(ex.what());
 	}
 	if (!result->success) {
-		// initial failures should always be reported as MaterializedResult
-		D_ASSERT(result->type != QueryResultType::STREAM_RESULT);
 		// query failed: abort now
-		FinalizeQuery(lock, false);
+		EndQueryInternal(lock, false, invalidate_query);
 		return result;
 	}
-	// query succeeded, append to list of results
-	if (result->type == QueryResultType::STREAM_RESULT) {
-		// store as currently open result if it is a stream result
-		this->open_result = (StreamQueryResult *)result.get();
-	} else {
-		// finalize the query if it is not a stream result
-		string error = FinalizeQuery(lock, true);
-		if (!error.empty()) {
-			// failure in committing transaction
-			return make_unique<MaterializedQueryResult>(error);
-		}
-	}
-	return result;
-}
-
-unique_ptr<QueryResult> ClientContext::RunStatement(ClientContextLock &lock, const string &query,
-                                                    unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	shared_ptr<PreparedStatementData> prepared;
-	return RunStatementOrPreparedStatement(lock, query, move(statement), prepared, nullptr, allow_stream_result);
-}
-
-unique_ptr<QueryResult> ClientContext::RunStatements(ClientContextLock &lock, const string &query,
-                                                     vector<unique_ptr<SQLStatement>> &statements,
-                                                     bool allow_stream_result) {
-	// now we have a list of statements
-	// iterate over them and execute them one by one
-	unique_ptr<QueryResult> result;
-	QueryResult *last_result = nullptr;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		auto &statement = statements[i];
-		bool is_last_statement = i + 1 == statements.size();
-		auto current_result = RunStatement(lock, query, move(statement), allow_stream_result && is_last_statement);
-		// now append the result to the list of results
-		if (!last_result) {
-			// first result of the query
-			result = move(current_result);
-			last_result = result.get();
-		} else {
-			// later results; attach to the result chain
-			last_result->next = move(current_result);
-			last_result = last_result->next.get();
-		}
-	}
+	D_ASSERT(active_query->open_result == result.get());
 	return result;
 }
 
@@ -101389,34 +101579,96 @@ void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
 }
 
 unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	auto lock = LockContext();
-	LogQueryInternal(*lock, statement->query.substr(statement->stmt_location, statement->stmt_length));
-
-	vector<unique_ptr<SQLStatement>> statements;
-	statements.push_back(move(statement));
-
-	return RunStatements(*lock, query, statements, allow_stream_result);
+	auto pending_query = PendingQuery(move(statement));
+	return pending_query->Execute(allow_stream_result);
 }
 
 unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_stream_result) {
 	auto lock = LockContext();
-	LogQueryInternal(*lock, query);
 
+	string error;
 	vector<unique_ptr<SQLStatement>> statements;
+	if (!ParseStatements(*lock, query, statements, error)) {
+		return make_unique<MaterializedQueryResult>(move(error));
+	}
+	if (statements.empty()) {
+		// no statements, return empty successful result
+		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT);
+	}
+
+	unique_ptr<QueryResult> result;
+	QueryResult *last_result = nullptr;
+	for (idx_t i = 0; i < statements.size(); i++) {
+		auto &statement = statements[i];
+		bool is_last_statement = i + 1 == statements.size();
+		bool stream_result = allow_stream_result && is_last_statement;
+		auto pending_query = PendingQueryInternal(*lock, move(statement));
+		unique_ptr<QueryResult> current_result;
+		if (!pending_query->success) {
+			current_result = make_unique<MaterializedQueryResult>(pending_query->error);
+		} else {
+			current_result = ExecutePendingQueryInternal(*lock, *pending_query, stream_result);
+		}
+		// now append the result to the list of results
+		if (!last_result) {
+			// first result of the query
+			result = move(current_result);
+			last_result = result.get();
+		} else {
+			// later results; attach to the result chain
+			last_result->next = move(current_result);
+			last_result = last_result->next.get();
+		}
+	}
+	return result;
+}
+
+bool ClientContext::ParseStatements(ClientContextLock &lock, const string &query,
+                                    vector<unique_ptr<SQLStatement>> &result, string &error) {
 	try {
-		InitialCleanup(*lock);
+		InitialCleanup(lock);
 		// parse the query and transform it into a set of statements
-		statements = ParseStatementsInternal(*lock, query);
+		result = ParseStatementsInternal(lock, query);
+		return true;
 	} catch (std::exception &ex) {
-		return make_unique<MaterializedQueryResult>(ex.what());
+		error = ex.what();
+		return false;
 	}
+}
 
-	if (statements.empty()) {
-		// no statements, return empty successful result
-		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT);
+unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query) {
+	auto lock = LockContext();
+
+	string error;
+	vector<unique_ptr<SQLStatement>> statements;
+	if (!ParseStatements(*lock, query, statements, error)) {
+		return make_unique<PendingQueryResult>(move(error));
 	}
+	if (statements.size() != 1) {
+		return make_unique<PendingQueryResult>("PendingQuery can only take a single statement");
+	}
+	return PendingQueryInternal(*lock, move(statements[0]));
+}
 
-	return RunStatements(*lock, query, statements, allow_stream_result);
+unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement) {
+	auto lock = LockContext();
+	return PendingQueryInternal(*lock, move(statement));
+}
+
+unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
+                                                                   unique_ptr<SQLStatement> statement, bool verify) {
+	auto query = statement->query;
+	shared_ptr<PreparedStatementData> prepared;
+	if (verify) {
+		return PendingStatementOrPreparedStatementInternal(lock, query, move(statement), prepared, nullptr);
+	} else {
+		return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, nullptr);
+	}
+}
+
+unique_ptr<QueryResult> ClientContext::ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query,
+                                                                   bool allow_stream_result) {
+	return query.ExecuteInternal(lock, allow_stream_result);
 }
 
 void ClientContext::Interrupt() {
@@ -101425,12 +101677,14 @@ void ClientContext::Interrupt() {
 
 void ClientContext::EnableProfiling() {
 	auto lock = LockContext();
-	profiler->Enable();
+	auto &config = ClientConfig::GetConfig(*this);
+	config.enable_profiler = true;
 }
 
 void ClientContext::DisableProfiling() {
 	auto lock = LockContext();
-	profiler->Disable();
+	auto &config = ClientConfig::GetConfig(*this);
+	config.enable_profiler = false;
 }
 
 string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement) {
@@ -101492,9 +101746,10 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 #endif
 
 	// disable profiling if it is enabled
-	bool profiling_is_enabled = profiler->IsEnabled();
+	auto &config = ClientConfig::GetConfig(*this);
+	bool profiling_is_enabled = config.enable_profiler;
 	if (profiling_is_enabled) {
-		profiler->Disable();
+		config.enable_profiler = false;
 	}
 
 	// see below
@@ -101511,7 +101766,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 
 	// execute the original statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(statement), false);
+		auto result = RunStatementInternal(lock, query, move(statement), false, false);
 		original_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		original_result->error = ex.what();
@@ -101524,7 +101779,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 		auto explain_q = "EXPLAIN " + query;
 		auto explain_stmt = make_unique<ExplainStatement>(move(statement_copy_for_explain));
 		try {
-			RunStatementInternal(lock, explain_q, move(explain_stmt), false);
+			RunStatementInternal(lock, explain_q, move(explain_stmt), false, false);
 		} catch (std::exception &ex) { // LCOV_EXCL_START
 			return "EXPLAIN failed but query did not (" + string(ex.what()) + ")";
 		} // LCOV_EXCL_STOP
@@ -101532,7 +101787,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 
 	// now execute the copied statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(copied_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(copied_stmt), false, false);
 		copied_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		copied_result->error = ex.what();
@@ -101541,7 +101796,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	}
 	// now execute the deserialized statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false, false);
 		deserialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		deserialized_result->error = ex.what();
@@ -101551,7 +101806,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	// now execute the unoptimized statement
 	config.enable_optimizer = false;
 	try {
-		auto result = RunStatementInternal(lock, query, move(unoptimized_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(unoptimized_stmt), false, false);
 		unoptimized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		unoptimized_result->error = ex.what();
@@ -101561,7 +101816,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	config.enable_optimizer = true;
 
 	if (profiling_is_enabled) {
-		profiler->Enable();
+		config.enable_profiler = true;
 	}
 
 	// now compare the results
@@ -101615,7 +101870,7 @@ bool ClientContext::UpdateFunctionInfoFromEntry(ScalarFunctionCatalogEntry *exis
 void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
 	RunFunctionInTransaction([&]() {
 		auto &catalog = Catalog::GetCatalog(*this);
-		ScalarFunctionCatalogEntry *existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
+		auto existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
 		    *this, CatalogType::SCALAR_FUNCTION_ENTRY, info->schema, info->name, true);
 		if (existing_function) {
 			if (UpdateFunctionInfoFromEntry(existing_function, (CreateScalarFunctionInfo *)info)) {
@@ -101637,6 +101892,7 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co
 	// check if we are on AutoCommit. In this case we should start a transaction
 	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
 	if (require_new_transaction) {
+		D_ASSERT(!active_query);
 		transaction.BeginTransaction();
 	}
 	try {
@@ -101751,12 +102007,14 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 			// verify read only statements by running a select statement
 			auto select = make_unique<SelectStatement>();
 			select->node = relation->GetQueryNode();
-			RunStatement(*lock, query, move(select), false);
+			RunStatementInternal(*lock, query, move(select), false);
 		}
 	}
 	auto &expected_columns = relation->Columns();
 	auto relation_stmt = make_unique<RelationStatement>(relation);
-	auto result = RunStatement(*lock, query, move(relation_stmt), false);
+
+	unique_ptr<QueryResult> result;
+	result = RunStatementInternal(*lock, query, move(relation_stmt), false);
 	if (!result->success) {
 		return result;
 	}
@@ -102528,10 +102786,11 @@ Connection::Connection(DuckDB &database) : Connection(*database.instance) {
 }
 
 string Connection::GetProfilingInformation(ProfilerPrintFormat format) {
+	auto &profiler = QueryProfiler::Get(*context);
 	if (format == ProfilerPrintFormat::JSON) {
-		return context->profiler->ToJSON();
+		return profiler.ToJSON();
 	} else {
-		return context->profiler->ToString();
+		return profiler.ToString();
 	}
 }
 
@@ -102575,6 +102834,14 @@ unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> s
 	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 }
 
+unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query) {
+	return context->PendingQuery(query);
+}
+
+unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement) {
+	return context->PendingQuery(move(statement));
+}
+
 unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
 	return context->Prepare(query);
 }
@@ -110883,6 +111150,75 @@ unique_ptr<DataChunk> MaterializedQueryResult::FetchRaw() {
 
 
 
+namespace duckdb {
+
+PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
+                                       vector<LogicalType> types_p)
+    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, move(types_p), statement.names),
+      context(move(context_p)) {
+}
+
+PendingQueryResult::PendingQueryResult(string error) : BaseQueryResult(QueryResultType::PENDING_RESULT, move(error)) {
+}
+
+PendingQueryResult::~PendingQueryResult() {
+}
+
+unique_ptr<ClientContextLock> PendingQueryResult::LockContext() {
+	if (!context) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+	return context->LockContext();
+}
+
+void PendingQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
+	bool invalidated = !success || !context;
+	if (!invalidated) {
+		invalidated = !context->IsActiveResult(lock, this);
+	}
+	if (invalidated) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+}
+
+PendingExecutionResult PendingQueryResult::ExecuteTask() {
+	auto lock = LockContext();
+	return ExecuteTaskInternal(*lock);
+}
+
+PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock &lock) {
+	CheckExecutableInternal(lock);
+	return context->ExecuteTaskInternal(lock, *this);
+}
+
+unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock, bool allow_streaming_result) {
+	CheckExecutableInternal(lock);
+	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
+	}
+	if (!success) {
+		return make_unique<MaterializedQueryResult>(error);
+	}
+	auto result = context->FetchResultInternal(lock, *this, allow_streaming_result);
+	Close();
+	return result;
+}
+
+unique_ptr<QueryResult> PendingQueryResult::Execute(bool allow_streaming_result) {
+	auto lock = LockContext();
+	return ExecuteInternal(*lock, allow_streaming_result);
+}
+
+void PendingQueryResult::Close() {
+	context.reset();
+}
+
+} // namespace duckdb
+
+
+
+
 
 namespace duckdb {
 
@@ -110919,11 +111255,19 @@ const vector<string> &PreparedStatement::GetNames() {
 }
 
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
+	auto pending = PendingQuery(values);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(pending->error);
+	}
+	return pending->Execute(allow_stream_result && data->allow_stream_result);
+}
+
+unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values) {
 	if (!success) {
 		throw InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
 	}
 	D_ASSERT(data);
-	auto result = context->Execute(query, data, values, allow_stream_result && data->allow_stream_result);
+	auto result = context->PendingQuery(query, data, values);
 	return result;
 }
 
@@ -111009,16 +111353,42 @@ using std::ofstream;
 
 
 
+
+
 #include <utility>
 #include <algorithm>
 
 namespace duckdb {
 
+QueryProfiler::QueryProfiler(ClientContext &context_p)
+    : context(context_p), running(false), query_requires_profiling(false), is_explain_analyze(false) {
+}
+
+bool QueryProfiler::IsEnabled() const {
+	return is_explain_analyze ? true : ClientConfig::GetConfig(context).enable_profiler;
+}
+
+bool QueryProfiler::IsDetailedEnabled() const {
+	return is_explain_analyze ? false : ClientConfig::GetConfig(context).enable_detailed_profiling;
+}
+
+ProfilerPrintFormat QueryProfiler::GetPrintFormat() const {
+	return is_explain_analyze ? ProfilerPrintFormat::NONE : ClientConfig::GetConfig(context).profiler_print_format;
+}
+
+string QueryProfiler::GetSaveLocation() const {
+	return is_explain_analyze ? string() : ClientConfig::GetConfig(context).profiler_save_location;
+}
+
+QueryProfiler &QueryProfiler::Get(ClientContext &context) {
+	return *context.profiler;
+}
+
 void QueryProfiler::StartQuery(string query, bool is_explain_analyze) {
 	if (is_explain_analyze) {
 		StartExplainAnalyze();
 	}
-	if (!enabled) {
+	if (!IsEnabled()) {
 		return;
 	}
 	this->running = true;
@@ -111076,17 +111446,10 @@ void QueryProfiler::Finalize(TreeNode &node) {
 
 void QueryProfiler::StartExplainAnalyze() {
 	this->is_explain_analyze = true;
-	this->stored_enabled = enabled;
-	this->stored_automatic_print_format = automatic_print_format;
-	this->stored_save_location = save_location;
-
-	this->enabled = true;
-	this->save_location = string();
-	this->automatic_print_format = ProfilerPrintFormat::NONE;
 }
 
 void QueryProfiler::EndQuery() {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 
@@ -111095,6 +111458,7 @@ void QueryProfiler::EndQuery() {
 		Finalize(*root);
 	}
 	this->running = false;
+	auto automatic_print_format = GetPrintFormat();
 	// print or output the query profiling after termination, if this is enabled
 	if (automatic_print_format != ProfilerPrintFormat::NONE) {
 		// check if this query should be output based on the operator types
@@ -111106,7 +111470,7 @@ void QueryProfiler::EndQuery() {
 		} else if (automatic_print_format == ProfilerPrintFormat::QUERY_TREE_OPTIMIZER) {
 			query_info = ToString(true);
 		}
-
+		auto save_location = GetSaveLocation();
 		if (save_location.empty()) {
 			Printer::Print(query_info);
 			Printer::Print("\n");
@@ -111114,16 +111478,11 @@ void QueryProfiler::EndQuery() {
 			WriteToFile(save_location.c_str(), query_info);
 		}
 	}
-	if (is_explain_analyze) {
-		this->is_explain_analyze = false;
-		this->enabled = stored_enabled;
-		this->automatic_print_format = stored_automatic_print_format;
-		this->save_location = stored_save_location;
-	}
+	this->is_explain_analyze = false;
 }
 
 void QueryProfiler::StartPhase(string new_phase) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 
@@ -111147,7 +111506,7 @@ void QueryProfiler::StartPhase(string new_phase) {
 }
 
 void QueryProfiler::EndPhase() {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	D_ASSERT(phase_stack.size() > 0);
@@ -111167,7 +111526,7 @@ void QueryProfiler::EndPhase() {
 }
 
 void QueryProfiler::Initialize(PhysicalOperator *root_op) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	this->query_requires_profiling = false;
@@ -111248,7 +111607,7 @@ void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor
 }
 
 void QueryProfiler::Flush(OperatorProfiler &profiler) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	lock_guard<mutex> guard(flush_lock);
@@ -111258,7 +111617,7 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 
 		entry->second->info.time += node.second.time;
 		entry->second->info.elements += node.second.elements;
-		if (!detailed_enabled) {
+		if (!IsDetailedEnabled()) {
 			continue;
 		}
 		for (auto &info : node.second.executors_info) {
@@ -111319,7 +111678,7 @@ string QueryProfiler::ToString(bool print_optimizer_output) const {
 }
 
 void QueryProfiler::ToStream(std::ostream &ss, bool print_optimizer_output) const {
-	if (!enabled) {
+	if (!IsEnabled()) {
 		ss << "Query profiling is disabled. Call "
 		      "Connection::EnableProfiling() to enable profiling!";
 		return;
@@ -111490,7 +111849,7 @@ static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int
 }
 
 string QueryProfiler::ToJSON() const {
-	if (!enabled) {
+	if (!IsEnabled()) {
 		return "{ \"result\": \"disabled\" }\n";
 	}
 	if (query.empty()) {
@@ -111605,10 +111964,6 @@ vector<QueryProfiler::PhaseTimingItem> QueryProfiler::GetOrderedPhaseTimings() c
 	return result;
 }
 void QueryProfiler::Propagate(QueryProfiler &qp) {
-	this->automatic_print_format = qp.automatic_print_format;
-	this->save_location = qp.save_location;
-	this->enabled = qp.enabled;
-	this->detailed_enabled = qp.detailed_enabled;
 }
 
 void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &state) {
@@ -111665,17 +112020,44 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
 
 namespace duckdb {
 
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type)
+BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type)
     : type(type), statement_type(statement_type), success(true) {
 }
 
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
-                         vector<string> names_p)
+BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
+                                 vector<string> names_p)
     : type(type), statement_type(statement_type), types(move(types_p)), names(move(names_p)), success(true) {
 	D_ASSERT(types.size() == names.size());
 }
 
-QueryResult::QueryResult(QueryResultType type, string error) : type(type), success(false), error(move(error)) {
+BaseQueryResult::BaseQueryResult(QueryResultType type, string error) : type(type), success(false), error(move(error)) {
+}
+
+BaseQueryResult::~BaseQueryResult() {
+}
+
+bool BaseQueryResult::HasError() {
+	return !success;
+}
+const string &BaseQueryResult::GetError() {
+	return error;
+}
+idx_t BaseQueryResult::ColumnCount() {
+	return types.size();
+}
+
+QueryResult::QueryResult(QueryResultType type, StatementType statement_type) : BaseQueryResult(type, statement_type) {
+}
+
+QueryResult::QueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
+                         vector<string> names_p)
+    : BaseQueryResult(type, statement_type, move(types_p), move(names_p)) {
+}
+
+QueryResult::QueryResult(QueryResultType type, string error) : BaseQueryResult(type, move(error)) {
+}
+
+QueryResult::~QueryResult() {
 }
 
 unique_ptr<DataChunk> QueryResult::Fetch() {
@@ -114694,24 +115076,27 @@ Value EnableObjectCacheSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void EnableProfilingSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
+
+	auto &config = ClientConfig::GetConfig(context);
 	if (parameter == "json") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::JSON;
+		config.profiler_print_format = ProfilerPrintFormat::JSON;
 	} else if (parameter == "query_tree") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE;
+		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
 	} else if (parameter == "query_tree_optimizer") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
+		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
 	} else {
 		throw ParserException(
 		    "Unrecognized print format %s, supported formats: [json, query_tree, query_tree_optimizer]", parameter);
 	}
-	context.profiler->Enable();
+	config.enable_profiler = true;
 }
 
 Value EnableProfilingSetting::GetSetting(ClientContext &context) {
-	if (!context.profiler->IsEnabled()) {
+	auto &config = ClientConfig::GetConfig(context);
+	if (!config.enable_profiler) {
 		return Value();
 	}
-	switch (context.profiler->automatic_print_format) {
+	switch (config.profiler_print_format) {
 	case ProfilerPrintFormat::NONE:
 		return Value("none");
 	case ProfilerPrintFormat::JSON:
@@ -114855,12 +115240,14 @@ Value ProfilerHistorySize::GetSetting(ClientContext &context) {
 // Profile Output
 //===--------------------------------------------------------------------===//
 void ProfileOutputSetting::SetLocal(ClientContext &context, const Value &input) {
+	auto &config = ClientConfig::GetConfig(context);
 	auto parameter = input.ToString();
-	context.profiler->save_location = parameter;
+	config.profiler_save_location = parameter;
 }
 
 Value ProfileOutputSetting::GetSetting(ClientContext &context) {
-	return Value(context.profiler->save_location);
+	auto &config = ClientConfig::GetConfig(context);
+	return Value(config.profiler_save_location);
 }
 
 //===--------------------------------------------------------------------===//
@@ -114868,17 +115255,24 @@ Value ProfileOutputSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void ProfilingModeSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
+	auto &config = ClientConfig::GetConfig(context);
 	if (parameter == "standard") {
-		context.profiler->Enable();
+		config.enable_profiler = true;
+		config.enable_detailed_profiling = false;
 	} else if (parameter == "detailed") {
-		context.profiler->DetailedEnable();
+		config.enable_profiler = true;
+		config.enable_detailed_profiling = true;
 	} else {
 		throw ParserException("Unrecognized profiling mode \"%s\", supported formats: [standard, detailed]", parameter);
 	}
 }
 
 Value ProfilingModeSetting::GetSetting(ClientContext &context) {
-	return Value(context.profiler->IsDetailedEnabled() ? "detailed" : "standard");
+	auto &config = ClientConfig::GetConfig(context);
+	if (!config.enable_profiler) {
+		return Value();
+	}
+	return Value(config.enable_detailed_profiling ? "detailed" : "standard");
 }
 
 //===--------------------------------------------------------------------===//
@@ -114958,14 +115352,11 @@ Value ThreadsSetting::GetSetting(ClientContext &context) {
 namespace duckdb {
 
 StreamQueryResult::StreamQueryResult(StatementType statement_type, shared_ptr<ClientContext> context,
-                                     vector<LogicalType> types, vector<string> names,
-                                     shared_ptr<PreparedStatementData> prepared)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(types), move(names)), is_open(true),
-      context(move(context)), prepared(move(prepared)) {
+                                     vector<LogicalType> types, vector<string> names)
+    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(types), move(names)), context(move(context)) {
 }
 
 StreamQueryResult::~StreamQueryResult() {
-	Close();
 }
 
 string StreamQueryResult::ToString() {
@@ -114979,12 +115370,28 @@ string StreamQueryResult::ToString() {
 	return result;
 }
 
+unique_ptr<ClientContextLock> StreamQueryResult::LockContext() {
+	if (!context) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+	return context->LockContext();
+}
+
+void StreamQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
+	if (!IsOpenInternal(lock)) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+}
+
 unique_ptr<DataChunk> StreamQueryResult::FetchRaw() {
-	if (!success || !is_open) {
-		throw InvalidInputException(
-		    "Attempting to fetch from an unsuccessful or closed streaming query result\nError: %s", error);
+	unique_ptr<DataChunk> chunk;
+	{
+		auto lock = LockContext();
+		CheckExecutableInternal(*lock);
+		chunk = context->Fetch(*lock, *this);
 	}
-	auto chunk = context->Fetch();
 	if (!chunk || chunk->ColumnCount() == 0 || chunk->size() == 0) {
 		Close();
 		return nullptr;
@@ -115010,12 +115417,24 @@ unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
 	return result;
 }
 
-void StreamQueryResult::Close() {
-	if (!is_open) {
-		return;
+bool StreamQueryResult::IsOpenInternal(ClientContextLock &lock) {
+	bool invalidated = !success || !context;
+	if (!invalidated) {
+		invalidated = !context->IsActiveResult(lock, this);
 	}
-	is_open = false;
-	context->Cleanup();
+	return !invalidated;
+}
+
+bool StreamQueryResult::IsOpen() {
+	if (!success || !context) {
+		return false;
+	}
+	auto lock = LockContext();
+	return IsOpenInternal(*lock);
+}
+
+void StreamQueryResult::Close() {
+	context.reset();
 }
 
 } // namespace duckdb
@@ -119810,9 +120229,10 @@ void Optimizer::RunOptimizer(OptimizerType type, const std::function<void()> &ca
 		// optimizer is marked as disabled: skip
 		return;
 	}
-	context.profiler->StartPhase(OptimizerTypeToString(type));
+	auto &profiler = QueryProfiler::Get(context);
+	profiler.StartPhase(OptimizerTypeToString(type));
 	callback();
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 }
 
 unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan) {
@@ -123771,6 +124191,10 @@ public:
 
 	//! Fully execute a pipeline with a source and a sink until the source is completely exhausted
 	void Execute();
+	//! Execute a pipeline with a source and a sink until finished, or until max_chunks have been processed
+	//! Returns true if execution is finished, false if Execute should be called again
+	bool Execute(idx_t max_chunks);
+
 	//! Push a single input DataChunk into the pipeline.
 	//! Returns either OperatorResultType::NEED_MORE_INPUT or OperatorResultType::FINISHED
 	//! If OperatorResultType::FINISHED is returned, more input will not change the result anymore
@@ -123939,7 +124363,7 @@ Executor::~Executor() {
 }
 
 Executor &Executor::Get(ClientContext &context) {
-	return context.executor;
+	return context.GetExecutor();
 }
 
 void Executor::AddEvent(shared_ptr<Event> event) {
@@ -124168,16 +124592,6 @@ void Executor::VerifyPipelines() {
 #endif
 }
 
-void Executor::WorkOnTasks() {
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-
-	unique_ptr<Task> task;
-	while (scheduler.GetTaskFromProducer(*producer, task)) {
-		task->Execute();
-		task.reset();
-	}
-}
-
 void Executor::Initialize(PhysicalOperator *plan) {
 	Reset();
 
@@ -124186,7 +124600,8 @@ void Executor::Initialize(PhysicalOperator *plan) {
 		lock_guard<mutex> elock(executor_lock);
 		physical_plan = plan;
 
-		context.profiler->Initialize(physical_plan);
+		auto &profiler = QueryProfiler::Get(context);
+		profiler.Initialize(physical_plan);
 		this->producer = scheduler.CreateProducer();
 
 		auto root_pipeline = make_shared<Pipeline>(*this);
@@ -124202,60 +124617,102 @@ void Executor::Initialize(PhysicalOperator *plan) {
 
 		ScheduleEvents();
 	}
+}
 
-	// now execute tasks from this producer until all pipelines are completed
-	while (completed_pipelines < total_pipelines) {
-		WorkOnTasks();
-		if (!HasError()) {
-			// no exceptions: continue
-			continue;
+void Executor::CancelTasks() {
+	task.reset();
+	// we do this by creating weak pointers to all pipelines
+	// then clearing our references to the pipelines
+	// and waiting until all pipelines have been destroyed
+	vector<weak_ptr<Pipeline>> weak_references;
+	{
+		lock_guard<mutex> elock(executor_lock);
+		if (pipelines.empty()) {
+			return;
 		}
-
-		// an exception has occurred executing one of the pipelines
-		// we need to wait until all threads are finished
-		// we do this by creating weak pointers to all pipelines
-		// then clearing our references to the pipelines
-		// and waiting until all pipelines have been destroyed
-		vector<weak_ptr<Pipeline>> weak_references;
-		{
-			lock_guard<mutex> elock(executor_lock);
-			weak_references.reserve(pipelines.size());
-			for (auto &pipeline : pipelines) {
+		weak_references.reserve(pipelines.size());
+		for (auto &pipeline : pipelines) {
+			weak_references.push_back(weak_ptr<Pipeline>(pipeline));
+		}
+		for (auto &kv : union_pipelines) {
+			for (auto &pipeline : kv.second) {
 				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
 			}
-			for (auto &kv : union_pipelines) {
-				for (auto &pipeline : kv.second) {
-					weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-				}
+		}
+		for (auto &kv : child_pipelines) {
+			for (auto &pipeline : kv.second) {
+				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
 			}
-			for (auto &kv : child_pipelines) {
-				for (auto &pipeline : kv.second) {
-					weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-				}
+		}
+		pipelines.clear();
+		union_pipelines.clear();
+		child_pipelines.clear();
+		events.clear();
+	}
+	WorkOnTasks();
+	for (auto &weak_ref : weak_references) {
+		while (true) {
+			auto weak = weak_ref.lock();
+			if (!weak) {
+				break;
 			}
-			pipelines.clear();
-			union_pipelines.clear();
-			child_pipelines.clear();
-			events.clear();
 		}
-		for (auto &weak_ref : weak_references) {
-			while (true) {
-				auto weak = weak_ref.lock();
-				if (!weak) {
-					break;
-				}
+	}
+}
+
+void Executor::WorkOnTasks() {
+	auto &scheduler = TaskScheduler::GetScheduler(context);
+
+	unique_ptr<Task> task;
+	while (scheduler.GetTaskFromProducer(*producer, task)) {
+		task->Execute(TaskExecutionMode::PROCESS_ALL);
+		task.reset();
+	}
+}
+
+PendingExecutionResult Executor::ExecuteTask() {
+	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
+		return execution_result;
+	}
+	// check if there are any incomplete pipelines
+	auto &scheduler = TaskScheduler::GetScheduler(context);
+	while (completed_pipelines < total_pipelines) {
+		// there are! if we don't already have a task, fetch one
+		if (!task) {
+			scheduler.GetTaskFromProducer(*producer, task);
+		}
+		if (task) {
+			// if we have a task, partially process it
+			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
+			if (result != TaskExecutionResult::TASK_NOT_FINISHED) {
+				// if the task is finished, clean it up
+				task.reset();
 			}
 		}
+		if (!HasError()) {
+			// we (partially) processed a task and no exceptions were thrown
+			// give back control to the caller
+			return PendingExecutionResult::RESULT_NOT_READY;
+		}
+		execution_result = PendingExecutionResult::EXECUTION_ERROR;
+
+		// an exception has occurred executing one of the pipelines
+		// we need to cancel all tasks associated with this executor
+		CancelTasks();
 		ThrowException();
 	}
+	D_ASSERT(!task);
 
 	lock_guard<mutex> elock(executor_lock);
 	pipelines.clear();
 	NextExecutor();
 	if (!exceptions.empty()) { // LCOV_EXCL_START
 		// an exception has occurred executing one of the pipelines
+		execution_result = PendingExecutionResult::EXECUTION_ERROR;
 		ThrowExceptionInternal();
 	} // LCOV_EXCL_STOP
+	execution_result = PendingExecutionResult::RESULT_READY;
+	return execution_result;
 }
 
 void Executor::Reset() {
@@ -124274,6 +124731,7 @@ void Executor::Reset() {
 	union_pipelines.clear();
 	child_pipelines.clear();
 	child_dependencies.clear();
+	execution_result = PendingExecutionResult::RESULT_NOT_READY;
 }
 
 void Executor::AddChildPipeline(Pipeline *current) {
@@ -124555,10 +125013,11 @@ void Executor::ThrowExceptionInternal() { // LCOV_EXCL_START
 
 void Executor::Flush(ThreadContext &tcontext) {
 	lock_guard<mutex> elock(executor_lock);
-	context.profiler->Flush(tcontext.profiler);
+	auto &profiler = QueryProfiler::Get(context);
+	profiler.Flush(tcontext.profiler);
 }
 
-bool Executor::GetPipelinesProgress(int &current_progress) { // LCOV_EXCL_START
+bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_START
 	lock_guard<mutex> elock(executor_lock);
 
 	if (!pipelines.empty()) {
@@ -124604,9 +125063,9 @@ ExecutorTask::ExecutorTask(ClientContext &context) : ExecutorTask(Executor::Get(
 ExecutorTask::~ExecutorTask() {
 }
 
-void ExecutorTask::Execute() {
+TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 	try {
-		ExecuteTask();
+		return ExecuteTask(mode);
 	} catch (Exception &ex) {
 		executor.PushError(ex.type, ex.what());
 	} catch (std::exception &ex) {
@@ -124614,6 +125073,7 @@ void ExecutorTask::Execute() {
 	} catch (...) { // LCOV_EXCL_START
 		executor.PushError(ExceptionType::UNKNOWN_TYPE, "Unknown exception in Finalize!");
 	} // LCOV_EXCL_STOP
+	return TaskExecutionResult::TASK_ERROR;
 }
 
 } // namespace duckdb
@@ -124641,6 +125101,8 @@ void ExecutorTask::Execute() {
 namespace duckdb {
 
 class PipelineTask : public ExecutorTask {
+	static constexpr const idx_t PARTIAL_CHUNK_COUNT = 50;
+
 public:
 	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
 	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(move(event_p)) {
@@ -124648,12 +125110,24 @@ public:
 
 	Pipeline &pipeline;
 	shared_ptr<Event> event;
+	unique_ptr<PipelineExecutor> pipeline_executor;
 
 public:
-	void ExecuteTask() override {
-		PipelineExecutor executor(pipeline.GetClientContext(), pipeline);
-		executor.Execute();
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		if (!pipeline_executor) {
+			pipeline_executor = make_unique<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
+		}
+		if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
+			bool finished = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
+			if (!finished) {
+				return TaskExecutionResult::TASK_NOT_FINISHED;
+			}
+		} else {
+			pipeline_executor->Execute();
+		}
 		event->FinishTask();
+		pipeline_executor.reset();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 };
 
@@ -124665,7 +125139,7 @@ ClientContext &Pipeline::GetClientContext() {
 }
 
 // LCOV_EXCL_START
-bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op, int &current_percentage) {
+bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op, double &current_percentage) {
 	current_percentage = -1;
 	switch (op->type) {
 	case PhysicalOperatorType::TABLE_SCAN: {
@@ -124684,7 +125158,7 @@ bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op,
 }
 // LCOV_EXCL_STOP
 
-bool Pipeline::GetProgress(int &current_percentage) {
+bool Pipeline::GetProgress(double &current_percentage) {
 	auto &client = executor.context;
 	return GetProgressInternal(client, source, current_percentage);
 }
@@ -124885,16 +125359,18 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 	InitializeChunk(final_chunk);
 }
 
-void PipelineExecutor::Execute() {
+bool PipelineExecutor::Execute(idx_t max_chunks) {
 	D_ASSERT(pipeline.sink);
+	bool exhausted_source = false;
 	auto &source_chunk = pipeline.operators.empty() ? final_chunk : *intermediate_chunks[0];
-	while (true) {
+	for (idx_t i = 0; i < max_chunks; i++) {
 		if (finished_processing) {
 			break;
 		}
 		source_chunk.Reset();
 		FetchFromSource(source_chunk);
 		if (source_chunk.size() == 0) {
+			exhausted_source = true;
 			break;
 		}
 		auto result = ExecutePushInternal(source_chunk);
@@ -124903,7 +125379,15 @@ void PipelineExecutor::Execute() {
 			break;
 		}
 	}
+	if (!exhausted_source && !finished_processing) {
+		return false;
+	}
 	PushFinalize();
+	return true;
+}
+
+void PipelineExecutor::Execute() {
+	Execute(NumericLimits<idx_t>::Maximum());
 }
 
 OperatorResultType PipelineExecutor::ExecutePush(DataChunk &input) { // LCOV_EXCL_START
@@ -129434,7 +129918,7 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 		// wait for a signal with a timeout; the timeout allows us to periodically check
 		queue->semaphore.wait(TASK_TIMEOUT_USECS);
 		if (queue->q.try_dequeue(task)) {
-			task->Execute();
+			task->Execute(TaskExecutionMode::PROCESS_ALL);
 			task.reset();
 		}
 	}
@@ -129507,7 +129991,7 @@ void TaskScheduler::SetThreadsInternal(int32_t n) {
 
 namespace duckdb {
 
-ThreadContext::ThreadContext(ClientContext &context) : profiler(context.profiler->IsEnabled()) {
+ThreadContext::ThreadContext(ClientContext &context) : profiler(QueryProfiler::Get(context).IsEnabled()) {
 }
 
 } // namespace duckdb
@@ -154511,13 +154995,15 @@ Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context))
 }
 
 void Planner::CreatePlan(SQLStatement &statement) {
+	auto &profiler = QueryProfiler::Get(context);
+
 	vector<BoundParameterExpression *> bound_parameters;
 
 	// first bind the tables and columns to the catalog
-	context.profiler->StartPhase("binder");
+	profiler.StartPhase("binder");
 	binder->parameters = &bound_parameters;
 	auto bound_statement = binder->Bind(statement);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	this->read_only = binder->read_only;
 	this->requires_valid_transaction = binder->requires_valid_transaction;