duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/parallel/executor_task.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/parallel/task.hpp"
 #include "duckdb/execution/executor.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/parallel/thread_context.hpp"
 
 namespace duckdb {
 
@@ -9,11 +10,16 @@ ExecutorTask::ExecutorTask(Executor &executor_p, shared_ptr<Event> event_p)
 	executor.RegisterTask();
 }
 
-ExecutorTask::ExecutorTask(ClientContext &context, shared_ptr<Event> event_p)
-    : ExecutorTask(Executor::Get(context), std::move(event_p)) {
+ExecutorTask::ExecutorTask(ClientContext &context, shared_ptr<Event> event_p, const PhysicalOperator &op_p)
+    : executor(Executor::Get(context)), event(std::move(event_p)), op(&op_p) {
+	thread_context = make_uniq<ThreadContext>(context);
+	executor.RegisterTask();
 }
 
 ExecutorTask::~ExecutorTask() {
+	if (thread_context) {
+		executor.Flush(*thread_context);
+	}
 	executor.UnregisterTask();
 }
 
@@ -29,7 +35,14 @@ void ExecutorTask::Reschedule() {
 
 TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 	try {
-		return ExecuteTask(mode);
+		if (thread_context) {
+			thread_context->profiler.StartOperator(op);
+			auto result = ExecuteTask(mode);
+			thread_context->profiler.EndOperator(nullptr);
+			return result;
+		} else {
+			return ExecuteTask(mode);
+		}
 	} catch (std::exception &ex) {
 		executor.PushError(ErrorData(ex));
 	} catch (...) { // LCOV_EXCL_START

package/src/duckdb/src/parallel/meta_pipeline.cpp

@@ -4,8 +4,9 @@
 
 namespace duckdb {
 
-MetaPipeline::MetaPipeline(Executor &executor_p, PipelineBuildState &state_p, optional_ptr<PhysicalOperator> sink_p)
-    : executor(executor_p), state(state_p), sink(sink_p), recursive_cte(false), next_batch_index(0) {
+MetaPipeline::MetaPipeline(Executor &executor_p, PipelineBuildState &state_p, optional_ptr<PhysicalOperator> sink_p,
+                           MetaPipelineType type_p)
+    : executor(executor_p), state(state_p), sink(sink_p), type(type_p), recursive_cte(false), next_batch_index(0) {
 	CreatePipeline();
 }
 
@@ -21,6 +22,10 @@ optional_ptr<PhysicalOperator> MetaPipeline::GetSink() const {
 	return sink;
 }
 
+optional_ptr<Pipeline> MetaPipeline::GetParent() const {
+	return parent;
+}
+
 shared_ptr<Pipeline> &MetaPipeline::GetBasePipeline() {
 	return pipelines[0];
 }
@@ -38,20 +43,31 @@ void MetaPipeline::GetMetaPipelines(vector<shared_ptr<MetaPipeline>> &result, bo
 	if (!skip) {
 		result.push_back(shared_from_this());
 	}
-	if (recursive) {
-		for (auto &child : children) {
-			child->GetMetaPipelines(result, true, false);
+	for (auto &child : children) {
+		result.push_back(child);
+		if (recursive) {
+			child->GetMetaPipelines(result, true, true);
 		}
 	}
 }
 
-optional_ptr<const vector<reference<Pipeline>>> MetaPipeline::GetDependencies(Pipeline &dependant) const {
-	auto it = dependencies.find(dependant);
-	if (it == dependencies.end()) {
-		return nullptr;
-	} else {
-		return &it->second;
+MetaPipeline &MetaPipeline::GetLastChild() {
+	if (children.empty()) {
+		return *this;
+	}
+	reference<const vector<shared_ptr<MetaPipeline>>> current_children = children;
+	while (!current_children.get().back()->children.empty()) {
+		current_children = current_children.get().back()->children;
 	}
+	return *current_children.get().back();
+}
+
+const reference_map_t<Pipeline, vector<reference<Pipeline>>> &MetaPipeline::GetDependencies() const {
+	return pipeline_dependencies;
+}
+
+MetaPipelineType MetaPipeline::Type() const {
+	return type;
 }
 
 bool MetaPipeline::HasRecursiveCTE() const {
@@ -72,7 +88,7 @@ void MetaPipeline::Build(PhysicalOperator &op) {
 	op.BuildPipelines(*pipelines.back(), *this);
 }
 
-void MetaPipeline::Ready() {
+void MetaPipeline::Ready() const {
 	for (auto &pipeline : pipelines) {
 		pipeline->Ready();
 	}
@@ -81,14 +97,16 @@ void MetaPipeline::Ready() {
 	}
 }
 
-MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op) {
-	children.push_back(make_shared_ptr<MetaPipeline>(executor, state, &op));
-	auto child_meta_pipeline = children.back().get();
+MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op, MetaPipelineType type) {
+	children.push_back(make_shared_ptr<MetaPipeline>(executor, state, &op, type));
+	auto &child_meta_pipeline = *children.back().get();
+	// store the parent
+	child_meta_pipeline.parent = &current;
 	// child MetaPipeline must finish completely before this MetaPipeline can start
-	current.AddDependency(child_meta_pipeline->GetBasePipeline());
+	current.AddDependency(child_meta_pipeline.GetBasePipeline());
 	// child meta pipeline is part of the recursive CTE too
-	child_meta_pipeline->recursive_cte = recursive_cte;
-	return *child_meta_pipeline;
+	child_meta_pipeline.recursive_cte = recursive_cte;
+	return child_meta_pipeline;
 }
 
 Pipeline &MetaPipeline::CreatePipeline() {
@@ -97,7 +115,8 @@ Pipeline &MetaPipeline::CreatePipeline() {
 	return *pipelines.back();
 }
 
-void MetaPipeline::AddDependenciesFrom(Pipeline &dependant, Pipeline &start, bool including) {
+vector<shared_ptr<Pipeline>> MetaPipeline::AddDependenciesFrom(Pipeline &dependant, const Pipeline &start,
+                                                               const bool including) {
 	// find 'start'
 	auto it = pipelines.begin();
 	for (; !RefersToSameObject(**it, start); it++) {
@@ -108,18 +127,68 @@ void MetaPipeline::AddDependenciesFrom(Pipeline &dependant, Pipeline &start, boo
 	}
 
 	// collect pipelines that were created from then
-	vector<reference<Pipeline>> created_pipelines;
+	vector<shared_ptr<Pipeline>> created_pipelines;
 	for (; it != pipelines.end(); it++) {
 		if (RefersToSameObject(**it, dependant)) {
 			// cannot depend on itself
 			continue;
 		}
-		created_pipelines.push_back(**it);
+		created_pipelines.push_back(*it);
 	}
 
 	// add them to the dependencies
-	auto &deps = dependencies[dependant];
-	deps.insert(deps.begin(), created_pipelines.begin(), created_pipelines.end());
+	auto &explicit_deps = pipeline_dependencies[dependant];
+	for (auto &created_pipeline : created_pipelines) {
+		explicit_deps.push_back(*created_pipeline);
+	}
+
+	return created_pipelines;
+}
+
+static bool PipelineExceedsThreadCount(Pipeline &pipeline, const idx_t thread_count) {
+#ifdef DEBUG
+	// we always add the dependency in debug mode so that this is well-tested
+	return true;
+#else
+	return pipeline.GetSource()->EstimatedThreadCount() > thread_count;
+#endif
+}
+
+void MetaPipeline::AddRecursiveDependencies(const vector<shared_ptr<Pipeline>> &new_dependencies,
+                                            const MetaPipeline &last_child) {
+	if (recursive_cte) {
+		return; // let's not burn our fingers on this for now
+	}
+
+	vector<shared_ptr<MetaPipeline>> child_meta_pipelines;
+	this->GetMetaPipelines(child_meta_pipelines, true, false);
+
+	// find the meta pipeline that has the same sink as 'pipeline'
+	auto it = child_meta_pipelines.begin();
+	for (; !RefersToSameObject(last_child, **it); it++) {
+	}
+	D_ASSERT(it != child_meta_pipelines.end());
+
+	// skip over it
+	it++;
+
+	// we try to limit the performance impact of these dependencies on smaller workloads,
+	// by only adding the dependencies if the source operator can likely keep all threads busy
+	const auto thread_count = NumericCast<idx_t>(TaskScheduler::GetScheduler(executor.context).NumberOfThreads());
+	for (; it != child_meta_pipelines.end(); it++) {
+		for (auto &pipeline : it->get()->pipelines) {
+			if (!PipelineExceedsThreadCount(*pipeline, thread_count)) {
+				continue;
+			}
+			auto &pipeline_deps = pipeline_dependencies[*pipeline];
+			for (auto &new_dependency : new_dependencies) {
+				if (!PipelineExceedsThreadCount(*new_dependency, thread_count)) {
+					continue;
+				}
+				pipeline_deps.push_back(*new_dependency);
+			}
+		}
+	}
 }
 
 void MetaPipeline::AddFinishEvent(Pipeline &pipeline) {
@@ -153,14 +222,14 @@ Pipeline &MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matter
 
 	// 'union_pipeline' inherits ALL dependencies of 'current' (within this MetaPipeline, and across MetaPipelines)
 	union_pipeline.dependencies = current.dependencies;
-	auto current_deps = GetDependencies(current);
-	if (current_deps) {
-		dependencies[union_pipeline] = *current_deps;
+	auto it = pipeline_dependencies.find(current);
+	if (it != pipeline_dependencies.end()) {
+		pipeline_dependencies[union_pipeline] = it->second;
 	}
 
 	if (order_matters) {
 		// if we need to preserve order, or if the sink is not parallel, we set a dependency
-		dependencies[union_pipeline].push_back(current);
+		pipeline_dependencies[union_pipeline].push_back(current);
 	}
 
 	return union_pipeline;
@@ -177,9 +246,9 @@ void MetaPipeline::CreateChildPipeline(Pipeline &current, PhysicalOperator &op,
 
 	// child pipeline has a dependency (within this MetaPipeline on all pipelines that were scheduled
 	// between 'current' and now (including 'current') - set them up
-	dependencies[child_pipeline].push_back(current);
+	pipeline_dependencies[child_pipeline].push_back(current);
 	AddDependenciesFrom(child_pipeline, last_pipeline, false);
-	D_ASSERT(!GetDependencies(child_pipeline)->empty());
+	D_ASSERT(pipeline_dependencies.find(child_pipeline) != pipeline_dependencies.end());
 }
 
 } // namespace duckdb

package/src/duckdb/src/parallel/pipeline.cpp

@@ -2,7 +2,7 @@
 
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/common/tree_renderer/text_tree_renderer.hpp"
 #include "duckdb/execution/executor.hpp"
 #include "duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp"
 #include "duckdb/execution/operator/scan/physical_table_scan.hpp"
@@ -74,13 +74,14 @@ ClientContext &Pipeline::GetClientContext() {
 
 bool Pipeline::GetProgress(double &current_percentage, idx_t &source_cardinality) {
 	D_ASSERT(source);
-	source_cardinality = source->estimated_cardinality;
+	source_cardinality = MinValue<idx_t>(source->estimated_cardinality, 1ULL << 48ULL);
 	if (!initialized) {
 		current_percentage = 0;
 		return true;
 	}
 	auto &client = executor.context;
 	current_percentage = source->GetProgress(client, *source_state);
+	current_percentage = sink->GetSinkProgress(client, *sink->sink_state, current_percentage);
 	return current_percentage >= 0;
 }
 
@@ -192,6 +193,19 @@ void Pipeline::ResetSink() {
 	}
 }
 
+void Pipeline::PrepareFinalize() {
+	if (sink) {
+		if (!sink->IsSink()) {
+			throw InternalException("Sink of pipeline does not have IsSink set");
+		}
+		lock_guard<mutex> guard(sink->lock);
+		if (!sink->sink_state) {
+			throw InternalException("Sink of pipeline does not have sink state");
+		}
+		sink->PrepareFinalize(GetClientContext(), *sink->sink_state);
+	}
+}
+
 void Pipeline::Reset() {
 	ResetSink();
 	for (auto &op_ref : operators) {
@@ -231,7 +245,7 @@ void Pipeline::AddDependency(shared_ptr<Pipeline> &pipeline) {
 }
 
 string Pipeline::ToString() const {
-	TreeRenderer renderer;
+	TextTreeRenderer renderer;
 	return renderer.ToString(*this);
 }
 

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -1,10 +1,11 @@
 #include "duckdb/parallel/pipeline_executor.hpp"
-#include "duckdb/main/client_context.hpp"
+
 #include "duckdb/common/limits.hpp"
+#include "duckdb/main/client_context.hpp"
 
 #ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-#include <thread>
 #include <chrono>
+#include <thread>
 #endif
 
 namespace duckdb {
@@ -260,6 +261,17 @@ OperatorResultType PipelineExecutor::ExecutePush(DataChunk &input) { // LCOV_EXC
 void PipelineExecutor::FinishProcessing(int32_t operator_idx) {
 	finished_processing_idx = operator_idx < 0 ? NumericLimits<int32_t>::Maximum() : operator_idx;
 	in_process_operators = stack<idx_t>();
+
+	if (pipeline.GetSource()) {
+		auto guard = pipeline.source_state->Lock();
+		pipeline.source_state->PreventBlocking(guard);
+		pipeline.source_state->UnblockTasks(guard);
+	}
+	if (pipeline.GetSink()) {
+		auto guard = pipeline.GetSink()->sink_state->Lock();
+		pipeline.GetSink()->sink_state->PreventBlocking(guard);
+		pipeline.GetSink()->sink_state->UnblockTasks(guard);
+	}
 }
 
 bool PipelineExecutor::IsFinished() {

package/src/duckdb/src/parallel/pipeline_prepare_finish_event.cpp

@@ -0,0 +1,34 @@
+#include "duckdb/parallel/pipeline_prepare_finish_event.hpp"
+
+namespace duckdb {
+
+PipelinePrepareFinishEvent::PipelinePrepareFinishEvent(shared_ptr<Pipeline> pipeline_p)
+    : BasePipelineEvent(std::move(pipeline_p)) {
+}
+
+class PipelinePreFinishTask : public ExecutorTask {
+public:
+	explicit PipelinePreFinishTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
+	    : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) {
+	}
+
+	Pipeline &pipeline;
+
+public:
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		pipeline.PrepareFinalize();
+		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
+	}
+};
+
+void PipelinePrepareFinishEvent::Schedule() {
+	vector<shared_ptr<Task>> tasks;
+	tasks.push_back(make_uniq<PipelinePreFinishTask>(*pipeline, shared_from_this()));
+	SetTasks(std::move(tasks));
+}
+
+void PipelinePrepareFinishEvent::FinishEvent() {
+}
+
+} // namespace duckdb

package/src/duckdb/src/parallel/task_executor.cpp

@@ -0,0 +1,84 @@
+#include "duckdb/parallel/task_executor.hpp"
+#include "duckdb/parallel/task_scheduler.hpp"
+
+namespace duckdb {
+
+TaskExecutor::TaskExecutor(TaskScheduler &scheduler)
+    : scheduler(scheduler), token(scheduler.CreateProducer()), completed_tasks(0), total_tasks(0) {
+}
+
+TaskExecutor::TaskExecutor(ClientContext &context) : TaskExecutor(TaskScheduler::GetScheduler(context)) {
+}
+
+TaskExecutor::~TaskExecutor() {
+}
+
+void TaskExecutor::PushError(ErrorData error) {
+	error_manager.PushError(std::move(error));
+}
+
+bool TaskExecutor::HasError() {
+	return error_manager.HasError();
+}
+
+void TaskExecutor::ThrowError() {
+	error_manager.ThrowException();
+}
+
+void TaskExecutor::ScheduleTask(unique_ptr<Task> task) {
+	++total_tasks;
+	scheduler.ScheduleTask(*token, std::move(task));
+}
+void TaskExecutor::FinishTask() {
+	++completed_tasks;
+}
+
+void TaskExecutor::WorkOnTasks() {
+	// repeatedly execute tasks until we are finished
+	shared_ptr<Task> task_from_producer;
+	while (scheduler.GetTaskFromProducer(*token, task_from_producer)) {
+		auto res = task_from_producer->Execute(TaskExecutionMode::PROCESS_ALL);
+		(void)res;
+		D_ASSERT(res != TaskExecutionResult::TASK_BLOCKED);
+		task_from_producer.reset();
+	}
+	// wait for all active tasks to finish
+	while (completed_tasks != total_tasks) {
+	}
+
+	// check if we ran into any errors while checkpointing
+	if (HasError()) {
+		// throw the error
+		ThrowError();
+	}
+}
+
+bool TaskExecutor::GetTask(shared_ptr<Task> &task) {
+	return scheduler.GetTaskFromProducer(*token, task);
+}
+
+BaseExecutorTask::BaseExecutorTask(TaskExecutor &executor) : executor(executor) {
+}
+
+TaskExecutionResult BaseExecutorTask::Execute(TaskExecutionMode mode) {
+	(void)mode;
+	D_ASSERT(mode == TaskExecutionMode::PROCESS_ALL);
+	if (executor.HasError()) {
+		// another task encountered an error - bailout
+		executor.FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
+	}
+	try {
+		ExecuteTask();
+		executor.FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
+	} catch (std::exception &ex) {
+		executor.PushError(ErrorData(ex));
+	} catch (...) { // LCOV_EXCL_START
+		executor.PushError(ErrorData("Unknown exception during Checkpoint!"));
+	} // LCOV_EXCL_STOP
+	executor.FinishTask();
+	return TaskExecutionResult::TASK_ERROR;
+}
+
+} // namespace duckdb

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -16,6 +16,13 @@
 #include <queue>
 #endif
 
+#if defined(_WIN32)
+#include <windows.h>
+#elif defined(__GNUC__)
+#include <sched.h>
+#include <unistd.h>
+#endif
+
 namespace duckdb {
 
 struct SchedulerThread {
@@ -23,10 +30,6 @@ struct SchedulerThread {
 	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(std::move(thread_p)) {
 	}
 
-	~SchedulerThread() {
-		Allocator::ThreadFlush(0);
-	}
-
 	unique_ptr<thread> internal_thread;
 #endif
 };
@@ -66,7 +69,7 @@ bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task>
 
 #else
 struct ConcurrentQueue {
-	std::queue<shared_ptr<Task>> q;
+	reference_map_t<QueueProducerToken, std::queue<shared_ptr<Task>>> q;
 	mutex qlock;
 
 	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
@@ -75,22 +78,35 @@ struct ConcurrentQueue {
 
 void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
 	lock_guard<mutex> lock(qlock);
-	q.push(std::move(task));
+	q[std::ref(*token.token)].push(std::move(task));
 }
 
 bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	lock_guard<mutex> lock(qlock);
-	if (q.empty()) {
+	D_ASSERT(!q.empty());
+
+	const auto it = q.find(std::ref(*token.token));
+	if (it == q.end() || it->second.empty()) {
 		return false;
 	}
-	task = std::move(q.front());
-	q.pop();
+
+	task = std::move(it->second.front());
+	it->second.pop();
+
 	return true;
 }
 
 struct QueueProducerToken {
-	QueueProducerToken(ConcurrentQueue &queue) {
+	explicit QueueProducerToken(ConcurrentQueue &queue) : queue(&queue) {
 	}
+
+	~QueueProducerToken() {
+		lock_guard<mutex> lock(queue->qlock);
+		queue->q.erase(*this);
+	}
+
+private:
+	ConcurrentQueue *queue;
 };
 #endif
 
@@ -103,8 +119,10 @@ ProducerToken::~ProducerToken() {
 
 TaskScheduler::TaskScheduler(DatabaseInstance &db)
     : db(db), queue(make_uniq<ConcurrentQueue>()),
-      allocator_flush_threshold(db.config.options.allocator_flush_threshold), requested_thread_count(0),
+      allocator_flush_threshold(db.config.options.allocator_flush_threshold),
+      allocator_background_threads(db.config.options.allocator_background_threads), requested_thread_count(0),
       current_thread_count(1) {
+	SetAllocatorBackgroundThreads(db.config.options.allocator_background_threads);
 }
 
 TaskScheduler::~TaskScheduler() {
@@ -141,11 +159,32 @@ bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &
 
 void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 #ifndef DUCKDB_NO_THREADS
+	static constexpr const int64_t INITIAL_FLUSH_WAIT = 500000; // initial wait time of 0.5s (in mus) before flushing
+
 	shared_ptr<Task> task;
 	// loop until the marker is set to false
 	while (*marker) {
-		// wait for a signal with a timeout
-		queue->semaphore.wait();
+		if (!Allocator::SupportsFlush()) {
+			// allocator can't flush, just start an untimed wait
+			queue->semaphore.wait();
+		} else if (!queue->semaphore.wait(INITIAL_FLUSH_WAIT)) {
+			// allocator can flush, we flush this threads outstanding allocations after it was idle for 0.5s
+			Allocator::ThreadFlush(allocator_background_threads, allocator_flush_threshold,
+			                       NumericCast<idx_t>(requested_thread_count.load()));
+			auto decay_delay = Allocator::DecayDelay();
+			if (!decay_delay.IsValid()) {
+				// no decay delay specified - just wait
+				queue->semaphore.wait();
+			} else {
+				if (!queue->semaphore.wait(UnsafeNumericCast<int64_t>(decay_delay.GetIndex()) * 1000000 -
+				                           INITIAL_FLUSH_WAIT)) {
+					// in total, the thread was idle for the entire decay delay (note: seconds converted to mus)
+					// mark it as idle and start an untimed wait
+					Allocator::ThreadIdle();
+					queue->semaphore.wait();
+				}
+			}
+		}
 		if (queue->q.try_dequeue(task)) {
 			auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
 
@@ -161,11 +200,13 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 				task.reset();
 				break;
 			}
-
-			// Flushes the outstanding allocator's outstanding allocations
-			Allocator::ThreadFlush(allocator_flush_threshold);
 		}
 	}
+	// this thread will exit, flush all of its outstanding allocations
+	if (Allocator::SupportsFlush()) {
+		Allocator::ThreadFlush(allocator_background_threads, 0, NumericCast<idx_t>(requested_thread_count.load()));
+		Allocator::ThreadIdle();
+	}
 #else
 	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
 #endif
@@ -261,6 +302,12 @@ void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) {
 }
 
 void TaskScheduler::SetAllocatorFlushTreshold(idx_t threshold) {
+	allocator_flush_threshold = threshold;
+}
+
+void TaskScheduler::SetAllocatorBackgroundThreads(bool enable) {
+	allocator_background_threads = enable;
+	Allocator::SetBackgroundThreads(enable);
 }
 
 void TaskScheduler::Signal(idx_t n) {
@@ -276,6 +323,34 @@ void TaskScheduler::YieldThread() {
 #endif
 }
 
+idx_t TaskScheduler::GetEstimatedCPUId() {
+#if defined(EMSCRIPTEN)
+	// FIXME: Wasm + multithreads can likely be implemented as
+	//   return return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
+	return 0;
+#else
+	// this code comes from jemalloc
+#if defined(_WIN32)
+	return (idx_t)GetCurrentProcessorNumber();
+#elif defined(_GNU_SOURCE)
+	auto cpu = sched_getcpu();
+	if (cpu < 0) {
+		// fallback to thread id
+		return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
+	}
+	return (idx_t)cpu;
+#elif defined(__aarch64__) && defined(__APPLE__)
+	/* Other oses most likely use tpidr_el0 instead */
+	uintptr_t c;
+	asm volatile("mrs %x0, tpidrro_el0" : "=r"(c)::"memory");
+	return (idx_t)(c & (1 << 3) - 1);
+#else
+	// fallback to thread id
+	return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
+#endif
+#endif
+}
+
 void TaskScheduler::RelaunchThreads() {
 	lock_guard<mutex> t(thread_lock);
 	auto n = requested_thread_count.load();
@@ -325,6 +400,9 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
 		}
 	}
 	current_thread_count = NumericCast<int32_t>(threads.size() + config.options.external_threads);
+	if (Allocator::SupportsFlush()) {
+		Allocator::FlushAll();
+	}
 #endif
 }
 

package/src/duckdb/src/parallel/thread_context.cpp

@@ -4,7 +4,7 @@
 
 namespace duckdb {
 
-ThreadContext::ThreadContext(ClientContext &context) : profiler(QueryProfiler::Get(context).IsEnabled()) {
+ThreadContext::ThreadContext(ClientContext &context) : profiler(context) {
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -95,4 +95,18 @@ void FunctionExpression::Verify() const {
 	D_ASSERT(!function_name.empty());
 }
 
+bool FunctionExpression::IsLambdaFunction() const {
+	// Ignore the ->> operator (JSON extension).
+	if (function_name == "->>") {
+		return false;
+	}
+	// Check the children for lambda expressions.
+	for (auto &child : children) {
+		if (child->expression_class == ExpressionClass::LAMBDA) {
+			return true;
+		}
+	}
+	return false;
+}
+
 } // namespace duckdb