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

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

@@ -6,8 +6,9 @@
 #include "duckdb/execution/operator/order/physical_order.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/table_filter.hpp"
 
 namespace duckdb {
@@ -35,14 +36,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	unique_ptr<TableFilterSet> table_filters;
 	op.info->column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
 
-	auto &bind_data = (TableScanBindData &)*op.bind_data;
+	auto &bind_data = op.bind_data->Cast<TableScanBindData>();
 	bind_data.is_create_index = true;
 
 	auto table_scan =
-	    make_unique<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
-	                                   op.info->names, std::move(table_filters), op.estimated_cardinality);
+	    make_uniq<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
+	                                 op.info->names, std::move(table_filters), op.estimated_cardinality);
 
-	dependencies.AddDependency(&op.table);
+	dependencies.AddDependency(op.table);
 	op.info->column_ids.pop_back();
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
@@ -57,10 +58,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 		select_list.push_back(std::move(op.expressions[i]));
 	}
 	new_column_types.emplace_back(LogicalType::ROW_TYPE);
-	select_list.push_back(make_unique<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
+	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
 
-	auto projection =
-	    make_unique<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
+	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
 	projection->children.push_back(std::move(table_scan));
 
 	// filter operator for IS_NOT_NULL on each key column
@@ -71,14 +71,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
 		filter_types.push_back(new_column_types[i]);
 		auto is_not_null_expr =
-		    make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-		auto bound_ref = make_unique<BoundReferenceExpression>(new_column_types[i], i);
+		    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
+		auto bound_ref = make_uniq<BoundReferenceExpression>(new_column_types[i], i);
 		is_not_null_expr->children.push_back(std::move(bound_ref));
 		filter_select_list.push_back(std::move(is_not_null_expr));
 	}
 
 	auto null_filter =
-	    make_unique<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
+	    make_uniq<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
 	null_filter->types.emplace_back(LogicalType::ROW_TYPE);
 	null_filter->children.push_back(std::move(projection));
 
@@ -87,21 +87,21 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	vector<BoundOrderByNode> orders;
 	vector<idx_t> projections;
 	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
-		auto col_expr = make_unique_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
+		auto col_expr = make_uniq_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
 		orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(col_expr));
 		projections.emplace_back(i);
 	}
 	projections.emplace_back(new_column_types.size() - 1);
 
-	auto physical_order = make_unique<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections),
-	                                                 op.estimated_cardinality);
+	auto physical_order =
+	    make_uniq<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections), op.estimated_cardinality);
 	physical_order->children.push_back(std::move(null_filter));
 
 	// actual physical create index operator
 
 	auto physical_create_index =
-	    make_unique<PhysicalCreateIndex>(op, op.table, op.info->column_ids, std::move(op.info),
-	                                     std::move(op.unbound_expressions), op.estimated_cardinality);
+	    make_uniq<PhysicalCreateIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                   std::move(op.unbound_expressions), op.estimated_cardinality);
 	physical_create_index->children.push_back(std::move(physical_order));
 	return std::move(physical_create_index);
 }

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

@@ -21,11 +21,11 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
 	unique_ptr<PhysicalOperator> create;
 	if (!parallel_streaming_insert && use_batch_index) {
-		create = make_unique<PhysicalBatchInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality);
+		create = make_uniq<PhysicalBatchInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 
 	} else {
-		create = make_unique<PhysicalInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality,
-		                                     parallel_streaming_insert && num_threads > 1);
+		create = make_uniq<PhysicalInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality,
+		                                   parallel_streaming_insert && num_threads > 1);
 	}
 
 	D_ASSERT(op.children.size() == 1);
@@ -35,14 +35,14 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
 	const auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = *op.info->schema->catalog;
+	auto &catalog = *op.info->schema.catalog;
 	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-		return op.schema->catalog->PlanCreateTableAs(context, op, std::move(plan));
+		return op.schema.catalog->PlanCreateTableAs(context, op, std::move(plan));
 	} else {
-		return make_unique<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
+		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 	}
 }
 

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

@@ -9,7 +9,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCrossProdu
 
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
-	return make_unique<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
+	return make_uniq<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -10,10 +10,10 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> DuckCatalog::PlanDelete(ClientContext &context, LogicalDelete &op,
                                                      unique_ptr<PhysicalOperator> plan) {
 	// get the index of the row_id column
-	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
+	auto &bound_ref = op.expressions[0]->Cast<BoundReferenceExpression>();
 
-	auto del = make_unique<PhysicalDelete>(op.types, *op.table, op.table->GetStorage(), bound_ref.index,
-	                                       op.estimated_cardinality, op.return_chunk);
+	auto del = make_uniq<PhysicalDelete>(op.types, op.table, op.table.GetStorage(), bound_ref.index,
+	                                     op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(std::move(plan));
 	return std::move(del);
 }
@@ -26,7 +26,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	return op.table->catalog->PlanDelete(context, op, std::move(plan));
+	return op.table.catalog->PlanDelete(context, op, std::move(plan));
 }
 
 } // namespace duckdb

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

@@ -9,7 +9,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimGet &
 
 	// create a PhysicalChunkScan without an owned_collection, the collection will be added later
 	auto chunk_scan =
-	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::DELIM_SCAN, op.estimated_cardinality);
+	    make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::DELIM_SCAN, op.estimated_cardinality);
 	return std::move(chunk_scan);
 }
 

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

@@ -10,25 +10,24 @@
 
 namespace duckdb {
 
-static void GatherDelimScans(PhysicalOperator *op, vector<PhysicalOperator *> &delim_scans) {
-	D_ASSERT(op);
-	if (op->type == PhysicalOperatorType::DELIM_SCAN) {
+static void GatherDelimScans(const PhysicalOperator &op, vector<const_reference<PhysicalOperator>> &delim_scans) {
+	if (op.type == PhysicalOperatorType::DELIM_SCAN) {
 		delim_scans.push_back(op);
 	}
-	for (auto &child : op->children) {
-		GatherDelimScans(child.get(), delim_scans);
+	for (auto &child : op.children) {
+		GatherDelimScans(*child, delim_scans);
 	}
 }
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin &op) {
 	// first create the underlying join
-	auto plan = CreatePlan((LogicalComparisonJoin &)op);
+	auto plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
 	// this should create a join, not a cross product
 	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
 	// duplicate eliminated join
 	// first gather the scans on the duplicate eliminated data set from the RHS
-	vector<PhysicalOperator *> delim_scans;
-	GatherDelimScans(plan->children[1].get(), delim_scans);
+	vector<const_reference<PhysicalOperator>> delim_scans;
+	GatherDelimScans(*plan->children[1], delim_scans);
 	if (delim_scans.empty()) {
 		// no duplicate eliminated scans in the RHS!
 		// in this case we don't need to create a delim join
@@ -39,15 +38,15 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin
 	vector<unique_ptr<Expression>> distinct_groups, distinct_expressions;
 	for (auto &delim_expr : op.duplicate_eliminated_columns) {
 		D_ASSERT(delim_expr->type == ExpressionType::BOUND_REF);
-		auto &bound_ref = (BoundReferenceExpression &)*delim_expr;
+		auto &bound_ref = delim_expr->Cast<BoundReferenceExpression>();
 		delim_types.push_back(bound_ref.return_type);
-		distinct_groups.push_back(make_unique<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
+		distinct_groups.push_back(make_uniq<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
 	}
 	// now create the duplicate eliminated join
-	auto delim_join = make_unique<PhysicalDelimJoin>(op.types, std::move(plan), delim_scans, op.estimated_cardinality);
+	auto delim_join = make_uniq<PhysicalDelimJoin>(op.types, std::move(plan), delim_scans, op.estimated_cardinality);
 	// we still have to create the DISTINCT clause that is used to generate the duplicate eliminated chunk
-	delim_join->distinct = make_unique<PhysicalHashAggregate>(context, delim_types, std::move(distinct_expressions),
-	                                                          std::move(distinct_groups), op.estimated_cardinality);
+	delim_join->distinct = make_uniq<PhysicalHashAggregate>(context, delim_types, std::move(distinct_expressions),
+	                                                        std::move(distinct_groups), op.estimated_cardinality);
 	return std::move(delim_join);
 }
 

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

@@ -9,8 +9,10 @@
 
 namespace duckdb {
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-                                                                     vector<unique_ptr<Expression>> distinct_targets) {
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
+	D_ASSERT(op.children.size() == 1);
+	auto child = CreatePlan(*op.children[0]);
+	auto &distinct_targets = op.distinct_targets;
 	D_ASSERT(child);
 	D_ASSERT(!distinct_targets.empty());
 
@@ -23,7 +25,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 	for (idx_t i = 0; i < distinct_targets.size(); i++) {
 		auto &target = distinct_targets[i];
 		if (target->type == ExpressionType::BOUND_REF) {
-			auto &bound_ref = (BoundReferenceExpression &)*target;
+			auto &bound_ref = target->Cast<BoundReferenceExpression>();
 			group_by_references[bound_ref.index] = i;
 		}
 		aggregate_types.push_back(target->return_type);
@@ -41,22 +43,26 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 		if (entry != group_by_references.end()) {
 			auto group_index = entry->second;
 			// entry is found: can directly refer to a group
-			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_index));
+			projections.push_back(make_uniq<BoundReferenceExpression>(logical_type, group_index));
 			if (group_index != i) {
 				// we require a projection only if this group element is out of order
 				requires_projection = true;
 			}
 		} else {
+			if (op.distinct_type == DistinctType::DISTINCT && op.order_by) {
+				throw InternalException("Entry that is not a group, but not a DISTINCT ON aggregate");
+			}
 			// entry is not one of the groups: need to push a FIRST aggregate
-			auto bound = make_unique<BoundReferenceExpression>(logical_type, i);
+			auto bound = make_uniq<BoundReferenceExpression>(logical_type, i);
 			vector<unique_ptr<Expression>> first_children;
 			first_children.push_back(std::move(bound));
 
 			FunctionBinder function_binder(context);
 			auto first_aggregate = function_binder.BindAggregateFunction(
 			    FirstFun::GetFunction(logical_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
+			first_aggregate->order_bys = op.order_by ? op.order_by->Copy() : nullptr;
 			// add the projection
-			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
+			projections.push_back(make_uniq<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
 			// push it to the list of aggregates
 			aggregate_types.push_back(logical_type);
 			aggregates.push_back(std::move(first_aggregate));
@@ -67,24 +73,17 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 	child = ExtractAggregateExpressions(std::move(child), aggregates, groups);
 
 	// we add a physical hash aggregation in the plan to select the distinct groups
-	auto groupby = make_unique<PhysicalHashAggregate>(context, aggregate_types, std::move(aggregates),
-	                                                  std::move(groups), child->estimated_cardinality);
+	auto groupby = make_uniq<PhysicalHashAggregate>(context, aggregate_types, std::move(aggregates), std::move(groups),
+	                                                child->estimated_cardinality);
 	groupby->children.push_back(std::move(child));
 	if (!requires_projection) {
 		return std::move(groupby);
 	}
 
 	// we add a physical projection on top of the aggregation to project all members in the select list
-	auto aggr_projection =
-	    make_unique<PhysicalProjection>(types, std::move(projections), groupby->estimated_cardinality);
+	auto aggr_projection = make_uniq<PhysicalProjection>(types, std::move(projections), groupby->estimated_cardinality);
 	aggr_projection->children.push_back(std::move(groupby));
 	return std::move(aggr_projection);
 }
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-	return CreateDistinctOn(std::move(plan), std::move(op.distinct_targets));
-}
-
 } // namespace duckdb

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

@@ -6,7 +6,7 @@ namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDummyScan &op) {
 	D_ASSERT(op.children.size() == 0);
-	return make_unique<PhysicalDummyScan>(op.types, op.estimated_cardinality);
+	return make_uniq<PhysicalDummyScan>(op.types, op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -6,7 +6,7 @@ namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalEmptyResult &op) {
 	D_ASSERT(op.children.size() == 0);
-	return make_unique<PhysicalEmptyResult>(op.types, op.estimated_cardinality);
+	return make_uniq<PhysicalEmptyResult>(op.types, op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -8,13 +8,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExecute &o
 	if (!op.prepared->plan) {
 		D_ASSERT(op.children.size() == 1);
 		auto owned_plan = CreatePlan(*op.children[0]);
-		auto execute = make_unique<PhysicalExecute>(owned_plan.get());
+		auto execute = make_uniq<PhysicalExecute>(*owned_plan);
 		execute->owned_plan = std::move(owned_plan);
 		execute->prepared = std::move(op.prepared);
 		return std::move(execute);
 	} else {
 		D_ASSERT(op.children.size() == 0);
-		return make_unique<PhysicalExecute>(op.prepared->plan.get());
+		return make_uniq<PhysicalExecute>(*op.prepared->plan);
 	}
 }
 

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

@@ -1,11 +1,10 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_explain.hpp"
+#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/operator/helper/physical_explain_analyze.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
 #include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-
-#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/operator/logical_explain.hpp"
 
 namespace duckdb {
 
@@ -14,7 +13,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	auto logical_plan_opt = op.children[0]->ToString();
 	auto plan = CreatePlan(*op.children[0]);
 	if (op.explain_type == ExplainType::EXPLAIN_ANALYZE) {
-		auto result = make_unique<PhysicalExplainAnalyze>(op.types);
+		auto result = make_uniq<PhysicalExplainAnalyze>(op.types);
 		result->children.push_back(std::move(plan));
 		return std::move(result);
 	}
@@ -40,7 +39,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	auto &allocator = Allocator::Get(context);
 	vector<LogicalType> plan_types {LogicalType::VARCHAR, LogicalType::VARCHAR};
 	auto collection =
-	    make_unique<ColumnDataCollection>(context, plan_types, ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
+	    make_uniq<ColumnDataCollection>(context, plan_types, ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
 
 	DataChunk chunk;
 	chunk.Initialize(allocator, op.types);
@@ -56,10 +55,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	collection->Append(chunk);
 
 	// create a chunk scan to output the result
-	auto chunk_scan =
-	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = std::move(collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
+	                                                    op.estimated_cardinality, std::move(collection));
 	return std::move(chunk_scan);
 }
 

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

@@ -10,8 +10,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExport &op
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Export is disabled through configuration");
 	}
-	auto export_node = make_unique<PhysicalExport>(op.types, op.function, std::move(op.copy_info),
-	                                               op.estimated_cardinality, op.exported_tables);
+	auto export_node = make_uniq<PhysicalExport>(op.types, op.function, std::move(op.copy_info),
+	                                             op.estimated_cardinality, op.exported_tables);
 	// plan the underlying copy statements, if any
 	if (!op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);

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

@@ -1,8 +1,8 @@
+#include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
 #include "duckdb/execution/operator/scan/physical_expression_scan.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
 
 namespace duckdb {
 
@@ -10,7 +10,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpression
 	D_ASSERT(op.children.size() == 1);
 	auto plan = CreatePlan(*op.children[0]);
 
-	auto expr_scan = make_unique<PhysicalExpressionScan>(op.types, std::move(op.expressions), op.estimated_cardinality);
+	auto expr_scan = make_uniq<PhysicalExpressionScan>(op.types, std::move(op.expressions), op.estimated_cardinality);
 	expr_scan->children.push_back(std::move(plan));
 	if (!expr_scan->IsFoldable()) {
 		return std::move(expr_scan);
@@ -18,9 +18,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpression
 	auto &allocator = Allocator::Get(context);
 	// simple expression scan (i.e. no subqueries to evaluate and no prepared statement parameters)
 	// we can evaluate all the expressions right now and turn this into a chunk collection scan
-	auto chunk_scan = make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
-	                                                      expr_scan->expressions.size());
-	chunk_scan->owned_collection = make_unique<ColumnDataCollection>(context, op.types);
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
+	                                                    expr_scan->expressions.size());
+	chunk_scan->owned_collection = make_uniq<ColumnDataCollection>(context, op.types);
 	chunk_scan->collection = chunk_scan->owned_collection.get();
 
 	DataChunk chunk;

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

@@ -16,7 +16,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op
 	if (!op.expressions.empty()) {
 		D_ASSERT(plan->types.size() > 0);
 		// create a filter if there is anything to filter
-		auto filter = make_unique<PhysicalFilter>(plan->types, std::move(op.expressions), op.estimated_cardinality);
+		auto filter = make_uniq<PhysicalFilter>(plan->types, std::move(op.expressions), op.estimated_cardinality);
 		filter->children.push_back(std::move(plan));
 		plan = std::move(filter);
 	}
@@ -24,9 +24,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op
 		// there is a projection map, generate a physical projection
 		vector<unique_ptr<Expression>> select_list;
 		for (idx_t i = 0; i < op.projection_map.size(); i++) {
-			select_list.push_back(make_unique<BoundReferenceExpression>(op.types[i], op.projection_map[i]));
+			select_list.push_back(make_uniq<BoundReferenceExpression>(op.types[i], op.projection_map[i]));
 		}
-		auto proj = make_unique<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
+		auto proj = make_uniq<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
 		proj->children.push_back(std::move(plan));
 		plan = std::move(proj);
 	}

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

@@ -11,7 +11,7 @@ namespace duckdb {
 
 unique_ptr<TableFilterSet> CreateTableFilterSet(TableFilterSet &table_filters, vector<column_t> &column_ids) {
 	// create the table filter map
-	auto table_filter_set = make_unique<TableFilterSet>();
+	auto table_filter_set = make_uniq<TableFilterSet>();
 	for (auto &table_filter : table_filters.filters) {
 		// find the relative column index from the absolute column index into the table
 		idx_t column_index = DConstants::INVALID_INDEX;
@@ -33,9 +33,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 	if (!op.children.empty()) {
 		// this is for table producing functions that consume subquery results
 		D_ASSERT(op.children.size() == 1);
-		auto node =
-		    make_unique<PhysicalTableInOutFunction>(op.types, op.function, std::move(op.bind_data), op.column_ids,
-		                                            op.estimated_cardinality, std::move(op.projected_input));
+		auto node = make_uniq<PhysicalTableInOutFunction>(op.types, op.function, std::move(op.bind_data), op.column_ids,
+		                                                  op.estimated_cardinality, std::move(op.projected_input));
 		node->children.push_back(CreatePlan(std::move(op.children[0])));
 		return std::move(node);
 	}
@@ -54,9 +53,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 	// create the table scan node
 	if (!op.function.projection_pushdown) {
 		// function does not support projection pushdown
-		auto node = make_unique<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);
+		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);
 		// first check if an additional projection is necessary
 		if (op.column_ids.size() == op.returned_types.size()) {
 			bool projection_necessary = false;
@@ -79,22 +78,22 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 		for (auto &column_id : op.column_ids) {
 			if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
 				types.emplace_back(LogicalType::BIGINT);
-				expressions.push_back(make_unique<BoundConstantExpression>(Value::BIGINT(0)));
+				expressions.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(0)));
 			} else {
 				auto type = op.returned_types[column_id];
 				types.push_back(type);
-				expressions.push_back(make_unique<BoundReferenceExpression>(type, column_id));
+				expressions.push_back(make_uniq<BoundReferenceExpression>(type, column_id));
 			}
 		}
 
 		auto projection =
-		    make_unique<PhysicalProjection>(std::move(types), std::move(expressions), op.estimated_cardinality);
+		    make_uniq<PhysicalProjection>(std::move(types), std::move(expressions), op.estimated_cardinality);
 		projection->children.push_back(std::move(node));
 		return std::move(projection);
 	} else {
-		return make_unique<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);
+		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);
 	}
 }
 

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

@@ -10,14 +10,34 @@
 
 namespace duckdb {
 
+static OrderPreservationType OrderPreservationRecursive(PhysicalOperator &op) {
+	if (op.IsSource()) {
+		return op.SourceOrder();
+	}
+	for (auto &child : op.children) {
+		auto child_preservation = OrderPreservationRecursive(*child);
+		if (child_preservation != OrderPreservationType::INSERTION_ORDER) {
+			return child_preservation;
+		}
+	}
+	return OrderPreservationType::INSERTION_ORDER;
+}
+
 bool PhysicalPlanGenerator::PreserveInsertionOrder(ClientContext &context, PhysicalOperator &plan) {
 	auto &config = DBConfig::GetConfig(context);
-	if (!config.options.preserve_insertion_order) {
-		// preserving insertion order is disabled by config
+
+	auto preservation_type = OrderPreservationRecursive(plan);
+	if (preservation_type == OrderPreservationType::FIXED_ORDER) {
+		// always need to maintain preservation order
+		return true;
+	}
+	if (preservation_type == OrderPreservationType::NO_ORDER) {
+		// never need to preserve order
 		return false;
 	}
-	if (!plan.AllOperatorsPreserveOrder()) {
-		// the plan has no order defined: no need to preserve insertion order
+	// preserve insertion order - check flags
+	if (!config.options.preserve_insertion_order) {
+		// preserving insertion order is disabled by config
 		return false;
 	}
 	return true;
@@ -66,10 +86,10 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanInsert(ClientContext &context, Log
 	}
 	unique_ptr<PhysicalOperator> insert;
 	if (use_batch_index && !parallel_streaming_insert) {
-		insert = make_unique<PhysicalBatchInsert>(op.types, op.table, op.column_index_map, std::move(op.bound_defaults),
-		                                          op.estimated_cardinality);
+		insert = make_uniq<PhysicalBatchInsert>(op.types, op.table, op.column_index_map, std::move(op.bound_defaults),
+		                                        op.estimated_cardinality);
 	} else {
-		insert = make_unique<PhysicalInsert>(
+		insert = make_uniq<PhysicalInsert>(
 		    op.types, op.table, op.column_index_map, std::move(op.bound_defaults), std::move(op.expressions),
 		    std::move(op.set_columns), std::move(op.set_types), op.estimated_cardinality, op.return_chunk,
 		    parallel_streaming_insert && num_threads > 1, op.action_type, std::move(op.on_conflict_condition),
@@ -87,7 +107,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		plan = CreatePlan(*op.children[0]);
 	}
 	dependencies.AddDependency(op.table);
-	return op.table->catalog->PlanInsert(context, op, std::move(plan));
+	return op.table.catalog->PlanInsert(context, op, std::move(plan));
 }
 
 } // namespace duckdb

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

@@ -14,19 +14,18 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimit &op)
 	unique_ptr<PhysicalOperator> limit;
 	if (!PreserveInsertionOrder(*plan)) {
 		// use parallel streaming limit if insertion order is not important
-		limit = make_unique<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-		                                            std::move(op.offset), op.estimated_cardinality, true);
+		limit = make_uniq<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
+		                                          std::move(op.offset), op.estimated_cardinality, true);
 	} else {
 		// maintaining insertion order is important
 		if (UseBatchIndex(*plan)) {
 			// source supports batch index: use parallel batch limit
-			limit = make_unique<PhysicalLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-			                                   std::move(op.offset), op.estimated_cardinality);
+			limit = make_uniq<PhysicalLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
+			                                 std::move(op.offset), op.estimated_cardinality);
 		} else {
 			// source does not support batch index: use a non-parallel streaming limit
-			limit =
-			    make_unique<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-			                                        std::move(op.offset), op.estimated_cardinality, false);
+			limit = make_uniq<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
+			                                          std::move(op.offset), op.estimated_cardinality, false);
 		}
 	}
 

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

@@ -9,8 +9,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimitPerce
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	auto limit = make_unique<PhysicalLimitPercent>(op.types, op.limit_percent, op.offset_val, std::move(op.limit),
-	                                               std::move(op.offset), op.estimated_cardinality);
+	auto limit = make_uniq<PhysicalLimitPercent>(op.types, op.limit_percent, op.offset_val, std::move(op.limit),
+	                                             std::move(op.offset), op.estimated_cardinality);
 	limit->children.push_back(std::move(plan));
 	return std::move(limit);
 }

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

@@ -17,8 +17,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOrder &op)
 		} else {
 			projections = std::move(op.projections);
 		}
-		auto order = make_unique<PhysicalOrder>(op.types, std::move(op.orders), std::move(projections),
-		                                        op.estimated_cardinality);
+		auto order =
+		    make_uniq<PhysicalOrder>(op.types, std::move(op.orders), std::move(projections), op.estimated_cardinality);
 		order->children.push_back(std::move(plan));
 		plan = std::move(order);
 	}