duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -24,7 +24,7 @@ unique_ptr<TableFilterSet> CreateTableFilterSet(TableFilterSet &table_filters, v
 		if (column_index == DConstants::INVALID_INDEX) {
 			throw InternalException("Could not find column index for table filter");
 		}
-		table_filter_set->filters[column_index] = move(table_filter.second);
+		table_filter_set->filters[column_index] = std::move(table_filter.second);
 	}
 	return table_filter_set;
 }
@@ -33,10 +33,11 @@ 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, move(op.bind_data), op.column_ids,
-		                                                    op.estimated_cardinality, move(op.projected_input));
-		node->children.push_back(CreatePlan(move(op.children[0])));
-		return move(node);
+		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));
+		node->children.push_back(CreatePlan(std::move(op.children[0])));
+		return std::move(node);
 	}
 	if (!op.projected_input.empty()) {
 		throw InternalException("LogicalGet::project_input can only be set for table-in-out functions");
@@ -53,9 +54,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, move(op.bind_data),
+		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,
-		                                           move(table_filters), op.estimated_cardinality);
+		                                           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;
@@ -69,7 +70,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 				// a projection is not necessary if all columns have been requested in-order
 				// in that case we just return the node
 
-				return move(node);
+				return std::move(node);
 			}
 		}
 		// push a projection on top that does the projection
@@ -86,12 +87,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 			}
 		}
 
-		auto projection = make_unique<PhysicalProjection>(move(types), move(expressions), op.estimated_cardinality);
-		projection->children.push_back(move(node));
-		return move(projection);
+		auto projection =
+		    make_unique<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, move(op.bind_data), op.returned_types,
-		                                      op.column_ids, op.projection_ids, op.names, move(table_filters),
+		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);
 	}
 }

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

@@ -6,6 +6,7 @@
 #include "duckdb/main/config.hpp"
 #include "duckdb/execution/operator/persistent/physical_batch_insert.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 
 namespace duckdb {
 
@@ -44,35 +45,49 @@ bool PhysicalPlanGenerator::UseBatchIndex(PhysicalOperator &plan) {
 	return UseBatchIndex(context, plan);
 }
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op) {
-	unique_ptr<PhysicalOperator> plan;
-	if (!op.children.empty()) {
-		D_ASSERT(op.children.size() == 1);
-		plan = CreatePlan(*op.children[0]);
-	}
-	dependencies.AddDependency(op.table);
-
-	bool parallel_streaming_insert = !PreserveInsertionOrder(*plan);
-	bool use_batch_index = UseBatchIndex(*plan);
+unique_ptr<PhysicalOperator> DuckCatalog::PlanInsert(ClientContext &context, LogicalInsert &op,
+                                                     unique_ptr<PhysicalOperator> plan) {
+	bool parallel_streaming_insert = !PhysicalPlanGenerator::PreserveInsertionOrder(context, *plan);
+	bool use_batch_index = PhysicalPlanGenerator::UseBatchIndex(context, *plan);
 	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
 	if (op.return_chunk) {
 		// not supported for RETURNING (yet?)
 		parallel_streaming_insert = false;
 		use_batch_index = false;
 	}
+	if (op.action_type != OnConflictAction::THROW) {
+		// We don't support ON CONFLICT clause in batch insertion operation currently
+		use_batch_index = false;
+	}
+	if (op.action_type == OnConflictAction::UPDATE) {
+		// When we potentially need to perform updates, we have to check that row is not updated twice
+		// that currently needs to be done for every chunk, which would add a huge bottleneck to parallelized insertion
+		parallel_streaming_insert = false;
+	}
 	unique_ptr<PhysicalOperator> insert;
 	if (use_batch_index && !parallel_streaming_insert) {
-		insert = make_unique<PhysicalBatchInsert>(op.types, op.table, op.column_index_map, move(op.bound_defaults),
+		insert = make_unique<PhysicalBatchInsert>(op.types, op.table, op.column_index_map, std::move(op.bound_defaults),
 		                                          op.estimated_cardinality);
 	} else {
-		insert = make_unique<PhysicalInsert>(op.types, op.table, op.column_index_map, move(op.bound_defaults),
-		                                     op.estimated_cardinality, op.return_chunk,
-		                                     parallel_streaming_insert && num_threads > 1);
-	}
-	if (plan) {
-		insert->children.push_back(move(plan));
+		insert = make_unique<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),
+		    std::move(op.do_update_condition), std::move(op.on_conflict_filter), std::move(op.columns_to_fetch));
 	}
+	D_ASSERT(plan);
+	insert->children.push_back(std::move(plan));
 	return insert;
 }
 
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op) {
+	unique_ptr<PhysicalOperator> plan;
+	if (!op.children.empty()) {
+		D_ASSERT(op.children.size() == 1);
+		plan = CreatePlan(*op.children[0]);
+	}
+	dependencies.AddDependency(op.table);
+	return op.table->catalog->PlanInsert(context, op, std::move(plan));
+}
+
 } // namespace duckdb

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

@@ -14,22 +14,23 @@ 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, move(op.limit),
-		                                            move(op.offset), op.estimated_cardinality, true);
+		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);
 	} 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, move(op.limit),
-			                                   move(op.offset), op.estimated_cardinality);
+			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);
 		} 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, move(op.limit),
-			                                            move(op.offset), op.estimated_cardinality, false);
+			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->children.push_back(move(plan));
+	limit->children.push_back(std::move(plan));
 	return limit;
 }
 

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

@@ -9,10 +9,10 @@ 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, move(op.limit),
-	                                               move(op.offset), op.estimated_cardinality);
-	limit->children.push_back(move(plan));
-	return move(limit);
+	auto limit = make_unique<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);
 }
 
 } // namespace duckdb

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

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

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

@@ -0,0 +1,21 @@
+#include "duckdb/execution/operator/join/physical_positional_join.hpp"
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/planner/operator/logical_positional_join.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPositionalJoin &op) {
+	D_ASSERT(op.children.size() == 2);
+
+	auto left = CreatePlan(*op.children[0]);
+	auto right = CreatePlan(*op.children[1]);
+	if (left->type == PhysicalOperatorType::TABLE_SCAN && right->type == PhysicalOperatorType::TABLE_SCAN) {
+		return make_unique<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
+	} else {
+		return make_unique<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right),
+		                                           op.estimated_cardinality);
+	}
+}
+
+} // namespace duckdb

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

@@ -12,10 +12,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPrepare &o
 	if (!op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
 		op.prepared->types = plan->types;
-		op.prepared->plan = move(plan);
+		op.prepared->plan = std::move(plan);
 	}
 
-	return make_unique<PhysicalPrepare>(op.name, move(op.prepared), op.estimated_cardinality);
+	return make_unique<PhysicalPrepare>(op.name, std::move(op.prepared), op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -36,9 +36,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalProjection
 		}
 	}
 
-	auto projection = make_unique<PhysicalProjection>(op.types, move(op.expressions), op.estimated_cardinality);
-	projection->children.push_back(move(plan));
-	return move(projection);
+	auto projection = make_unique<PhysicalProjection>(op.types, std::move(op.expressions), op.estimated_cardinality);
+	projection->children.push_back(std::move(plan));
+	return std::move(projection);
 }
 
 } // namespace duckdb

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

@@ -20,11 +20,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalRecursiveC
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
 
-	auto cte =
-	    make_unique<PhysicalRecursiveCTE>(op.types, op.union_all, move(left), move(right), op.estimated_cardinality);
+	auto cte = make_unique<PhysicalRecursiveCTE>(op.types, op.union_all, std::move(left), std::move(right),
+	                                             op.estimated_cardinality);
 	cte->working_table = working_table;
 
-	return move(cte);
+	return std::move(cte);
 }
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op) {
@@ -36,10 +36,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op
 	// CreatePlan of a LogicalRecursiveCTE must have happened before.
 	auto cte = recursive_cte_tables.find(op.cte_index);
 	if (cte == recursive_cte_tables.end()) {
-		throw Exception("Referenced recursive CTE does not exist.");
+		throw InvalidInputException("Referenced recursive CTE does not exist.");
 	}
 	chunk_scan->collection = cte->second.get();
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb

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

@@ -13,7 +13,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSample &op
 	unique_ptr<PhysicalOperator> sample;
 	switch (op.sample_options->method) {
 	case SampleMethod::RESERVOIR_SAMPLE:
-		sample = make_unique<PhysicalReservoirSample>(op.types, move(op.sample_options), op.estimated_cardinality);
+		sample = make_unique<PhysicalReservoirSample>(op.types, std::move(op.sample_options), op.estimated_cardinality);
 		break;
 	case SampleMethod::SYSTEM_SAMPLE:
 	case SampleMethod::BERNOULLI_SAMPLE:
@@ -29,7 +29,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSample &op
 	default:
 		throw InternalException("Unimplemented sample method");
 	}
-	sample->children.push_back(move(plan));
+	sample->children.push_back(std::move(plan));
 	return sample;
 }
 

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

@@ -13,13 +13,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSetOperati
 	auto right = CreatePlan(*op.children[1]);
 
 	if (left->GetTypes() != right->GetTypes()) {
-		throw Exception("Type mismatch for SET OPERATION");
+		throw InvalidInputException("Type mismatch for SET OPERATION");
 	}
 
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_UNION:
 		// UNION
-		return make_unique<PhysicalUnion>(op.types, move(left), move(right), op.estimated_cardinality);
+		return make_unique<PhysicalUnion>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 	default: {
 		// EXCEPT/INTERSECT
 		D_ASSERT(op.type == LogicalOperatorType::LOGICAL_EXCEPT || op.type == LogicalOperatorType::LOGICAL_INTERSECT);
@@ -31,13 +31,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSetOperati
 			cond.left = make_unique<BoundReferenceExpression>(types[i], i);
 			cond.right = make_unique<BoundReferenceExpression>(types[i], i);
 			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			conditions.push_back(move(cond));
+			conditions.push_back(std::move(cond));
 		}
 		// EXCEPT is ANTI join
 		// INTERSECT is SEMI join
 		PerfectHashJoinStats join_stats; // used in inner joins only
 		JoinType join_type = op.type == LogicalOperatorType::LOGICAL_EXCEPT ? JoinType::ANTI : JoinType::SEMI;
-		return make_unique<PhysicalHashJoin>(op, move(left), move(right), move(conditions), join_type,
+		return make_unique<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(conditions), join_type,
 		                                     op.estimated_cardinality, join_stats);
 	}
 	}

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

@@ -41,9 +41,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalShow &op)
 	// 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 = move(collection);
+	chunk_scan->owned_collection = std::move(collection);
 	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb

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

@@ -16,26 +16,28 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op) {
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_ALTER:
-		return make_unique<PhysicalAlter>(unique_ptr_cast<ParseInfo, AlterInfo>(move(op.info)),
+		return make_unique<PhysicalAlter>(unique_ptr_cast<ParseInfo, AlterInfo>(std::move(op.info)),
 		                                  op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_DROP:
-		return make_unique<PhysicalDrop>(unique_ptr_cast<ParseInfo, DropInfo>(move(op.info)), op.estimated_cardinality);
+		return make_unique<PhysicalDrop>(unique_ptr_cast<ParseInfo, DropInfo>(std::move(op.info)),
+		                                 op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		return make_unique<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(move(op.info)),
+		return make_unique<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(std::move(op.info)),
 		                                        op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_VACUUM: {
-		auto result = make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
+		auto result = make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(std::move(op.info)),
 		                                          op.estimated_cardinality);
 		if (!op.children.empty()) {
 			auto child = CreatePlan(*op.children[0]);
-			result->children.push_back(move(child));
+			result->children.push_back(std::move(child));
 		}
-		return move(result);
+		return std::move(result);
 	}
 	case LogicalOperatorType::LOGICAL_LOAD:
-		return make_unique<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(move(op.info)), op.estimated_cardinality);
+		return make_unique<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(std::move(op.info)),
+		                                 op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_ATTACH:
-		return make_unique<PhysicalAttach>(unique_ptr_cast<ParseInfo, AttachInfo>(move(op.info)),
+		return make_unique<PhysicalAttach>(unique_ptr_cast<ParseInfo, AttachInfo>(std::move(op.info)),
 		                                   op.estimated_cardinality);
 	default:
 		throw NotImplementedException("Unimplemented type for logical simple operator");

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

@@ -10,9 +10,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalTopN &op)
 	auto plan = CreatePlan(*op.children[0]);
 
 	auto top_n =
-	    make_unique<PhysicalTopN>(op.types, move(op.orders), (idx_t)op.limit, op.offset, op.estimated_cardinality);
-	top_n->children.push_back(move(plan));
-	return move(top_n);
+	    make_unique<PhysicalTopN>(op.types, std::move(op.orders), (idx_t)op.limit, op.offset, op.estimated_cardinality);
+	top_n->children.push_back(std::move(plan));
+	return std::move(top_n);
 }
 
 } // namespace duckdb

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

@@ -7,9 +7,9 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUnnest &op) {
 	D_ASSERT(op.children.size() == 1);
 	auto plan = CreatePlan(*op.children[0]);
-	auto unnest = make_unique<PhysicalUnnest>(op.types, move(op.expressions), op.estimated_cardinality);
-	unnest->children.push_back(move(plan));
-	return move(unnest);
+	auto unnest = make_unique<PhysicalUnnest>(op.types, std::move(op.expressions), op.estimated_cardinality);
+	unnest->children.push_back(std::move(plan));
+	return std::move(unnest);
 }
 
 } // namespace duckdb

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

@@ -2,21 +2,28 @@
 #include "duckdb/execution/operator/persistent/physical_update.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/operator/logical_update.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 
 namespace duckdb {
 
+unique_ptr<PhysicalOperator> DuckCatalog::PlanUpdate(ClientContext &context, LogicalUpdate &op,
+                                                     unique_ptr<PhysicalOperator> plan) {
+	auto update =
+	    make_unique<PhysicalUpdate>(op.types, *op.table, op.table->GetStorage(), op.columns, std::move(op.expressions),
+	                                std::move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
+
+	update->update_is_del_and_insert = op.update_is_del_and_insert;
+	update->children.push_back(std::move(plan));
+	return std::move(update);
+}
+
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op) {
 	D_ASSERT(op.children.size() == 1);
 
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
-	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
-
-	update->update_is_del_and_insert = op.update_is_del_and_insert;
-	update->children.push_back(move(plan));
-	return move(update);
+	return op.table->catalog->PlanUpdate(context, op, std::move(plan));
 }
 
 } // namespace duckdb

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

@@ -42,6 +42,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 	}
 #endif
 
+	op.estimated_cardinality = op.EstimateCardinality(context);
+
 	// Slice types
 	auto types = op.types;
 	const auto output_idx = types.size() - op.expressions.size();
@@ -84,19 +86,19 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 		// Extract the matching expressions
 		vector<unique_ptr<Expression>> select_list;
 		for (const auto &expr_idx : matching) {
-			select_list.emplace_back(move(op.expressions[expr_idx]));
+			select_list.emplace_back(std::move(op.expressions[expr_idx]));
 			types.emplace_back(op.types[output_idx + expr_idx]);
 		}
 
 		// Chain the new window operator on top of the plan
 		unique_ptr<PhysicalOperator> window;
 		if (process_streaming) {
-			window = make_unique<PhysicalStreamingWindow>(types, move(select_list), op.estimated_cardinality);
+			window = make_unique<PhysicalStreamingWindow>(types, std::move(select_list), op.estimated_cardinality);
 		} else {
-			window = make_unique<PhysicalWindow>(types, move(select_list), op.estimated_cardinality);
+			window = make_unique<PhysicalWindow>(types, std::move(select_list), op.estimated_cardinality);
 		}
-		window->children.push_back(move(plan));
-		plan = move(window);
+		window->children.push_back(std::move(plan));
+		plan = std::move(window);
 
 		// Remember the projection order if we changed it
 		if (!streaming_windows.empty() || !blocking_windows.empty() || !evaluation_order.empty()) {
@@ -116,9 +118,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 			const auto expr_idx = evaluation_order[i] + output_idx;
 			select_list[expr_idx] = make_unique<BoundReferenceExpression>(op.types[expr_idx], i + output_idx);
 		}
-		auto proj = make_unique<PhysicalProjection>(op.types, move(select_list), op.estimated_cardinality);
-		proj->children.push_back(move(plan));
-		plan = move(proj);
+		auto proj = make_unique<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
+		proj->children.push_back(std::move(plan));
+		plan = std::move(proj);
 	}
 
 	return plan;

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

@@ -121,6 +121,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
 		plan = CreatePlan((LogicalCrossProduct &)op);
 		break;
+	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
+		plan = CreatePlan((LogicalPositionalJoin &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
@@ -205,7 +208,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 			throw InternalException("Missing PhysicalOperator for Extension Operator");
 		}
 		break;
-	default: {
+	case LogicalOperatorType::LOGICAL_JOIN:
+	case LogicalOperatorType::LOGICAL_INVALID: {
 		throw NotImplementedException("Unimplemented logical operator type!");
 	}
 	}

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -196,7 +196,7 @@ void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkSta
 	llstate.ht->Finalize();
 
 	// at this point we just collect them the PhysicalHashAggregateFinalizeTask (below) will merge them in parallel
-	gstate.intermediate_hts.push_back(move(llstate.ht));
+	gstate.intermediate_hts.push_back(std::move(llstate.ht));
 }
 
 bool RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState &gstate_p) const {
@@ -267,7 +267,7 @@ class RadixAggregateFinalizeTask : public ExecutorTask {
 public:
 	RadixAggregateFinalizeTask(Executor &executor, shared_ptr<Event> event_p, RadixHTGlobalState &state_p,
 	                           idx_t radix_p)
-	    : ExecutorTask(executor), event(move(event_p)), state(state_p), radix(radix_p) {
+	    : ExecutorTask(executor), event(std::move(event_p)), state(state_p), radix(radix_p) {
 	}
 
 	static void FinalizeHT(RadixHTGlobalState &gstate, idx_t radix) {

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -118,7 +118,7 @@ void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
 			input.Slice(sel, append_to_next_sample);
 		}
 		// now our first sample is filled: append it to the set of finished samples
-		finished_samples.push_back(move(current_sample));
+		finished_samples.push_back(std::move(current_sample));
 
 		// allocate a new sample, and potentially add the remainder of the current input to that sample
 		current_sample = make_unique<ReservoirSample>(allocator, reservoir_sample_size, random.NextRandomInteger());
@@ -162,7 +162,7 @@ void ReservoirSamplePercentage::Finalize() {
 			}
 			new_sample->AddToReservoir(*chunk);
 		}
-		finished_samples.push_back(move(new_sample));
+		finished_samples.push_back(std::move(new_sample));
 	}
 	is_finalized = true;
 }

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -98,7 +98,7 @@ void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
 
 void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
 	D_ASSERT(begin <= end);
-	if (begin == end) {
+	if (begin == end || inputs.ColumnCount() == 0) {
 		return;
 	}
 
@@ -107,6 +107,7 @@ void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end)
 	if (l_idx == 0) {
 		ExtractFrame(begin, end);
 		AggregateInputData aggr_input_data(bind_info, Allocator::DefaultAllocator());
+		D_ASSERT(inputs.data.size() > 0);
 		aggregate.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
 	} else {
 		// find out where the states begin

package/src/duckdb/src/function/aggregate/distributive/approx_count.cpp

@@ -93,8 +93,8 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = (ApproxDistinctCountState **)sdata.data;
 
-	uint64_t *indices;
-	uint8_t *counts;
+	uint64_t *indices = nullptr;
+	uint8_t *counts = nullptr;
 	for (idx_t i = 0; i < count; i++) {
 		auto agg_state = states[sdata.sel->get_index(i)];
 		if (!agg_state->log) {