duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/src/optimizer/optimizer.cpp

@@ -43,6 +43,7 @@ Optimizer::Optimizer(Binder &binder, ClientContext &context) : context(context),
 	rewriter.rules.push_back(make_uniq<RegexOptimizationRule>(rewriter));
 	rewriter.rules.push_back(make_uniq<EmptyNeedleRemovalRule>(rewriter));
 	rewriter.rules.push_back(make_uniq<EnumComparisonRule>(rewriter));
+	rewriter.rules.push_back(make_uniq<TimeStampComparison>(context, rewriter));
 
 #ifdef DEBUG
 	for (auto &rule : rewriter.rules) {
@@ -193,7 +194,8 @@ unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan
 
 	for (auto &optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) {
 		RunOptimizer(OptimizerType::EXTENSION, [&]() {
-			optimizer_extension.optimize_function(context, optimizer_extension.optimizer_info.get(), plan);
+			OptimizerExtensionInput input {GetContext(), *this, optimizer_extension.optimizer_info.get()};
+			optimizer_extension.optimize_function(input, plan);
 		});
 	}
 

package/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp

@@ -37,7 +37,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<Logical
 
 	// pushdown into AGGREGATE and GROUP BY
 	// we cannot push expressions that refer to the aggregate
-	FilterPushdown child_pushdown(optimizer);
+	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
 	for (idx_t i = 0; i < filters.size(); i++) {
 		auto &f = *filters[i];
 		if (f.bindings.find(aggr.aggregate_index) != f.bindings.end()) {
@@ -87,7 +87,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<Logical
 			return make_uniq<LogicalEmptyResult>(std::move(op));
 		}
 		// erase the filter from here
-		filters.erase(filters.begin() + i);
+		filters.erase_at(i);
 		i--;
 	}
 	child_pushdown.GenerateFilters();

package/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp

@@ -8,7 +8,7 @@ using Filter = FilterPushdown::Filter;
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->children.size() > 1);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
+	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
 	vector<unique_ptr<Expression>> join_expressions;
 	auto join_ref_type = JoinRefType::REGULAR;
 	switch (op->type) {

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -64,7 +64,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return FinishPushdown(std::move(op));
 	}
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
+	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
 	// for a comparison join we create a FilterCombiner that checks if we can push conditions on LHS join conditions
 	// into the RHS of the join
 	FilterCombiner filter_combiner(optimizer);
@@ -91,7 +91,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 			}
 			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
+			filters.erase_at(i);
 			i--;
 		} else {
 			// bindings match right side or both sides: we cannot directly push it into the right

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -16,7 +16,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN || op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
 
 	right_bindings.insert(comp_join.mark_index);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
+	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
 #ifdef DEBUG
 	bool simplified_mark_join = false;
 #endif
@@ -27,7 +27,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 			// bindings match left side: push into left
 			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
+			filters.erase_at(i);
 			i--;
 		} else if (side == JoinSide::RIGHT) {
 #ifdef DEBUG
@@ -35,13 +35,13 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 #endif
 			// this filter references the marker
 			// we can turn this into a SEMI join if the filter is on only the marker
-			if (filters[i]->filter->type == ExpressionType::BOUND_COLUMN_REF) {
+			if (filters[i]->filter->type == ExpressionType::BOUND_COLUMN_REF && convert_mark_joins) {
 				// filter just references the marker: turn into semi join
 #ifdef DEBUG
 				simplified_mark_join = true;
 #endif
 				join.join_type = JoinType::SEMI;
-				filters.erase(filters.begin() + i);
+				filters.erase_at(i);
 				i--;
 				continue;
 			}
@@ -61,13 +61,13 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 							break;
 						}
 					}
-					if (all_null_values_are_equal) {
+					if (all_null_values_are_equal && convert_mark_joins) {
 #ifdef DEBUG
 						simplified_mark_join = true;
 #endif
 						// all null values are equal, convert to ANTI join
 						join.join_type = JoinType::ANTI;
-						filters.erase(filters.begin() + i);
+						filters.erase_at(i);
 						i--;
 						continue;
 					}

package/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp

@@ -43,7 +43,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<Logica
 	// push filter through logical projection
 	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
 	// we can rewrite them by replacing those references with the expression of the LogicalProjection node
-	FilterPushdown child_pushdown(optimizer);
+	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
 	// There are some expressions can not be pushed down. We should keep them
 	// and add an extra filter operator.
 	vector<unique_ptr<Expression>> remain_expressions;

package/src/duckdb/src/optimizer/pushdown/pushdown_semi_anti_join.cpp

@@ -17,7 +17,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSemiAntiJoin(unique_ptr<Logi
 
 	// push all current filters down the left side
 	op->children[0] = Rewrite(std::move(op->children[0]));
-	FilterPushdown right_pushdown(optimizer);
+	FilterPushdown right_pushdown(optimizer, convert_mark_joins);
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
 
 	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;

package/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp

@@ -40,7 +40,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 	}
 
 	// pushdown into set operation, we can duplicate the condition and pushdown the expressions into both sides
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
+	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
 	for (idx_t i = 0; i < filters.size(); i++) {
 		// first create a copy of the filter
 		auto right_filter = make_uniq<Filter>();

package/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp

@@ -9,7 +9,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<Logica
                                                                unordered_set<idx_t> &left_bindings,
                                                                unordered_set<idx_t> &right_bindings) {
 	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::SINGLE);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
+	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
 	// now check the set of filters
 	for (idx_t i = 0; i < filters.size(); i++) {
 		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
@@ -17,7 +17,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<Logica
 			// bindings match left side: push into left
 			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
+			filters.erase_at(i);
 			i--;
 		}
 	}

package/src/duckdb/src/optimizer/remove_duplicate_groups.cpp

@@ -65,7 +65,7 @@ void RemoveDuplicateGroups::VisitAggregate(LogicalAggregate &aggr) {
 
 		// Store expression and remove it from groups
 		stored_expressions.emplace_back(std::move(groups[removed_idx]));
-		groups.erase(groups.begin() + removed_idx);
+		groups.erase_at(removed_idx);
 
 		// This optimizer should run before statistics propagation, so this should be empty
 		// If it runs after, then group_stats should be updated too

package/src/duckdb/src/optimizer/remove_unused_columns.cpp

@@ -38,7 +38,7 @@ void RemoveUnusedColumns::ClearUnusedExpressions(vector<T> &list, idx_t table_id
 		auto entry = column_references.find(current_binding);
 		if (entry == column_references.end()) {
 			// this entry is not referred to, erase it from the set of expressions
-			list.erase(list.begin() + col_idx);
+			list.erase_at(col_idx);
 			offset++;
 			col_idx--;
 		} else if (offset > 0 && replace) {

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -26,7 +26,7 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
                                                            bool &changes_made, bool is_root) {
 	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
 	auto &constant = bindings[1].get().Cast<BoundConstantExpression>();
-	int constant_child = root.children[0].get() == &constant ? 0 : 1;
+	idx_t constant_child = root.children[0].get() == &constant ? 0 : 1;
 	D_ASSERT(root.children.size() == 2);
 	(void)root;
 	// any arithmetic operator involving NULL is always NULL

package/src/duckdb/src/optimizer/rule/case_simplification.cpp

@@ -25,14 +25,14 @@ unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector
 			auto condition = constant_value.DefaultCastAs(LogicalType::BOOLEAN);
 			if (condition.IsNull() || !BooleanValue::Get(condition)) {
 				// the condition is always false: remove this case check
-				root.case_checks.erase(root.case_checks.begin() + i);
+				root.case_checks.erase_at(i);
 				i--;
 			} else {
 				// the condition is always true
 				// move the THEN clause to the ELSE of the case
 				root.else_expr = std::move(case_check.then_expr);
 				// remove this case check and any case checks after this one
-				root.case_checks.erase(root.case_checks.begin() + i, root.case_checks.end());
+				root.case_checks.erase(root.case_checks.begin() + NumericCast<int64_t>(i), root.case_checks.end());
 				break;
 			}
 		}

package/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp

@@ -1,3 +1,4 @@
+
 #include "duckdb/optimizer/rule/conjunction_simplification.hpp"
 
 #include "duckdb/execution/expression_executor.hpp"
@@ -19,7 +20,7 @@ unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConj
 	for (idx_t i = 0; i < conj.children.size(); i++) {
 		if (conj.children[i].get() == &expr) {
 			// erase the expression
-			conj.children.erase(conj.children.begin() + i);
+			conj.children.erase_at(i);
 			break;
 		}
 	}

package/src/duckdb/src/optimizer/rule/constant_folding.cpp

@@ -1,3 +1,4 @@
+
 #include "duckdb/optimizer/rule/constant_folding.hpp"
 
 #include "duckdb/common/exception.hpp"

package/src/duckdb/src/optimizer/rule/distributivity.cpp

@@ -35,7 +35,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 		for (idx_t i = 0; i < and_expr.children.size(); i++) {
 			if (and_expr.children[i]->Equals(expr)) {
 				result = std::move(and_expr.children[i]);
-				and_expr.children.erase(and_expr.children.begin() + i);
+				and_expr.children.erase_at(i);
 				break;
 			}
 		}

package/src/duckdb/src/optimizer/rule/empty_needle_removal.cpp

@@ -1,3 +1,4 @@
+
 #include "duckdb/optimizer/rule/empty_needle_removal.hpp"
 
 #include "duckdb/execution/expression_executor.hpp"

package/src/duckdb/src/optimizer/rule/enum_comparison.cpp

@@ -1,3 +1,4 @@
+
 #include "duckdb/optimizer/rule/enum_comparison.hpp"
 
 #include "duckdb/execution/expression_executor.hpp"

package/src/duckdb/src/optimizer/rule/in_clause_simplification_rule.cpp

@@ -1,3 +1,4 @@
+
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/rule/in_clause_simplification.hpp"
 #include "duckdb/planner/expression/list.hpp"

package/src/duckdb/src/optimizer/rule/ordered_aggregate_optimizer.cpp

@@ -1,5 +1,3 @@
-#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"
-
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/optimizer/matcher/expression_matcher.hpp"
@@ -8,6 +6,7 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
+#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp

@@ -0,0 +1,107 @@
+
+#include "duckdb/optimizer/rule/timestamp_comparison.hpp"
+#include "duckdb/optimizer/matcher/expression_matcher.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/optimizer/matcher/type_matcher_id.hpp"
+#include "duckdb/optimizer/expression_rewriter.hpp"
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/operator/add.hpp"
+
+namespace duckdb {
+
+TimeStampComparison::TimeStampComparison(ClientContext &context, ExpressionRewriter &rewriter)
+    : Rule(rewriter), context(context) {
+	// match on a ComparisonExpression that is an Equality and has a VARCHAR and ENUM as its children
+	auto op = make_uniq<ComparisonExpressionMatcher>();
+	op->policy = SetMatcher::Policy::UNORDERED;
+	// Enum requires expression to be root
+	op->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
+
+	// one side is timestamp cast to date
+	auto left = make_uniq<CastExpressionMatcher>();
+	left->type = make_uniq<TypeMatcherId>(LogicalTypeId::DATE);
+	left->matcher = make_uniq<ExpressionMatcher>();
+	left->matcher->expr_class = ExpressionClass::BOUND_COLUMN_REF;
+	left->matcher->type = make_uniq<TypeMatcherId>(LogicalTypeId::TIMESTAMP);
+	op->matchers.push_back(std::move(left));
+
+	// other side is varchar to date?
+	auto right = make_uniq<CastExpressionMatcher>();
+	right->type = make_uniq<TypeMatcherId>(LogicalTypeId::DATE);
+	right->matcher = make_uniq<FoldableConstantMatcher>();
+	right->matcher->expr_class = ExpressionClass::BOUND_CONSTANT;
+	right->matcher->type = make_uniq<TypeMatcherId>(LogicalTypeId::VARCHAR);
+	op->matchers.push_back(std::move(right));
+
+	root = std::move(op);
+}
+
+static void ExpressionIsConstant(Expression &expr, bool &is_constant) {
+	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+		is_constant = false;
+		return;
+	}
+	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExpressionIsConstant(child, is_constant); });
+}
+
+unique_ptr<Expression> TimeStampComparison::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                  bool &changes_made, bool is_root) {
+	auto cast_constant = bindings[3].get().Copy();
+	auto cast_columnref = bindings[2].get().Copy();
+	auto is_constant = true;
+	ExpressionIsConstant(*cast_constant, is_constant);
+	if (!is_constant) {
+		// means the matchers are flipped, so we need to flip our bindings
+		// for some reason an extra binding is added in this case.
+		cast_constant = bindings[4].get().Copy();
+		cast_columnref = bindings[3].get().Copy();
+	}
+	auto new_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
+
+	Value result;
+	if (ExpressionExecutor::TryEvaluateScalar(context, *cast_constant, result)) {
+		D_ASSERT(result.type() == LogicalType::DATE);
+		auto original_val = result.GetValue<duckdb::date_t>();
+		auto no_seconds = dtime_t(0);
+
+		// original date as timestamp with no seconds
+		auto original_val_ts = Value::TIMESTAMP(original_val, no_seconds);
+		auto original_val_for_comparison = make_uniq<BoundConstantExpression>(original_val_ts);
+
+		// add one day and validate the new date
+		// code is inspired by AddOperator::Operation(date_t left, int32_t right). The function wasn't used directly
+		// since it throws errors that I cannot catch here.
+
+		auto date_t_copy = result.GetValue<duckdb::date_t>();
+		date_t date_t_result;
+		// attempt to add 1 day
+		if (!TryAddOperator::Operation<date_t, int32_t, date_t>(date_t_copy, 1, date_t_result)) {
+			// don't rewrite the expression and let the expression executor handle the invalid date
+			return nullptr;
+		}
+
+		auto result_as_val = Value::DATE(date_t_result);
+		auto original_val_plus_on_date_ts = Value::TIMESTAMP(result_as_val.GetValue<timestamp_t>());
+
+		auto val_for_comparison = make_uniq<BoundConstantExpression>(original_val_plus_on_date_ts);
+
+		auto left_copy = cast_columnref->Copy();
+		auto right_copy = cast_columnref->Copy();
+		auto lt_eq_expr = make_uniq_base<Expression, BoundComparisonExpression>(
+		    ExpressionType::COMPARE_LESSTHAN, std::move(right_copy), std::move(val_for_comparison));
+		auto gt_eq_expr = make_uniq_base<Expression, BoundComparisonExpression>(
+		    ExpressionType::COMPARE_GREATERTHANOREQUALTO, std::move(left_copy), std::move(original_val_for_comparison));
+		new_expr->children.push_back(std::move(gt_eq_expr));
+		new_expr->children.push_back(std::move(lt_eq_expr));
+		return std::move(new_expr);
+	}
+	return nullptr;
+}
+
+} // namespace duckdb

package/src/duckdb/src/optimizer/statistics/expression/propagate_conjunction.cpp

@@ -46,7 +46,7 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjun
 			}
 		}
 		if (prune_child) {
-			expr.children.erase(expr.children.begin() + expr_idx);
+			expr.children.erase_at(expr_idx);
 			expr_idx--;
 			continue;
 		}

package/src/duckdb/src/optimizer/statistics/expression/propagate_operator.cpp

@@ -28,8 +28,8 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundOperat
 				// this child is always NULL, we can remove it from the coalesce
 				// UNLESS there is only one node remaining
 				if (expr.children.size() > 1) {
-					expr.children.erase(expr.children.begin() + i);
-					child_stats.erase(child_stats.begin() + i);
+					expr.children.erase_at(i);
+					child_stats.erase_at(i);
 					i--;
 				}
 			} else if (!child_stats[i]->CanHaveNull()) {
@@ -37,8 +37,8 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundOperat
 				// this is the last coalesce node that influences the result
 				// we can erase any children after this node
 				if (i + 1 < expr.children.size()) {
-					expr.children.erase(expr.children.begin() + i + 1, expr.children.end());
-					child_stats.erase(child_stats.begin() + i + 1, child_stats.end());
+					expr.children.erase(expr.children.begin() + NumericCast<int64_t>(i + 1), expr.children.end());
+					child_stats.erase(child_stats.begin() + NumericCast<int64_t>(i + 1), child_stats.end());
 				}
 				break;
 			}

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -227,7 +227,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 	node_stats = PropagateStatistics(filter.children[0]);
 	if (filter.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
 		ReplaceWithEmptyResult(node_ptr);
-		return make_uniq<NodeStatistics>(0, 0);
+		return make_uniq<NodeStatistics>(0U, 0U);
 	}
 
 	// then propagate to each of the expressions
@@ -238,7 +238,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 		if (ExpressionIsConstant(*condition, Value::BOOLEAN(true))) {
 			// filter is always true; it is useless to execute it
 			// erase this condition
-			filter.expressions.erase(filter.expressions.begin() + i);
+			filter.expressions.erase_at(i);
 			i--;
 			if (filter.expressions.empty()) {
 				// just break. The physical filter planner will plan a projection instead
@@ -248,7 +248,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 		           ExpressionIsConstantOrNull(*condition, Value::BOOLEAN(false))) {
 			// filter is always false or null; this entire filter should be replaced by an empty result block
 			ReplaceWithEmptyResult(node_ptr);
-			return make_uniq<NodeStatistics>(0, 0);
+			return make_uniq<NodeStatistics>(0U, 0U);
 		} else {
 			// cannot prune this filter: propagate statistics from the filter
 			UpdateFilterStatistics(*condition);

package/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp

@@ -86,7 +86,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 		case FilterPropagateResult::FILTER_ALWAYS_FALSE:
 			// filter is always false; this entire filter should be replaced by an empty result block
 			ReplaceWithEmptyResult(node_ptr);
-			return make_uniq<NodeStatistics>(0, 0);
+			return make_uniq<NodeStatistics>(0U, 0U);
 		default:
 			// general case: filter can be true or false, update this columns' statistics
 			UpdateFilterStatistics(stats, *filter);

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -85,7 +85,7 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 				}
 				if (join.conditions.size() > 1) {
 					// there are multiple conditions: erase this condition
-					join.conditions.erase(join.conditions.begin() + i);
+					join.conditions.erase_at(i);
 					// remove the corresponding statistics
 					join.join_stats.clear();
 					i--;
@@ -187,7 +187,8 @@ void StatisticsPropagator::MultiplyCardinalities(unique_ptr<NodeStatistics> &sta
 		return;
 	}
 	stats->estimated_cardinality = MaxValue<idx_t>(stats->estimated_cardinality, new_stats.estimated_cardinality);
-	auto new_max = Hugeint::Multiply(stats->max_cardinality, new_stats.max_cardinality);
+	auto new_max = Hugeint::Multiply(NumericCast<int64_t>(stats->max_cardinality),
+	                                 NumericCast<int64_t>(new_stats.max_cardinality));
 	if (new_max < NumericLimits<int64_t>::Maximum()) {
 		int64_t result;
 		if (!Hugeint::TryCast<int64_t>(new_max, result)) {
@@ -357,7 +358,9 @@ void StatisticsPropagator::CreateFilterFromJoinStats(unique_ptr<LogicalOperator>
 		child->expressions.emplace_back(std::move(filter_expr));
 	}
 
-	FilterPushdown filter_pushdown(optimizer);
+	// not allowed to let filter pushdowwn change mark joins to semi joins.
+	// semi joins are potentially slower AND the conversion can ruin column binding information
+	FilterPushdown filter_pushdown(optimizer, false);
 	child = filter_pushdown.Rewrite(std::move(child));
 	PropagateExpression(expr);
 }

package/src/duckdb/src/optimizer/statistics/operator/propagate_set_operation.cpp

@@ -10,7 +10,8 @@ void StatisticsPropagator::AddCardinalities(unique_ptr<NodeStatistics> &stats, N
 		return;
 	}
 	stats->estimated_cardinality += new_stats.estimated_cardinality;
-	auto new_max = Hugeint::Add(stats->max_cardinality, new_stats.max_cardinality);
+	auto new_max =
+	    Hugeint::Add(NumericCast<int64_t>(stats->max_cardinality), NumericCast<int64_t>(new_stats.max_cardinality));
 	if (new_max < NumericLimits<int64_t>::Maximum()) {
 		int64_t result;
 		if (!Hugeint::TryCast<int64_t>(new_max, result)) {

package/src/duckdb/src/optimizer/topn_optimizer.cpp

@@ -29,8 +29,8 @@ unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
 	if (CanOptimize(*op)) {
 		auto &limit = op->Cast<LogicalLimit>();
 		auto &order_by = (op->children[0])->Cast<LogicalOrder>();
-		auto limit_val = int64_t(limit.limit_val.GetConstantValue());
-		int64_t offset_val = 0;
+		auto limit_val = limit.limit_val.GetConstantValue();
+		idx_t offset_val = 0;
 		if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
 			offset_val = limit.offset_val.GetConstantValue();
 		}

package/src/duckdb/src/parallel/executor.cpp

@@ -73,10 +73,11 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 
 	// create events/stack for the base pipeline
 	auto base_pipeline = meta_pipeline->GetBasePipeline();
-	auto base_initialize_event = make_shared<PipelineInitializeEvent>(base_pipeline);
-	auto base_event = make_shared<PipelineEvent>(base_pipeline);
-	auto base_finish_event = make_shared<PipelineFinishEvent>(base_pipeline);
-	auto base_complete_event = make_shared<PipelineCompleteEvent>(base_pipeline->executor, event_data.initial_schedule);
+	auto base_initialize_event = make_shared_ptr<PipelineInitializeEvent>(base_pipeline);
+	auto base_event = make_shared_ptr<PipelineEvent>(base_pipeline);
+	auto base_finish_event = make_shared_ptr<PipelineFinishEvent>(base_pipeline);
+	auto base_complete_event =
+	    make_shared_ptr<PipelineCompleteEvent>(base_pipeline->executor, event_data.initial_schedule);
 	PipelineEventStack base_stack(*base_initialize_event, *base_event, *base_finish_event, *base_complete_event);
 	events.push_back(std::move(base_initialize_event));
 	events.push_back(std::move(base_event));
@@ -96,7 +97,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 		D_ASSERT(pipeline);
 
 		// create events/stack for this pipeline
-		auto pipeline_event = make_shared<PipelineEvent>(pipeline);
+		auto pipeline_event = make_shared_ptr<PipelineEvent>(pipeline);
 
 		auto finish_group = meta_pipeline->GetFinishGroup(*pipeline);
 		if (finish_group) {
@@ -115,7 +116,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
 		} else if (meta_pipeline->HasFinishEvent(*pipeline)) {
 			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
-			auto pipeline_finish_event = make_shared<PipelineFinishEvent>(pipeline);
+			auto pipeline_finish_event = make_shared_ptr<PipelineFinishEvent>(pipeline);
 			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
 			                                  *pipeline_finish_event, base_stack.pipeline_complete_event);
 			events.push_back(std::move(pipeline_finish_event));
@@ -359,7 +360,7 @@ void Executor::InitializeInternal(PhysicalOperator &plan) {
 
 		// build and ready the pipelines
 		PipelineBuildState state;
-		auto root_pipeline = make_shared<MetaPipeline>(*this, state, nullptr);
+		auto root_pipeline = make_shared_ptr<MetaPipeline>(*this, state, nullptr);
 		root_pipeline->Build(*physical_plan);
 		root_pipeline->Ready();
 
@@ -570,7 +571,7 @@ shared_ptr<Pipeline> Executor::CreateChildPipeline(Pipeline &current, PhysicalOp
 	D_ASSERT(op.IsSource());
 	// found another operator that is a source, schedule a child pipeline
 	// 'op' is the source, and the sink is the same
-	auto child_pipeline = make_shared<Pipeline>(*this);
+	auto child_pipeline = make_shared_ptr<Pipeline>(*this);
 	child_pipeline->sink = current.sink;
 	child_pipeline->source = &op;
 
@@ -639,7 +640,9 @@ bool Executor::GetPipelinesProgress(double &current_progress, uint64_t &current_
 
 	for (size_t i = 0; i < progress.size(); i++) {
 		progress[i] = MaxValue(0.0, MinValue(100.0, progress[i]));
-		current_cardinality += double(progress[i]) * double(cardinality[i]) / double(100);
+		current_cardinality = NumericCast<idx_t>(static_cast<double>(
+		    current_cardinality +
+		    static_cast<double>(progress[i]) * static_cast<double>(cardinality[i]) / static_cast<double>(100)));
 		current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality);
 		D_ASSERT(current_cardinality <= total_cardinality);
 	}

package/src/duckdb/src/parallel/meta_pipeline.cpp

@@ -82,7 +82,7 @@ void MetaPipeline::Ready() {
 }
 
 MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op) {
-	children.push_back(make_shared<MetaPipeline>(executor, state, &op));
+	children.push_back(make_shared_ptr<MetaPipeline>(executor, state, &op));
 	auto child_meta_pipeline = children.back().get();
 	// child MetaPipeline must finish completely before this MetaPipeline can start
 	current.AddDependency(child_meta_pipeline->GetBasePipeline());
@@ -92,7 +92,7 @@ MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalO
 }
 
 Pipeline &MetaPipeline::CreatePipeline() {
-	pipelines.emplace_back(make_shared<Pipeline>(executor));
+	pipelines.emplace_back(make_shared_ptr<Pipeline>(executor));
 	state.SetPipelineSink(*pipelines.back(), sink, next_batch_index++);
 	return *pipelines.back();
 }

package/src/duckdb/src/parallel/pipeline.cpp

@@ -110,9 +110,9 @@ bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
 			    "Attempting to schedule a pipeline where the sink requires batch index but source does not support it");
 		}
 	}
-	idx_t max_threads = source_state->MaxThreads();
+	auto max_threads = source_state->MaxThreads();
 	auto &scheduler = TaskScheduler::GetScheduler(executor.context);
-	idx_t active_threads = scheduler.NumberOfThreads();
+	auto active_threads = NumericCast<idx_t>(scheduler.NumberOfThreads());
 	if (max_threads > active_threads) {
 		max_threads = active_threads;
 	}