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

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

@@ -9,7 +9,9 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+#include "duckdb/function/function_binder.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+
 namespace duckdb {
 
 static uint32_t RequiredBitsForValue(uint32_t n) {
@@ -50,23 +52,20 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 			// for small types we can just set the stats to [type_min, type_max]
 			switch (group_type.InternalType()) {
 			case PhysicalType::INT8:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
-				break;
 			case PhysicalType::INT16:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
 				break;
 			default:
 				// type is too large and there are no stats: skip perfect hashing
 				return false;
 			}
-			// we had no stats before, so we have no clue if there are null values or not
-			stats->validity_stats = make_unique<ValidityStatistics>(true);
+			// construct stats with the min and max value of the type
+			stats = NumericStats::CreateUnknown(group_type).ToUnique();
+			NumericStats::SetMin(*stats, Value::MinimumValue(group_type));
+			NumericStats::SetMax(*stats, Value::MaximumValue(group_type));
 		}
-		auto &nstats = (NumericStatistics &)*stats;
+		auto &nstats = *stats;
 
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
+		if (!NumericStats::HasMinMax(nstats)) {
 			return false;
 		}
 		// we have a min and a max value for the stats: use that to figure out how many bits we have
@@ -75,17 +74,17 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		int64_t range;
 		switch (group_type.InternalType()) {
 		case PhysicalType::INT8:
-			range = int64_t(nstats.max.GetValueUnsafe<int8_t>()) - int64_t(nstats.min.GetValueUnsafe<int8_t>());
+			range = int64_t(NumericStats::GetMax<int8_t>(nstats)) - int64_t(NumericStats::GetMin<int8_t>(nstats));
 			break;
 		case PhysicalType::INT16:
-			range = int64_t(nstats.max.GetValueUnsafe<int16_t>()) - int64_t(nstats.min.GetValueUnsafe<int16_t>());
+			range = int64_t(NumericStats::GetMax<int16_t>(nstats)) - int64_t(NumericStats::GetMin<int16_t>(nstats));
 			break;
 		case PhysicalType::INT32:
-			range = int64_t(nstats.max.GetValueUnsafe<int32_t>()) - int64_t(nstats.min.GetValueUnsafe<int32_t>());
+			range = int64_t(NumericStats::GetMax<int32_t>(nstats)) - int64_t(NumericStats::GetMin<int32_t>(nstats));
 			break;
 		case PhysicalType::INT64:
-			if (!TrySubtractOperator::Operation(nstats.max.GetValueUnsafe<int64_t>(),
-			                                    nstats.min.GetValueUnsafe<int64_t>(), range)) {
+			if (!TrySubtractOperator::Operation(NumericStats::GetMax<int64_t>(nstats),
+			                                    NumericStats::GetMin<int64_t>(nstats), range)) {
 				return false;
 			}
 			break;
@@ -108,7 +107,7 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		}
 	}
 	for (auto &expression : op.expressions) {
-		auto &aggregate = (BoundAggregateExpression &)*expression;
+		auto &aggregate = expression->Cast<BoundAggregateExpression>();
 		if (aggregate.IsDistinct() || !aggregate.function.combine) {
 			// distinct aggregates are not supported in perfect hash aggregates
 			return false;
@@ -130,7 +129,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 		// special case: aggregate entire columns together
 		bool use_simple_aggregation = true;
 		for (auto &expression : op.expressions) {
-			auto &aggregate = (BoundAggregateExpression &)*expression;
+			auto &aggregate = expression->Cast<BoundAggregateExpression>();
 			if (!aggregate.function.simple_update) {
 				// unsupported aggregate for simple aggregation: use hash aggregation
 				use_simple_aggregation = false;
@@ -138,10 +137,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 			}
 		}
 		if (use_simple_aggregation) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalUngroupedAggregate>(
-			    op.types, std::move(op.expressions), op.estimated_cardinality);
+			groupby = make_uniq_base<PhysicalOperator, PhysicalUngroupedAggregate>(op.types, std::move(op.expressions),
+			                                                                       op.estimated_cardinality);
 		} else {
-			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(
+			groupby = make_uniq_base<PhysicalOperator, PhysicalHashAggregate>(
 			    context, op.types, std::move(op.expressions), op.estimated_cardinality);
 		}
 	} else {
@@ -149,11 +148,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 		// use a perfect hash aggregate if possible
 		vector<idx_t> required_bits;
 		if (CanUsePerfectHashAggregate(context, op, required_bits)) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalPerfectHashAggregate>(
+			groupby = make_uniq_base<PhysicalOperator, PhysicalPerfectHashAggregate>(
 			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.group_stats),
 			    std::move(required_bits), op.estimated_cardinality);
 		} else {
-			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(
+			groupby = make_uniq_base<PhysicalOperator, PhysicalHashAggregate>(
 			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.grouping_sets),
 			    std::move(op.grouping_functions), op.estimated_cardinality);
 		}
@@ -169,24 +168,31 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 	vector<unique_ptr<Expression>> expressions;
 	vector<LogicalType> types;
 
+	// bind sorted aggregates
+	for (auto &aggr : aggregates) {
+		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
+		if (bound_aggr.order_bys) {
+			// sorted aggregate!
+			FunctionBinder::BindSortedAggregate(context, bound_aggr, groups);
+		}
+	}
 	for (auto &group : groups) {
-		auto ref = make_unique<BoundReferenceExpression>(group->return_type, expressions.size());
+		auto ref = make_uniq<BoundReferenceExpression>(group->return_type, expressions.size());
 		types.push_back(group->return_type);
 		expressions.push_back(std::move(group));
 		group = std::move(ref);
 	}
-
 	for (auto &aggr : aggregates) {
-		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
+		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
 		for (auto &child : bound_aggr.children) {
-			auto ref = make_unique<BoundReferenceExpression>(child->return_type, expressions.size());
+			auto ref = make_uniq<BoundReferenceExpression>(child->return_type, expressions.size());
 			types.push_back(child->return_type);
 			expressions.push_back(std::move(child));
 			child = std::move(ref);
 		}
 		if (bound_aggr.filter) {
 			auto &filter = bound_aggr.filter;
-			auto ref = make_unique<BoundReferenceExpression>(filter->return_type, expressions.size());
+			auto ref = make_uniq<BoundReferenceExpression>(filter->return_type, expressions.size());
 			types.push_back(filter->return_type);
 			expressions.push_back(std::move(filter));
 			bound_aggr.filter = std::move(ref);
@@ -196,7 +202,7 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 		return child;
 	}
 	auto projection =
-	    make_unique<PhysicalProjection>(std::move(types), std::move(expressions), child->estimated_cardinality);
+	    make_uniq<PhysicalProjection>(std::move(types), std::move(expressions), child->estimated_cardinality);
 	projection->children.push_back(std::move(child));
 	return std::move(projection);
 }

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

@@ -13,8 +13,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAnyJoin &o
 	auto right = CreatePlan(*op.children[1]);
 
 	// create the blockwise NL join
-	return make_unique<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(op.condition),
-	                                            op.join_type, op.estimated_cardinality);
+	return make_uniq<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(op.condition),
+	                                          op.join_type, op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -0,0 +1,97 @@
+#include "duckdb/execution/operator/aggregate/physical_window.hpp"
+#include "duckdb/execution/operator/join/physical_iejoin.hpp"
+#include "duckdb/execution/operator/projection/physical_projection.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &op) {
+	// now visit the children
+	D_ASSERT(op.children.size() == 2);
+	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
+	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
+	auto left = CreatePlan(*op.children[0]);
+	auto right = CreatePlan(*op.children[1]);
+	D_ASSERT(left && right);
+
+	//	Validate
+	vector<idx_t> equi_indexes;
+	auto asof_idx = op.conditions.size();
+	for (size_t c = 0; c < op.conditions.size(); ++c) {
+		auto &cond = op.conditions[c];
+		switch (cond.comparison) {
+		case ExpressionType::COMPARE_EQUAL:
+		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+			equi_indexes.emplace_back(c);
+			break;
+		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			D_ASSERT(asof_idx == op.conditions.size());
+			asof_idx = c;
+			break;
+		default:
+			throw InternalException("Invalid ASOF JOIN comparison");
+		}
+	}
+	D_ASSERT(asof_idx < op.conditions.size());
+
+	//	Temporary implementation: IEJoin of Window
+	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_temp
+	auto &asof_comp = op.conditions[asof_idx];
+	auto &asof_column = asof_comp.right;
+	auto asof_type = asof_column->return_type;
+	auto asof_temp = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
+	asof_temp->children.emplace_back(asof_column->Copy());
+	asof_temp->offset_expr = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
+	asof_temp->default_expr = make_uniq<BoundConstantExpression>(Value::Infinity(asof_type));
+	for (auto equi_idx : equi_indexes) {
+		asof_temp->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
+	}
+	asof_temp->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
+	asof_temp->start = WindowBoundary::UNBOUNDED_PRECEDING;
+	asof_temp->end = WindowBoundary::CURRENT_ROW_ROWS;
+
+	vector<unique_ptr<Expression>> window_select;
+	window_select.emplace_back(std::move(asof_temp));
+
+	auto window_types = right->types;
+	window_types.emplace_back(asof_type);
+
+	auto window = make_uniq<PhysicalWindow>(window_types, std::move(window_select), rhs_cardinality);
+	window->children.emplace_back(std::move(right));
+
+	// IEJoin(left, window, conditions || asof_column < asof_temp)
+	JoinCondition asof_upper;
+	asof_upper.left = asof_comp.left->Copy();
+	asof_upper.right = make_uniq<BoundReferenceExpression>(asof_type, window_types.size() - 1);
+	asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
+
+	// We have an equality condition, so we may have to deal with projection maps.
+	// IEJoin does not (currently) support them, so we have to do it manually
+	auto proj_types = op.types;
+	op.types.clear();
+
+	auto lhs_types = op.children[0]->types;
+	op.types = lhs_types;
+
+	auto rhs_types = op.children[1]->types;
+	op.types.insert(op.types.end(), rhs_types.begin(), rhs_types.end());
+
+	op.types.emplace_back(asof_type);
+	op.conditions.emplace_back(std::move(asof_upper));
+	auto iejoin = make_uniq<PhysicalIEJoin>(op, std::move(left), std::move(window), std::move(op.conditions),
+	                                        op.join_type, op.estimated_cardinality);
+
+	//	Project away asof_temp and anything from the projection maps
+	auto proj = PhysicalProjection::CreateJoinProjection(proj_types, lhs_types, rhs_types, op.left_projection_map,
+	                                                     op.right_projection_map, lhs_cardinality);
+	proj->children.push_back(std::move(iejoin));
+
+	return proj;
+}
+
+} // namespace duckdb

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

@@ -9,10 +9,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalColumnData
 	D_ASSERT(op.collection);
 
 	// create a PhysicalChunkScan pointing towards the owned collection
-	auto chunk_scan =
-	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = std::move(op.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(op.collection));
 	return std::move(chunk_scan);
 }
 

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

@@ -10,24 +10,20 @@
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 
 namespace duckdb {
 
-static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData *bind_data, PhysicalTableScan &scan) {
-	if (!bind_data) {
-		// not a table scan
-		return false;
-	}
-	auto table = bind_data->table;
+static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData &bind_data, PhysicalTableScan &scan) {
+	auto table = bind_data.table;
 	auto &transaction = DuckTransaction::Get(context, *table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
-	if (local_storage.Find(table->GetStoragePtr())) {
+	if (local_storage.Find(table->GetStorage())) {
 		// transaction local appends: skip index join
 		return false;
 	}
@@ -92,19 +88,21 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	}
 	// with integral internal types
 	for (auto &&join_stat : op.join_stats) {
-		if (!TypeIsInteger(join_stat->type.InternalType()) || join_stat->type.InternalType() == PhysicalType::INT128) {
+		if (!TypeIsInteger(join_stat->GetType().InternalType()) ||
+		    join_stat->GetType().InternalType() == PhysicalType::INT128) {
 			// perfect join not possible for non-integral types or hugeint
 			return;
 		}
 	}
 
 	// and when the build range is smaller than the threshold
-	auto stats_build = reinterpret_cast<NumericStatistics *>(op.join_stats[0].get()); // lhs stats
-	if (stats_build->min.IsNull() || stats_build->max.IsNull()) {
+	auto &stats_build = *op.join_stats[0].get(); // lhs stats
+	if (!NumericStats::HasMinMax(stats_build)) {
 		return;
 	}
 	int64_t min_value, max_value;
-	if (!ExtractNumericValue(stats_build->min, min_value) || !ExtractNumericValue(stats_build->max, max_value)) {
+	if (!ExtractNumericValue(NumericStats::Min(stats_build), min_value) ||
+	    !ExtractNumericValue(NumericStats::Max(stats_build), max_value)) {
 		return;
 	}
 	int64_t build_range;
@@ -113,65 +111,127 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	}
 
 	// Fill join_stats for invisible join
-	auto stats_probe = reinterpret_cast<NumericStatistics *>(op.join_stats[1].get()); // rhs stats
+	auto &stats_probe = *op.join_stats[1].get(); // rhs stats
+	if (!NumericStats::HasMinMax(stats_probe)) {
+		return;
+	}
 
 	// The max size our build must have to run the perfect HJ
 	const idx_t MAX_BUILD_SIZE = 1000000;
-	join_state.probe_min = stats_probe->min;
-	join_state.probe_max = stats_probe->max;
-	join_state.build_min = stats_build->min;
-	join_state.build_max = stats_build->max;
+	join_state.probe_min = NumericStats::Min(stats_probe);
+	join_state.probe_max = NumericStats::Max(stats_probe);
+	join_state.build_min = NumericStats::Min(stats_build);
+	join_state.build_max = NumericStats::Max(stats_build);
 	join_state.estimated_cardinality = op.estimated_cardinality;
 	join_state.build_range = build_range;
-	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.IsNull() || stats_probe->min.IsNull()) {
+	if (join_state.build_range > MAX_BUILD_SIZE) {
 		return;
 	}
-	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
+	if (NumericStats::Min(stats_build) <= NumericStats::Min(stats_probe) &&
+	    NumericStats::Max(stats_probe) <= NumericStats::Max(stats_build)) {
 		join_state.is_probe_in_domain = true;
 	}
 	join_state.is_build_small = true;
 	return;
 }
 
-static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **result_index) {
-	tbl->table->GetStorage().info->indexes.Scan([&](Index &index) {
+static optional_ptr<Index> CanUseIndexJoin(TableScanBindData &tbl, Expression &expr) {
+	optional_ptr<Index> result;
+	tbl.table->GetStorage().info->indexes.Scan([&](Index &index) {
 		if (index.unbound_expressions.size() != 1) {
 			return false;
 		}
 		if (expr.alias == index.unbound_expressions[0]->alias) {
-			*result_index = &index;
+			result = &index;
 			return true;
 		}
 		return false;
 	});
+	return result;
 }
 
-void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
-                        PhysicalOperator *left, PhysicalOperator *right) {
+optional_ptr<Index> CheckIndexJoin(ClientContext &context, LogicalComparisonJoin &op, PhysicalOperator &plan,
+                                   Expression &condition) {
+	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return nullptr;
+	}
 	// check if one of the tables has an index on column
-	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
-		// check if one of the children are table scans and if they have an index in the join attribute
-		// (op.condition)
-		if (left->type == PhysicalOperatorType::TABLE_SCAN) {
-			auto &tbl_scan = (PhysicalTableScan &)*left;
-			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(context, tbl, tbl_scan)) {
-				CanUseIndexJoin(tbl, *op.conditions[0].left, left_index);
-			}
-		}
-		if (right->type == PhysicalOperatorType::TABLE_SCAN) {
-			auto &tbl_scan = (PhysicalTableScan &)*right;
-			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(context, tbl, tbl_scan)) {
-				CanUseIndexJoin(tbl, *op.conditions[0].right, right_index);
-			}
-		}
+	if (op.join_type != JoinType::INNER) {
+		return nullptr;
+	}
+	if (op.conditions.size() != 1) {
+		return nullptr;
+	}
+	// check if the child is (1) a table scan, and (2) has an index on the join condition
+	if (plan.type != PhysicalOperatorType::TABLE_SCAN) {
+		return nullptr;
+	}
+	auto &tbl_scan = plan.Cast<PhysicalTableScan>();
+	auto tbl_data = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
+	if (!tbl_data) {
+		return nullptr;
+	}
+	optional_ptr<Index> result;
+	if (CanPlanIndexJoin(context, *tbl_data, tbl_scan)) {
+		result = CanUseIndexJoin(*tbl_data, condition);
+	}
+	return result;
+}
+
+static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> &plan,
+                          unique_ptr<PhysicalOperator> &left, unique_ptr<PhysicalOperator> &right,
+                          optional_ptr<Index> index, bool swap_condition = false) {
+	if (!index) {
+		return false;
 	}
+	// index joins are not supported if there are pushed down table filters
+	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
+	auto &tbl_scan = (PhysicalTableScan &)*right;
+	//	if (tbl_scan.table_filters && !tbl_scan.table_filters->filters.empty()) {
+	//		return false;
+	//	}
+	// index joins are disabled if enable_optimizer is false
+	if (!ClientConfig::GetConfig(context).enable_optimizer) {
+		return false;
+	}
+	// check if the cardinality difference justifies an index join
+	if (!((ClientConfig::GetConfig(context).force_index_join ||
+	       left->estimated_cardinality < 0.01 * right->estimated_cardinality))) {
+		return false;
+	}
+
+	// plan the index join
+	if (swap_condition) {
+		swap(op.conditions[0].left, op.conditions[0].right);
+		swap(op.left_projection_map, op.right_projection_map);
+	}
+	plan = make_uniq<PhysicalIndexJoin>(op, std::move(left), std::move(right), std::move(op.conditions), op.join_type,
+	                                    op.left_projection_map, op.right_projection_map, tbl_scan.column_ids, *index,
+	                                    !swap_condition, op.estimated_cardinality);
+	return true;
+}
+
+static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> &plan,
+                          unique_ptr<PhysicalOperator> &left, unique_ptr<PhysicalOperator> &right) {
+	if (op.conditions.empty()) {
+		return false;
+	}
+	// check if we can plan an index join on the RHS
+	auto right_index = CheckIndexJoin(context, op, *right, *op.conditions[0].right);
+	if (PlanIndexJoin(context, op, plan, left, right, right_index)) {
+		return true;
+	}
+	// else check if we can plan an index join on the left side
+	auto left_index = CheckIndexJoin(context, op, *left, *op.conditions[0].left);
+	if (PlanIndexJoin(context, op, plan, right, left, left_index, true)) {
+		return true;
+	}
+	return false;
 }
 
 static void RewriteJoinCondition(Expression &expr, idx_t offset) {
 	if (expr.type == ExpressionType::BOUND_REF) {
-		auto &ref = (BoundReferenceExpression &)expr;
+		auto &ref = expr.Cast<BoundReferenceExpression>();
 		ref.index += offset;
 	}
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { RewriteJoinCondition(child, offset); });
@@ -184,11 +244,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
+	left->estimated_cardinality = lhs_cardinality;
+	right->estimated_cardinality = rhs_cardinality;
 	D_ASSERT(left && right);
 
 	if (op.conditions.empty()) {
 		// no conditions: insert a cross product
-		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);
 	}
 
 	bool has_equality = false;
@@ -218,29 +280,16 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 
 	unique_ptr<PhysicalOperator> plan;
 	if (has_equality) {
-		Index *left_index {}, *right_index {};
-		TransformIndexJoin(context, op, &left_index, &right_index, left.get(), right.get());
-		if (left_index &&
-		    (ClientConfig::GetConfig(context).force_index_join || rhs_cardinality < 0.01 * lhs_cardinality)) {
-			auto &tbl_scan = (PhysicalTableScan &)*left;
-			swap(op.conditions[0].left, op.conditions[0].right);
-			return make_unique<PhysicalIndexJoin>(op, std::move(right), std::move(left), std::move(op.conditions),
-			                                      op.join_type, op.right_projection_map, op.left_projection_map,
-			                                      tbl_scan.column_ids, left_index, false, op.estimated_cardinality);
-		}
-		if (right_index &&
-		    (ClientConfig::GetConfig(context).force_index_join || lhs_cardinality < 0.01 * rhs_cardinality)) {
-			auto &tbl_scan = (PhysicalTableScan &)*right;
-			return make_unique<PhysicalIndexJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                      op.join_type, op.left_projection_map, op.right_projection_map,
-			                                      tbl_scan.column_ids, right_index, true, op.estimated_cardinality);
+		// check if we can use an index join
+		if (PlanIndexJoin(context, op, plan, left, right)) {
+			return plan;
 		}
 		// Equality join with small number of keys : possible perfect join optimization
 		PerfectHashJoinStats perfect_join_stats;
 		CheckForPerfectJoinOpt(op, perfect_join_stats);
-		plan = make_unique<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-		                                     op.join_type, op.left_projection_map, op.right_projection_map,
-		                                     std::move(op.delim_types), op.estimated_cardinality, perfect_join_stats);
+		plan = make_uniq<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+		                                   op.join_type, op.left_projection_map, op.right_projection_map,
+		                                   std::move(op.delim_types), op.estimated_cardinality, perfect_join_stats);
 
 	} else {
 		static constexpr const idx_t NESTED_LOOP_JOIN_THRESHOLD = 5;
@@ -262,24 +311,24 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 			can_merge = false;
 		}
 		if (can_iejoin) {
-			plan = make_unique<PhysicalIEJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                   op.join_type, op.estimated_cardinality);
+			plan = make_uniq<PhysicalIEJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                 op.join_type, op.estimated_cardinality);
 		} else if (can_merge) {
 			// range join: use piecewise merge join
 			plan =
-			    make_unique<PhysicalPiecewiseMergeJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                            op.join_type, op.estimated_cardinality);
+			    make_uniq<PhysicalPiecewiseMergeJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                          op.join_type, op.estimated_cardinality);
 		} else if (PhysicalNestedLoopJoin::IsSupported(op.conditions, op.join_type)) {
 			// inequality join: use nested loop
-			plan = make_unique<PhysicalNestedLoopJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                           op.join_type, op.estimated_cardinality);
+			plan = make_uniq<PhysicalNestedLoopJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                         op.join_type, op.estimated_cardinality);
 		} else {
 			for (auto &cond : op.conditions) {
 				RewriteJoinCondition(*cond.right, left->types.size());
 			}
 			auto condition = JoinCondition::CreateExpression(std::move(op.conditions));
-			plan = make_unique<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(condition),
-			                                            op.join_type, op.estimated_cardinality);
+			plan = make_uniq<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(condition),
+			                                          op.join_type, op.estimated_cardinality);
 		}
 	}
 	return plan;

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

@@ -13,11 +13,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile
 		op.file_path += ".tmp";
 	}
 	// COPY from select statement to file
-	auto copy =
-	    make_unique<PhysicalCopyToFile>(op.types, op.function, std::move(op.bind_data), op.estimated_cardinality);
+	auto copy = make_uniq<PhysicalCopyToFile>(op.types, op.function, std::move(op.bind_data), op.estimated_cardinality);
 	copy->file_path = op.file_path;
 	copy->use_tmp_file = op.use_tmp_file;
-	copy->allow_overwrite = op.allow_overwrite;
+	copy->overwrite_or_ignore = op.overwrite_or_ignore;
+	copy->filename_pattern = op.filename_pattern;
 	copy->per_thread_output = op.per_thread_output;
 	copy->partition_output = op.partition_output;
 	copy->partition_columns = op.partition_columns;

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

@@ -13,19 +13,19 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreate &op) {
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return make_unique<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(std::move(op.info)),
-		                                           op.estimated_cardinality);
+		return make_uniq<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(std::move(op.info)),
+		                                         op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return make_unique<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(op.info)),
-		                                       op.estimated_cardinality);
+		return make_uniq<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(op.info)),
+		                                     op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return make_unique<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(std::move(op.info)),
-		                                         op.estimated_cardinality);
+		return make_uniq<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(std::move(op.info)),
+		                                       op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return make_unique<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(std::move(op.info)),
-		                                           op.estimated_cardinality);
+		return make_uniq<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(std::move(op.info)),
+		                                         op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE: {
-		unique_ptr<PhysicalOperator> create = make_unique<PhysicalCreateType>(
+		unique_ptr<PhysicalOperator> create = make_uniq<PhysicalCreateType>(
 		    unique_ptr_cast<CreateInfo, CreateTypeInfo>(std::move(op.info)), op.estimated_cardinality);
 		if (!op.children.empty()) {
 			D_ASSERT(op.children.size() == 1);