duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/execution/operator/persistent/physical_insert.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/storage/data_table.hpp"
@@ -16,10 +16,11 @@
 #include "duckdb/common/types/conflict_manager.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/storage/table/append_state.hpp"
 
 namespace duckdb {
 
-PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *table,
+PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry &table,
                                physical_index_vector_t<idx_t> column_index_map,
                                vector<unique_ptr<Expression>> bound_defaults,
                                vector<unique_ptr<Expression>> set_expressions, vector<PhysicalIndex> set_columns,
@@ -29,7 +30,7 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
                                unique_ptr<Expression> do_update_condition_p, unordered_set<column_t> conflict_target_p,
                                vector<column_t> columns_to_fetch_p)
     : PhysicalOperator(PhysicalOperatorType::INSERT, std::move(types_p), estimated_cardinality),
-      column_index_map(std::move(column_index_map)), insert_table(table), insert_types(table->GetTypes()),
+      column_index_map(std::move(column_index_map)), insert_table(&table), insert_types(table.GetTypes()),
       bound_defaults(std::move(bound_defaults)), return_chunk(return_chunk), parallel(parallel),
       action_type(action_type), set_expressions(std::move(set_expressions)), set_columns(std::move(set_columns)),
       set_types(std::move(set_types)), on_conflict_condition(std::move(on_conflict_condition_p)),
@@ -52,10 +53,10 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
 	}
 }
 
-PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info_p,
+PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info_p,
                                idx_t estimated_cardinality, bool parallel)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE_AS, op.types, estimated_cardinality), insert_table(nullptr),
-      return_chunk(false), schema(schema), info(std::move(info_p)), parallel(parallel),
+      return_chunk(false), schema(&schema), info(std::move(info_p)), parallel(parallel),
       action_type(OnConflictAction::THROW) {
 	GetInsertInfo(*info, insert_types, bound_defaults);
 }
@@ -65,7 +66,7 @@ void PhysicalInsert::GetInsertInfo(const BoundCreateTableInfo &info, vector<Logi
 	auto &create_info = (CreateTableInfo &)*info.base;
 	for (auto &col : create_info.columns.Physical()) {
 		insert_types.push_back(col.GetType());
-		bound_defaults.push_back(make_unique<BoundConstantExpression>(Value(col.GetType())));
+		bound_defaults.push_back(make_uniq<BoundConstantExpression>(Value(col.GetType())));
 	}
 }
 
@@ -74,12 +75,12 @@ void PhysicalInsert::GetInsertInfo(const BoundCreateTableInfo &info, vector<Logi
 //===--------------------------------------------------------------------===//
 class InsertGlobalState : public GlobalSinkState {
 public:
-	explicit InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types)
-	    : insert_count(0), initialized(false), return_collection(context, return_types) {
+	explicit InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types, DuckTableEntry &table)
+	    : table(table), insert_count(0), initialized(false), return_collection(context, return_types) {
 	}
 
 	mutex lock;
-	DuckTableEntry *table;
+	DuckTableEntry &table;
 	idx_t insert_count;
 	bool initialized;
 	LocalAppendState append_state;
@@ -98,32 +99,33 @@ public:
 	ExpressionExecutor default_executor;
 	TableAppendState local_append_state;
 	unique_ptr<RowGroupCollection> local_collection;
-	OptimisticDataWriter *writer;
+	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
 	unordered_set<row_t> updated_rows;
 };
 
 unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
-	auto result = make_unique<InsertGlobalState>(context, GetTypes());
+	optional_ptr<TableCatalogEntry> table;
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table =
-		    (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
+		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
+		                                                 info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
-		result->table = (DuckTableEntry *)insert_table;
+		table = insert_table.get_mutable();
 	}
+	auto result = make_uniq<InsertGlobalState>(context, GetTypes(), table->Cast<DuckTableEntry>());
 	return std::move(result);
 }
 
 unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<InsertLocalState>(context.client, insert_types, bound_defaults);
+	return make_uniq<InsertLocalState>(context.client, insert_types, bound_defaults);
 }
 
-void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
+void PhysicalInsert::ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
                                      const physical_index_vector_t<idx_t> &column_index_map,
                                      ExpressionExecutor &default_executor, DataChunk &result) {
 	chunk.Flatten();
@@ -134,7 +136,7 @@ void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
 
 	if (!column_index_map.empty()) {
 		// columns specified by the user, use column_index_map
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto storage_idx = col.StorageOid();
 			auto mapped_index = column_index_map[col.Physical()];
 			if (mapped_index == DConstants::INVALID_INDEX) {
@@ -215,7 +217,7 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry *table,
+void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
                                              Vector &row_ids) const {
 	if (action_type == OnConflictAction::NOTHING) {
 		return;
@@ -254,9 +256,9 @@ void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChun
 	executor.Execute(chunk, update_chunk);
 	update_chunk.SetCardinality(chunk);
 
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
-	data_table.Update(*table, context.client, row_ids, set_columns, update_chunk);
+	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
 }
 
 // TODO: should we use a hash table to keep track of this instead?
@@ -273,11 +275,11 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionContext &context,
+void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
                                         InsertLocalState &lstate) const {
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	if (action_type == OnConflictAction::THROW) {
-		data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, nullptr);
+		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
 		return;
 	}
 	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
@@ -286,7 +288,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 	// We either want to do nothing, or perform an update when conflicts arise
 	ConflictInfo conflict_info(conflict_target);
 	ConflictManager conflict_manager(VerifyExistenceType::APPEND, lstate.insert_chunk.size(), &conflict_info);
-	data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, &conflict_manager);
+	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
 		// No conflicts found
@@ -310,8 +312,8 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 		// When these values are required for the conditions or the SET expressions,
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
-		auto fetch_state = make_unique<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, *table->catalog);
+		auto fetch_state = make_uniq<ColumnFetchState>();
+		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
 		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
 	}
 
@@ -334,7 +336,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 			}
 			combined_chunk.Slice(sel.Selection(), sel.Count());
 			row_ids.Slice(sel.Selection(), sel.Count());
-			data_table.VerifyAppendConstraints(*table, context.client, combined_chunk, nullptr);
+			data_table.VerifyAppendConstraints(table, context.client, combined_chunk, nullptr);
 			throw InternalException("The previous operation was expected to throw but didn't");
 		}
 	}
@@ -353,11 +355,11 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 
 SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
                                     DataChunk &chunk) const {
-	auto &gstate = (InsertGlobalState &)state;
-	auto &lstate = (InsertLocalState &)lstate_p;
+	auto &gstate = state.Cast<InsertGlobalState>();
+	auto &lstate = lstate_p.Cast<InsertLocalState>();
 
-	auto table = gstate.table;
-	auto &storage = table->GetStorage();
+	auto &table = gstate.table;
+	auto &storage = table.GetStorage();
 	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!parallel) {
@@ -367,7 +369,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 		}
 
 		OnConflictHandling(table, context, lstate);
-		storage.LocalAppend(gstate.append_state, *table, context.client, lstate.insert_chunk, true);
+		storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
 			gstate.return_collection.Append(lstate.insert_chunk);
@@ -381,10 +383,10 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			auto &table_info = storage.info;
 			auto &block_manager = TableIOManager::Get(storage).GetBlockManagerForRowData();
 			lstate.local_collection =
-			    make_unique<RowGroupCollection>(table_info, block_manager, insert_types, MAX_ROW_ID);
+			    make_uniq<RowGroupCollection>(table_info, block_manager, insert_types, MAX_ROW_ID);
 			lstate.local_collection->InitializeEmpty();
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
-			lstate.writer = gstate.table->GetStorage().CreateOptimisticWriter(context.client);
+			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
 		}
 		OnConflictHandling(table, context, lstate);
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
@@ -397,10 +399,10 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (InsertGlobalState &)gstate_p;
-	auto &lstate = (InsertLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<InsertGlobalState>();
+	auto &lstate = lstate_p.Cast<InsertLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &lstate.default_executor, "default_executor", 1);
+	context.thread.profiler.Flush(*this, lstate.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 
 	if (!parallel) {
@@ -419,12 +421,12 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		// we have few rows - append to the local storage directly
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
-		auto table = gstate.table;
-		auto &storage = table->GetStorage();
+		auto &table = gstate.table;
+		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
-		auto &transaction = DuckTransaction::Get(context.client, *table->catalog);
+		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
 		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
-			storage.LocalAppend(gstate.append_state, *table, context.client, insert_chunk);
+			storage.LocalAppend(gstate.append_state, table, context.client, insert_chunk);
 			return true;
 		});
 		storage.FinalizeLocalAppend(gstate.append_state);
@@ -436,16 +438,16 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
-		gstate.table->GetStorage().LocalMerge(context.client, *lstate.local_collection);
+		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
 	}
 }
 
 SinkFinalizeType PhysicalInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &state) const {
-	auto &gstate = (InsertGlobalState &)state;
+	auto &gstate = state.Cast<InsertGlobalState>();
 	if (!parallel && gstate.initialized) {
-		auto table = gstate.table;
-		auto &storage = table->GetStorage();
+		auto &table = gstate.table;
+		auto &storage = table.GetStorage();
 		storage.FinalizeLocalAppend(gstate.append_state);
 	}
 	return SinkFinalizeType::READY;
@@ -459,7 +461,7 @@ public:
 	explicit InsertSourceState(const PhysicalInsert &op) : finished(false) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
-			auto &g = (InsertGlobalState &)*op.sink_state;
+			auto &g = op.sink_state->Cast<InsertGlobalState>();
 			g.return_collection.InitializeScan(scan_state);
 		}
 	}
@@ -469,13 +471,13 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalInsert::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<InsertSourceState>(*this);
+	return make_uniq<InsertSourceState>(*this);
 }
 
 void PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (InsertSourceState &)gstate;
-	auto &insert_gstate = (InsertGlobalState &)*sink_state;
+	auto &state = gstate.Cast<InsertSourceState>();
+	auto &insert_gstate = sink_state->Cast<InsertGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/persistent/physical_update.cpp

@@ -1,12 +1,13 @@
 #include "duckdb/execution/operator/persistent/physical_update.hpp"
-#include "duckdb/parallel/thread_context.hpp"
+
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 
@@ -58,8 +59,8 @@ public:
 
 SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &chunk) const {
-	auto &gstate = (UpdateGlobalState &)state;
-	auto &ustate = (UpdateLocalState &)lstate;
+	auto &gstate = state.Cast<UpdateGlobalState>();
+	auto &ustate = lstate.Cast<UpdateLocalState>();
 
 	DataChunk &update_chunk = ustate.update_chunk;
 	DataChunk &mock_chunk = ustate.mock_chunk;
@@ -80,7 +81,7 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 		} else {
 			D_ASSERT(expressions[i]->type == ExpressionType::BOUND_REF);
 			// index into child chunk
-			auto &binding = (BoundReferenceExpression &)*expressions[i];
+			auto &binding = expressions[i]->Cast<BoundReferenceExpression>();
 			update_chunk.data[i].Reference(chunk.data[binding.index]);
 		}
 	}
@@ -133,17 +134,17 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 unique_ptr<GlobalSinkState> PhysicalUpdate::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<UpdateGlobalState>(context, GetTypes());
+	return make_uniq<UpdateGlobalState>(context, GetTypes());
 }
 
 unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<UpdateLocalState>(context.client, expressions, table.GetTypes(), bound_defaults);
+	return make_uniq<UpdateLocalState>(context.client, expressions, table.GetTypes(), bound_defaults);
 }
 
 void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (UpdateLocalState &)lstate;
+	auto &state = lstate.Cast<UpdateLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
+	context.thread.profiler.Flush(*this, state.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
@@ -155,7 +156,7 @@ public:
 	explicit UpdateSourceState(const PhysicalUpdate &op) : finished(false) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
-			auto &g = (UpdateGlobalState &)*op.sink_state;
+			auto &g = op.sink_state->Cast<UpdateGlobalState>();
 			g.return_collection.InitializeScan(scan_state);
 		}
 	}
@@ -165,13 +166,13 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalUpdate::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<UpdateSourceState>(*this);
+	return make_uniq<UpdateSourceState>(*this);
 }
 
 void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (UpdateSourceState &)gstate;
-	auto &g = (UpdateGlobalState &)*sink_state;
+	auto &state = gstate.Cast<UpdateSourceState>();
+	auto &g = sink_state->Cast<UpdateGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/projection/physical_pivot.cpp

@@ -0,0 +1,81 @@
+#include "duckdb/execution/operator/projection/physical_pivot.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+
+namespace duckdb {
+
+PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOperator> child,
+                             BoundPivotInfo bound_pivot_p)
+    : PhysicalOperator(PhysicalOperatorType::PIVOT, std::move(types_p), child->estimated_cardinality),
+      bound_pivot(std::move(bound_pivot_p)) {
+	children.push_back(std::move(child));
+	for (idx_t p = 0; p < bound_pivot.pivot_values.size(); p++) {
+		auto entry = pivot_map.find(bound_pivot.pivot_values[p]);
+		if (entry != pivot_map.end()) {
+			continue;
+		}
+		pivot_map[bound_pivot.pivot_values[p]] = bound_pivot.group_count + p;
+	}
+	// extract the empty aggregate expressions
+	for (auto &aggr_expr : bound_pivot.aggregates) {
+		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
+		// for each aggregate, initialize an empty aggregate state and finalize it immediately
+		auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
+		aggr.function.initialize(state.get());
+		Vector state_vector(Value::POINTER((uintptr_t)state.get()));
+		Vector result_vector(aggr_expr->return_type);
+		AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+		aggr.function.finalize(state_vector, aggr_input_data, result_vector, 1, 0);
+		empty_aggregates.push_back(result_vector.GetValue(0));
+	}
+}
+
+OperatorResultType PhysicalPivot::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                          GlobalOperatorState &gstate, OperatorState &state) const {
+	// copy the groups as-is
+	for (idx_t i = 0; i < bound_pivot.group_count; i++) {
+		chunk.data[i].Reference(input.data[i]);
+	}
+	auto pivot_column_lists = FlatVector::GetData<list_entry_t>(input.data.back());
+	auto &pivot_column_values = ListVector::GetEntry(input.data.back());
+	auto pivot_columns = FlatVector::GetData<string_t>(pivot_column_values);
+
+	// initialize all aggregate columns with the empty aggregate value
+	// if there are multiple aggregates the columns are in order of [AGGR1][AGGR2][AGGR1][AGGR2]
+	// so we need to alternate the empty_aggregate that we use
+	idx_t aggregate = 0;
+	for (idx_t c = bound_pivot.group_count; c < chunk.ColumnCount(); c++) {
+		chunk.data[c].Reference(empty_aggregates[aggregate]);
+		chunk.data[c].Flatten(input.size());
+		aggregate++;
+		if (aggregate >= empty_aggregates.size()) {
+			aggregate = 0;
+		}
+	}
+
+	// move the pivots to the given columns
+	for (idx_t r = 0; r < input.size(); r++) {
+		auto list = pivot_column_lists[r];
+		for (idx_t l = 0; l < list.length; l++) {
+			// figure out the column value number of this list
+			auto &column_name = pivot_columns[list.offset + l];
+			auto entry = pivot_map.find(column_name);
+			if (entry == pivot_map.end()) {
+				// column entry not found in map - that means this element is explicitly excluded from the pivot list
+				continue;
+			}
+			auto column_idx = entry->second;
+			for (idx_t aggr = 0; aggr < empty_aggregates.size(); aggr++) {
+				auto pivot_value_lists = FlatVector::GetData<list_entry_t>(input.data[bound_pivot.group_count + aggr]);
+				auto &pivot_value_child = ListVector::GetEntry(input.data[bound_pivot.group_count + aggr]);
+				if (list.offset != pivot_value_lists[r].offset || list.length != pivot_value_lists[r].length) {
+					throw InternalException("Pivot - unaligned lists between values and columns!?");
+				}
+				chunk.data[column_idx + aggr].SetValue(r, pivot_value_child.GetValue(list.offset + l));
+			}
+		}
+	}
+	chunk.SetCardinality(input.size());
+	return OperatorResultType::NEED_MORE_INPUT;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/projection/physical_projection.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 
 namespace duckdb {
 
@@ -13,8 +14,8 @@ public:
 	ExpressionExecutor executor;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &executor, "projection", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, executor, "projection", 0);
 	}
 };
 
@@ -32,7 +33,40 @@ OperatorResultType PhysicalProjection::Execute(ExecutionContext &context, DataCh
 }
 
 unique_ptr<OperatorState> PhysicalProjection::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<ProjectionState>(context, select_list);
+	return make_uniq<ProjectionState>(context, select_list);
+}
+
+unique_ptr<PhysicalOperator>
+PhysicalProjection::CreateJoinProjection(vector<LogicalType> proj_types, const vector<LogicalType> &lhs_types,
+                                         const vector<LogicalType> &rhs_types, const vector<idx_t> &left_projection_map,
+                                         const vector<idx_t> &right_projection_map, const idx_t estimated_cardinality) {
+
+	vector<unique_ptr<Expression>> proj_selects;
+	proj_selects.reserve(proj_types.size());
+
+	if (left_projection_map.empty()) {
+		for (storage_t i = 0; i < lhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	} else {
+		for (auto i : left_projection_map) {
+			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	}
+	const auto left_cols = lhs_types.size();
+
+	if (right_projection_map.empty()) {
+		for (storage_t i = 0; i < rhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+
+	} else {
+		for (auto i : right_projection_map) {
+			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+	}
+
+	return make_uniq<PhysicalProjection>(std::move(proj_types), std::move(proj_selects), estimated_cardinality);
 }
 
 string PhysicalProjection::ParamsToString() const {

package/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp

@@ -31,8 +31,8 @@ PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types
 }
 
 unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = (TableInOutGlobalState &)*op_state;
-	auto result = make_unique<TableInOutLocalState>();
+	auto &gstate = op_state->Cast<TableInOutGlobalState>();
+	auto result = make_uniq<TableInOutLocalState>();
 	if (function.init_local) {
 		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
 		result->local_state = function.init_local(context, input, gstate.global_state.get());
@@ -44,7 +44,7 @@ unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(Execution
 }
 
 unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorState(ClientContext &context) const {
-	auto result = make_unique<TableInOutGlobalState>();
+	auto result = make_uniq<TableInOutGlobalState>();
 	if (function.init_global) {
 		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
 		result->global_state = function.init_global(context, input);
@@ -54,8 +54,8 @@ unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorSta
 
 OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                        GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (TableInOutGlobalState &)gstate_p;
-	auto &state = (TableInOutLocalState &)state_p;
+	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
+	auto &state = state_p.Cast<TableInOutLocalState>();
 	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
 	if (projected_input.empty()) {
 		// straightforward case - no need to project input
@@ -102,8 +102,8 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context
 OperatorFinalizeResultType PhysicalTableInOutFunction::FinalExecute(ExecutionContext &context, DataChunk &chunk,
                                                                     GlobalOperatorState &gstate_p,
                                                                     OperatorState &state_p) const {
-	auto &gstate = (TableInOutGlobalState &)gstate_p;
-	auto &state = (TableInOutLocalState &)state_p;
+	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
+	auto &state = state_p.Cast<TableInOutLocalState>();
 	if (!projected_input.empty()) {
 		throw InternalException("FinalExecute not supported for project_input");
 	}

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -19,9 +19,9 @@ public:
 		vector<LogicalType> list_data_types;
 		for (auto &exp : select_list) {
 			D_ASSERT(exp->type == ExpressionType::BOUND_UNNEST);
-			auto bue = (BoundUnnestExpression *)exp.get();
-			list_data_types.push_back(bue->child->return_type);
-			executor.AddExpression(*bue->child.get());
+			auto &bue = exp->Cast<BoundUnnestExpression>();
+			list_data_types.push_back(bue.child->return_type);
+			executor.AddExpression(*bue.child.get());
 		}
 
 		auto &allocator = Allocator::Get(context);
@@ -56,7 +56,6 @@ void UnnestOperatorState::Reset() {
 }
 
 void UnnestOperatorState::SetLongestListLength() {
-
 	longest_list_length = 0;
 	for (idx_t col_idx = 0; col_idx < list_data.ColumnCount(); col_idx++) {
 
@@ -249,7 +248,7 @@ unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ExecutionContext &con
 
 unique_ptr<OperatorState> PhysicalUnnest::GetState(ExecutionContext &context,
                                                    const vector<unique_ptr<Expression>> &select_list) {
-	return make_unique<UnnestOperatorState>(context.client, select_list);
+	return make_uniq<UnnestOperatorState>(context.client, select_list);
 }
 
 OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
@@ -257,7 +256,7 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
                                                    const vector<unique_ptr<Expression>> &select_list,
                                                    bool include_input) {
 
-	auto &state = (UnnestOperatorState &)state_p;
+	auto &state = state_p.Cast<UnnestOperatorState>();
 
 	do {
 		// prepare the input data by executing any expressions and getting the

package/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp

@@ -6,6 +6,13 @@
 
 namespace duckdb {
 
+PhysicalColumnDataScan::PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type,
+                                               idx_t estimated_cardinality,
+                                               unique_ptr<ColumnDataCollection> owned_collection_p)
+    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(owned_collection_p.get()),
+      owned_collection(std::move(owned_collection_p)) {
+}
+
 class PhysicalColumnDataScanState : public GlobalSourceState {
 public:
 	explicit PhysicalColumnDataScanState() : initialized(false) {
@@ -17,13 +24,12 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalColumnDataScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PhysicalColumnDataScanState>();
+	return make_uniq<PhysicalColumnDataScanState>();
 }
 
 void PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                      LocalSourceState &lstate) const {
-	auto &state = (PhysicalColumnDataScanState &)gstate;
-	D_ASSERT(collection);
+	auto &state = gstate.Cast<PhysicalColumnDataScanState>();
 	if (collection->Count() == 0) {
 		return;
 	}
@@ -42,17 +48,17 @@ void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &met
 	auto &state = meta_pipeline.GetState();
 	switch (type) {
 	case PhysicalOperatorType::DELIM_SCAN: {
-		auto entry = state.delim_join_dependencies.find(this);
+		auto entry = state.delim_join_dependencies.find(*this);
 		D_ASSERT(entry != state.delim_join_dependencies.end());
 		// this chunk scan introduces a dependency to the current pipeline
 		// namely a dependency on the duplicate elimination pipeline to finish
-		auto delim_dependency = entry->second->shared_from_this();
+		auto delim_dependency = entry->second.get().shared_from_this();
 		auto delim_sink = state.GetPipelineSink(*delim_dependency);
 		D_ASSERT(delim_sink);
 		D_ASSERT(delim_sink->type == PhysicalOperatorType::DELIM_JOIN);
-		auto &delim_join = (PhysicalDelimJoin &)*delim_sink;
+		auto &delim_join = delim_sink->Cast<PhysicalDelimJoin>();
 		current.AddDependency(delim_dependency);
-		state.SetPipelineSource(current, (PhysicalOperator *)delim_join.distinct.get());
+		state.SetPipelineSource(current, (PhysicalOperator &)*delim_join.distinct);
 		return;
 	}
 	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
@@ -64,7 +70,7 @@ void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &met
 		break;
 	}
 	D_ASSERT(children.empty());
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 }
 
 } // namespace duckdb