duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

package/src/duckdb/src/execution/operator/set/physical_cte.cpp

@@ -0,0 +1,160 @@
+#include "duckdb/execution/operator/set/physical_cte.hpp"
+
+#include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/execution/aggregate_hashtable.hpp"
+#include "duckdb/execution/executor.hpp"
+#include "duckdb/parallel/event.hpp"
+#include "duckdb/parallel/meta_pipeline.hpp"
+#include "duckdb/parallel/pipeline.hpp"
+#include "duckdb/parallel/task_scheduler.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+PhysicalCTE::PhysicalCTE(string ctename, idx_t table_index, vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
+                         unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
+    : PhysicalOperator(PhysicalOperatorType::CTE, std::move(types), estimated_cardinality), table_index(table_index),
+      ctename(std::move(ctename)) {
+	children.push_back(std::move(top));
+	children.push_back(std::move(bottom));
+}
+
+PhysicalCTE::~PhysicalCTE() {
+}
+
+//===--------------------------------------------------------------------===//
+// Sink
+//===--------------------------------------------------------------------===//
+class CTEState : public GlobalSinkState {
+public:
+	explicit CTEState(ClientContext &context, const PhysicalCTE &op)
+	    : intermediate_table(context, op.children[1]->GetTypes()) {
+	}
+	ColumnDataCollection intermediate_table;
+	ColumnDataScanState scan_state;
+	bool initialized = false;
+	bool finished_scan = false;
+};
+
+unique_ptr<GlobalSinkState> PhysicalCTE::GetGlobalSinkState(ClientContext &context) const {
+	working_table->Reset();
+	return make_uniq<CTEState>(context, *this);
+}
+
+SinkResultType PhysicalCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	auto &gstate = input.global_state.Cast<CTEState>();
+	if (!gstate.finished_scan) {
+		working_table->Append(chunk);
+	} else {
+		gstate.intermediate_table.Append(chunk);
+	}
+	return SinkResultType::NEED_MORE_INPUT;
+}
+
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
+SourceResultType PhysicalCTE::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &gstate = sink_state->Cast<CTEState>();
+	if (!gstate.initialized) {
+		gstate.intermediate_table.InitializeScan(gstate.scan_state);
+		gstate.finished_scan = false;
+		gstate.initialized = true;
+	}
+	if (!gstate.finished_scan) {
+		gstate.finished_scan = true;
+		ExecuteRecursivePipelines(context);
+	}
+
+	gstate.intermediate_table.Scan(gstate.scan_state, chunk);
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
+}
+
+void PhysicalCTE::ExecuteRecursivePipelines(ExecutionContext &context) const {
+	if (!recursive_meta_pipeline) {
+		throw InternalException("Missing meta pipeline for recursive CTE");
+	}
+
+	// get and reset pipelines
+	vector<shared_ptr<Pipeline>> pipelines;
+	recursive_meta_pipeline->GetPipelines(pipelines, true);
+	for (auto &pipeline : pipelines) {
+		auto sink = pipeline->GetSink();
+		if (sink.get() != this) {
+			sink->sink_state.reset();
+		}
+		for (auto &op_ref : pipeline->GetOperators()) {
+			auto &op = op_ref.get();
+			op.op_state.reset();
+		}
+		pipeline->ClearSource();
+	}
+
+	// get the MetaPipelines in the recursive_meta_pipeline and reschedule them
+	vector<shared_ptr<MetaPipeline>> meta_pipelines;
+	recursive_meta_pipeline->GetMetaPipelines(meta_pipelines, true, false);
+	auto &executor = recursive_meta_pipeline->GetExecutor();
+	vector<shared_ptr<Event>> events;
+	executor.ReschedulePipelines(meta_pipelines, events);
+
+	while (true) {
+		executor.WorkOnTasks();
+		if (executor.HasError()) {
+			executor.ThrowException();
+		}
+		bool finished = true;
+		for (auto &event : events) {
+			if (!event->IsFinished()) {
+				finished = false;
+				break;
+			}
+		}
+		if (finished) {
+			// all pipelines finished: done!
+			break;
+		}
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Pipeline Construction
+//===--------------------------------------------------------------------===//
+void PhysicalCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
+	D_ASSERT(children.size() == 2);
+	op_state.reset();
+	sink_state.reset();
+	recursive_meta_pipeline.reset();
+
+	auto &state = meta_pipeline.GetState();
+	state.SetPipelineSource(current, *this);
+
+	auto &executor = meta_pipeline.GetExecutor();
+	executor.AddMaterializedCTE(*this);
+
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	child_meta_pipeline.Build(*children[0]);
+
+	// the RHS is the recursive pipeline
+	recursive_meta_pipeline = make_shared<MetaPipeline>(executor, state, this);
+	if (meta_pipeline.HasRecursiveCTE()) {
+		recursive_meta_pipeline->SetRecursiveCTE();
+	}
+	recursive_meta_pipeline->Build(*children[1]);
+}
+
+vector<const_reference<PhysicalOperator>> PhysicalCTE::GetSources() const {
+	return {*this};
+}
+
+string PhysicalCTE::ParamsToString() const {
+	string result = "";
+	result += "\n[INFOSEPARATOR]\n";
+	result += ctename;
+	result += "\n[INFOSEPARATOR]\n";
+	result += StringUtil::Format("idx: %llu", table_index);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp

@@ -12,10 +12,11 @@
 
 namespace duckdb {
 
-PhysicalRecursiveCTE::PhysicalRecursiveCTE(vector<LogicalType> types, bool union_all, unique_ptr<PhysicalOperator> top,
-                                           unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
+PhysicalRecursiveCTE::PhysicalRecursiveCTE(string ctename, idx_t table_index, vector<LogicalType> types, bool union_all,
+                                           unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
+                                           idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::RECURSIVE_CTE, std::move(types), estimated_cardinality),
-      union_all(union_all) {
+      ctename(std::move(ctename)), table_index(table_index), union_all(union_all) {
 	children.push_back(std::move(top));
 	children.push_back(std::move(bottom));
 }
@@ -30,8 +31,8 @@ class RecursiveCTEState : public GlobalSinkState {
 public:
 	explicit RecursiveCTEState(ClientContext &context, const PhysicalRecursiveCTE &op)
 	    : intermediate_table(context, op.GetTypes()), new_groups(STANDARD_VECTOR_SIZE) {
-		ht = make_uniq<GroupedAggregateHashTable>(context, Allocator::Get(context), op.types, vector<LogicalType>(),
-		                                          vector<BoundAggregateExpression *>());
+		ht = make_uniq<GroupedAggregateHashTable>(context, BufferAllocator::Get(context), op.types,
+		                                          vector<LogicalType>(), vector<BoundAggregateExpression *>());
 	}
 
 	unique_ptr<GroupedAggregateHashTable> ht;
@@ -195,4 +196,13 @@ vector<const_reference<PhysicalOperator>> PhysicalRecursiveCTE::GetSources() con
 	return {*this};
 }
 
+string PhysicalRecursiveCTE::ParamsToString() const {
+	string result = "";
+	result += "\n[INFOSEPARATOR]\n";
+	result += ctename;
+	result += "\n[INFOSEPARATOR]\n";
+	result += StringUtil::Format("idx: %llu", table_index);
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/partitionable_hashtable.cpp

@@ -9,10 +9,10 @@ RadixPartitionInfo::RadixPartitionInfo(const idx_t n_partitions_upper_bound)
       radix_bits(RadixPartitioning::RadixBits(n_partitions)), radix_mask(RadixPartitioning::Mask(radix_bits)),
       radix_shift(RadixPartitioning::Shift(radix_bits)) {
 
+	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
 	D_ASSERT(n_partitions > 0);
-	D_ASSERT(n_partitions <= 256);
+	D_ASSERT(n_partitions == RadixPartitioning::NumberOfPartitions(radix_bits));
 	D_ASSERT(IsPowerOfTwo(n_partitions));
-	D_ASSERT(radix_bits <= 8);
 }
 
 PartitionableHashTable::PartitionableHashTable(ClientContext &context, Allocator &allocator,
@@ -47,11 +47,21 @@ HtEntryType PartitionableHashTable::GetHTEntrySize() {
 	return HtEntryType::HT_WIDTH_32;
 }
 
+bool OverMemoryLimit(ClientContext &context, const bool is_partitioned, const RadixPartitionInfo &partition_info,
+                     const GroupedAggregateHashTable &ht) {
+	const auto n_partitions = is_partitioned ? partition_info.n_partitions : 1;
+	const auto max_memory = BufferManager::GetBufferManager(context).GetMaxMemory();
+	const auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+	const auto memory_per_partition = 0.6 * max_memory / num_threads / n_partitions;
+	return ht.TotalSize() > memory_per_partition;
+}
+
 idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes,
                                            DataChunk &payload, const unsafe_vector<idx_t> &filter) {
 	// If this is false, a single AddChunk would overflow the max capacity
 	D_ASSERT(list.empty() || groups.size() <= list.back()->MaxCapacity());
-	if (list.empty() || list.back()->Count() + groups.size() >= list.back()->MaxCapacity()) {
+	if (list.empty() || list.back()->Count() + groups.size() >= list.back()->MaxCapacity() ||
+	    OverMemoryLimit(context, is_partitioned, partition_info, *list.back())) {
 		idx_t new_capacity = GroupedAggregateHashTable::InitialCapacity();
 		if (!list.empty()) {
 			new_capacity = list.back()->Capacity();
@@ -70,7 +80,7 @@ idx_t PartitionableHashTable::AddChunk(DataChunk &groups, DataChunk &payload, bo
 
 	// we partition when we are asked to or when the unpartitioned ht runs out of space
 	if (!IsPartitioned() && do_partition) {
-		Partition();
+		Partition(false);
 	}
 
 	if (!IsPartitioned()) {
@@ -117,7 +127,7 @@ idx_t PartitionableHashTable::AddChunk(DataChunk &groups, DataChunk &payload, bo
 	return group_count;
 }
 
-void PartitionableHashTable::Partition() {
+void PartitionableHashTable::Partition(bool sink_done) {
 	D_ASSERT(!IsPartitioned());
 	D_ASSERT(radix_partitioned_hts.empty());
 	D_ASSERT(partition_info.n_partitions > 1);
@@ -130,7 +140,7 @@ void PartitionableHashTable::Partition() {
 			    context, allocator, group_types, payload_types, bindings, GetHTEntrySize()));
 			partition_hts[r] = radix_partitioned_hts[r].back().get();
 		}
-		unpartitioned_ht->Partition(partition_hts, partition_info.radix_bits);
+		unpartitioned_ht->Partition(partition_hts, partition_info.radix_bits, sink_done);
 		unpartitioned_ht.reset();
 	}
 	unpartitioned_hts.clear();
@@ -153,6 +163,22 @@ HashTableList PartitionableHashTable::GetUnpartitioned() {
 	return std::move(unpartitioned_hts);
 }
 
+idx_t PartitionableHashTable::GetPartitionCount(idx_t partition) const {
+	idx_t total_size = 0;
+	for (const auto &ht : radix_partitioned_hts[partition]) {
+		total_size += ht->Count();
+	}
+	return total_size;
+}
+
+idx_t PartitionableHashTable::GetPartitionSize(idx_t partition) const {
+	idx_t total_size = 0;
+	for (const auto &ht : radix_partitioned_hts[partition]) {
+		total_size += ht->DataSize();
+	}
+	return total_size;
+}
+
 void PartitionableHashTable::Finalize() {
 	if (IsPartitioned()) {
 		for (auto &ht_list : radix_partitioned_hts) {
@@ -169,4 +195,13 @@ void PartitionableHashTable::Finalize() {
 	}
 }
 
+void PartitionableHashTable::Append(GroupedAggregateHashTable &ht) {
+	if (unpartitioned_hts.empty()) {
+		unpartitioned_hts.push_back(make_uniq<GroupedAggregateHashTable>(context, allocator, group_types, payload_types,
+		                                                                 bindings, GetHTEntrySize(),
+		                                                                 GroupedAggregateHashTable::InitialCapacity()));
+	}
+	unpartitioned_hts.back()->Append(ht);
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/execution/perfect_aggregate_hashtable.hpp"
-#include "duckdb/execution/expression_executor.hpp"
+
 #include "duckdb/common/row_operations/row_operations.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
@@ -93,6 +94,18 @@ static void ComputeGroupLocation(Vector &group, Value &min, uintptr_t *address_d
 	case PhysicalType::INT64:
 		ComputeGroupLocationTemplated<int64_t>(vdata, min, address_data, current_shift, count);
 		break;
+	case PhysicalType::UINT8:
+		ComputeGroupLocationTemplated<uint8_t>(vdata, min, address_data, current_shift, count);
+		break;
+	case PhysicalType::UINT16:
+		ComputeGroupLocationTemplated<uint16_t>(vdata, min, address_data, current_shift, count);
+		break;
+	case PhysicalType::UINT32:
+		ComputeGroupLocationTemplated<uint32_t>(vdata, min, address_data, current_shift, count);
+		break;
+	case PhysicalType::UINT64:
+		ComputeGroupLocationTemplated<uint64_t>(vdata, min, address_data, current_shift, count);
+		break;
 	default:
 		throw InternalException("Unsupported group type for perfect aggregate hash table");
 	}
@@ -123,7 +136,7 @@ void PerfectAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload)
 	// after finding the group location we update the aggregates
 	idx_t payload_idx = 0;
 	auto &aggregates = layout.GetAggregates();
-	RowOperationsState row_state(aggregate_allocator.GetAllocator());
+	RowOperationsState row_state(aggregate_allocator);
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
 		auto &aggregate = aggregates[aggr_idx];
 		auto input_count = (idx_t)aggregate.child_count;
@@ -152,7 +165,7 @@ void PerfectAggregateHashTable::Combine(PerfectAggregateHashTable &other) {
 	data_ptr_t source_ptr = other.data;
 	data_ptr_t target_ptr = data;
 	idx_t combine_count = 0;
-	RowOperationsState row_state(aggregate_allocator.GetAllocator());
+	RowOperationsState row_state(aggregate_allocator);
 	for (idx_t i = 0; i < total_groups; i++) {
 		auto has_entry_source = other.group_is_set[i];
 		// we only have any work to do if the source has an entry for this group
@@ -208,6 +221,18 @@ static void ReconstructGroupVector(uint32_t group_values[], Value &min, idx_t re
 	case PhysicalType::INT64:
 		ReconstructGroupVectorTemplated<int64_t>(group_values, min, mask, shift, entry_count, result);
 		break;
+	case PhysicalType::UINT8:
+		ReconstructGroupVectorTemplated<uint8_t>(group_values, min, mask, shift, entry_count, result);
+		break;
+	case PhysicalType::UINT16:
+		ReconstructGroupVectorTemplated<uint16_t>(group_values, min, mask, shift, entry_count, result);
+		break;
+	case PhysicalType::UINT32:
+		ReconstructGroupVectorTemplated<uint32_t>(group_values, min, mask, shift, entry_count, result);
+		break;
+	case PhysicalType::UINT64:
+		ReconstructGroupVectorTemplated<uint64_t>(group_values, min, mask, shift, entry_count, result);
+		break;
 	default:
 		throw InternalException("Invalid type for perfect aggregate HT group");
 	}
@@ -243,7 +268,7 @@ void PerfectAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
 	}
 	// then construct the payloads
 	result.SetCardinality(entry_count);
-	RowOperationsState row_state(aggregate_allocator.GetAllocator());
+	RowOperationsState row_state(aggregate_allocator);
 	RowOperations::FinalizeStates(row_state, layout, addresses, result, grouping_columns);
 }
 
@@ -264,7 +289,7 @@ void PerfectAggregateHashTable::Destroy() {
 	idx_t count = 0;
 
 	// iterate over all initialised slots of the hash table
-	RowOperationsState row_state(aggregate_allocator.GetAllocator());
+	RowOperationsState row_state(aggregate_allocator);
 	data_ptr_t payload_ptr = data;
 	for (idx_t i = 0; i < total_groups; i++) {
 		if (group_is_set[i]) {

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -5,12 +5,12 @@
 #include "duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp"
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/function/function_binder.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/function/function_binder.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/operator/logical_aggregate.hpp"
 
 namespace duckdb {
 
@@ -23,6 +23,11 @@ static uint32_t RequiredBitsForValue(uint32_t n) {
 	return required_bits;
 }
 
+template <class T>
+hugeint_t GetRangeHugeint(const BaseStatistics &nstats) {
+	return Hugeint::Convert(NumericStats::GetMax<T>(nstats)) - Hugeint::Convert(NumericStats::GetMin<T>(nstats));
+}
+
 static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate &op, vector<idx_t> &bits_per_group) {
 	if (op.grouping_sets.size() > 1 || !op.grouping_functions.empty()) {
 		return false;
@@ -40,6 +45,10 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		case PhysicalType::INT16:
 		case PhysicalType::INT32:
 		case PhysicalType::INT64:
+		case PhysicalType::UINT8:
+		case PhysicalType::UINT16:
+		case PhysicalType::UINT32:
+		case PhysicalType::UINT64:
 			break;
 		default:
 			// we only support simple integer types for perfect hashing
@@ -53,6 +62,8 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 			switch (group_type.InternalType()) {
 			case PhysicalType::INT8:
 			case PhysicalType::INT16:
+			case PhysicalType::UINT8:
+			case PhysicalType::UINT16:
 				break;
 			default:
 				// type is too large and there are no stats: skip perfect hashing
@@ -68,33 +79,55 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		if (!NumericStats::HasMinMax(nstats)) {
 			return false;
 		}
+
+		if (NumericStats::Max(*stats) < NumericStats::Min(*stats)) {
+			// May result in underflow
+			return false;
+		}
+
 		// we have a min and a max value for the stats: use that to figure out how many bits we have
 		// we add two here, one for the NULL value, and one to make the computation one-indexed
 		// (e.g. if min and max are the same, we still need one entry in total)
-		int64_t range;
+		hugeint_t range_h;
 		switch (group_type.InternalType()) {
 		case PhysicalType::INT8:
-			range = int64_t(NumericStats::GetMax<int8_t>(nstats)) - int64_t(NumericStats::GetMin<int8_t>(nstats));
+			range_h = GetRangeHugeint<int8_t>(nstats);
 			break;
 		case PhysicalType::INT16:
-			range = int64_t(NumericStats::GetMax<int16_t>(nstats)) - int64_t(NumericStats::GetMin<int16_t>(nstats));
+			range_h = GetRangeHugeint<int16_t>(nstats);
 			break;
 		case PhysicalType::INT32:
-			range = int64_t(NumericStats::GetMax<int32_t>(nstats)) - int64_t(NumericStats::GetMin<int32_t>(nstats));
+			range_h = GetRangeHugeint<int32_t>(nstats);
 			break;
 		case PhysicalType::INT64:
-			if (!TrySubtractOperator::Operation(NumericStats::GetMax<int64_t>(nstats),
-			                                    NumericStats::GetMin<int64_t>(nstats), range)) {
-				return false;
-			}
+			range_h = GetRangeHugeint<int64_t>(nstats);
+			break;
+		case PhysicalType::UINT8:
+			range_h = GetRangeHugeint<uint8_t>(nstats);
+			break;
+		case PhysicalType::UINT16:
+			range_h = GetRangeHugeint<uint16_t>(nstats);
+			break;
+		case PhysicalType::UINT32:
+			range_h = GetRangeHugeint<uint32_t>(nstats);
+			break;
+		case PhysicalType::UINT64:
+			range_h = GetRangeHugeint<uint64_t>(nstats);
 			break;
 		default:
 			throw InternalException("Unsupported type for perfect hash (should be caught before)");
 		}
+
+		uint64_t range;
+		if (!Hugeint::TryCast(range_h, range)) {
+			return false;
+		}
+
 		// bail out on any range bigger than 2^32
 		if (range >= NumericLimits<int32_t>::Maximum()) {
 			return false;
 		}
+
 		range += 2;
 		// figure out how many bits we need
 		idx_t required_bits = RequiredBitsForValue(range);

package/src/duckdb/src/execution/physical_plan/plan_cte.cpp

@@ -0,0 +1,33 @@
+#include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
+#include "duckdb/execution/operator/set/physical_cte.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/operator/logical_cteref.hpp"
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalMaterializedCTE &op) {
+	D_ASSERT(op.children.size() == 2);
+
+	// Create the working_table that the PhysicalCTE will use for evaluation.
+	auto working_table = std::make_shared<ColumnDataCollection>(context, op.children[0]->types);
+
+	// Add the ColumnDataCollection to the context of this PhysicalPlanGenerator
+	recursive_cte_tables[op.table_index] = working_table;
+
+	// Create the plan for the left side. This is the materialization.
+	auto left = CreatePlan(*op.children[0]);
+	// Initialize an empty vector to collect the scan operators.
+	materialized_ctes.insert(op.table_index);
+	auto right = CreatePlan(*op.children[1]);
+
+	auto cte = make_uniq<PhysicalCTE>(op.ctename, op.table_index, op.children[1]->types, std::move(left),
+	                                  std::move(right), op.estimated_cardinality);
+	cte->working_table = working_table;
+
+	return std::move(cte);
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_get.cpp

@@ -55,7 +55,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 		// function does not support projection pushdown
 		auto node = make_uniq<PhysicalTableScan>(op.returned_types, op.function, std::move(op.bind_data),
 		                                         op.returned_types, op.column_ids, vector<column_t>(), op.names,
-		                                         std::move(table_filters), op.estimated_cardinality);
+		                                         std::move(table_filters), op.estimated_cardinality, op.extra_info);
 		// first check if an additional projection is necessary
 		if (op.column_ids.size() == op.returned_types.size()) {
 			bool projection_necessary = false;
@@ -93,7 +93,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 	} else {
 		return make_uniq<PhysicalTableScan>(op.types, op.function, std::move(op.bind_data), op.returned_types,
 		                                    op.column_ids, op.projection_ids, op.names, std::move(table_filters),
-		                                    op.estimated_cardinality);
+		                                    op.estimated_cardinality, op.extra_info);
 	}
 }
 

package/src/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp

@@ -20,8 +20,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalRecursiveC
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
 
-	auto cte = make_uniq<PhysicalRecursiveCTE>(op.types, op.union_all, std::move(left), std::move(right),
-	                                           op.estimated_cardinality);
+	auto cte = make_uniq<PhysicalRecursiveCTE>(op.ctename, op.table_index, op.types, op.union_all, std::move(left),
+	                                           std::move(right), op.estimated_cardinality);
 	cte->working_table = working_table;
 
 	return std::move(cte);
@@ -30,14 +30,35 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalRecursiveC
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op) {
 	D_ASSERT(op.children.empty());
 
-	auto chunk_scan =
-	    make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::RECURSIVE_CTE_SCAN, op.estimated_cardinality);
+	// Check if this LogicalCTERef is supposed to scan a materialized CTE.
+	if (op.materialized_cte == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+		// Lookup if there is a materialized CTE for the cte_index.
+		auto materialized_cte = materialized_ctes.find(op.cte_index);
+
+		// If this check fails, this is a reference to a materialized recursive CTE.
+		if (materialized_cte != materialized_ctes.end()) {
+			auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::CTE_SCAN,
+			                                                    op.estimated_cardinality, op.cte_index);
+
+			auto cte = recursive_cte_tables.find(op.cte_index);
+			if (cte == recursive_cte_tables.end()) {
+				throw InvalidInputException("Referenced materialized CTE does not exist.");
+			}
+			chunk_scan->collection = cte->second.get();
+
+			return std::move(chunk_scan);
+		}
+	}
 
 	// CreatePlan of a LogicalRecursiveCTE must have happened before.
 	auto cte = recursive_cte_tables.find(op.cte_index);
 	if (cte == recursive_cte_tables.end()) {
 		throw InvalidInputException("Referenced recursive CTE does not exist.");
 	}
+
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(
+	    cte->second.get()->Types(), PhysicalOperatorType::RECURSIVE_CTE_SCAN, op.estimated_cardinality, op.cte_index);
+
 	chunk_scan->collection = cte->second.get();
 	return std::move(chunk_scan);
 }

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -194,6 +194,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
 		plan = CreatePlan(op.Cast<LogicalRecursiveCTE>());
 		break;
+	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
+		plan = CreatePlan(op.Cast<LogicalMaterializedCTE>());
+		break;
 	case LogicalOperatorType::LOGICAL_CTE_REF:
 		plan = CreatePlan(op.Cast<LogicalCTERef>());
 		break;
@@ -217,6 +220,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 		}
 		break;
 	case LogicalOperatorType::LOGICAL_JOIN:
+	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
 	case LogicalOperatorType::LOGICAL_INVALID: {
 		throw NotImplementedException("Unimplemented logical operator type!");
 	}