duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/optimizer/join_order/relation_manager.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/parser/expression_map.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression/list.hpp"
@@ -130,9 +131,6 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op,
 			}
 			filter_operators.push_back(*op);
 		}
-		if (op->type == LogicalOperatorType::LOGICAL_SHOW) {
-			return false;
-		}
 		op = op->children[0].get();
 	}
 	bool non_reorderable_operation = false;
@@ -183,6 +181,9 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op,
 		op->children[0] = optimizer.Optimize(std::move(op->children[0]), &child_stats);
 		auto &aggr = op->Cast<LogicalAggregate>();
 		auto operator_stats = RelationStatisticsHelper::ExtractAggregationStats(aggr, child_stats);
+		if (!datasource_filters.empty()) {
+			operator_stats.cardinality *= RelationStatisticsHelper::DEFAULT_SELECTIVITY;
+		}
 		AddAggregateRelation(input_op, parent, operator_stats);
 		return true;
 	}
@@ -248,6 +249,14 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op,
 		AddRelation(input_op, parent, proj_stats);
 		return true;
 	}
+	case LogicalOperatorType::LOGICAL_EMPTY_RESULT: {
+		// optimize the child and copy the stats
+		auto &empty_result = op->Cast<LogicalEmptyResult>();
+		// Projection can create columns so we need to add them here
+		auto stats = RelationStatisticsHelper::ExtractEmptyResultStats(empty_result);
+		AddRelation(input_op, parent, stats);
+		return true;
+	}
 	default:
 		return false;
 	}

package/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp

@@ -226,6 +226,46 @@ RelationStats RelationStatisticsHelper::CombineStatsOfNonReorderableOperator(Log
 	idx_t child_1_card = child_stats[0].stats_initialized ? child_stats[0].cardinality : 0;
 	idx_t child_2_card = child_stats[1].stats_initialized ? child_stats[1].cardinality : 0;
 	ret.cardinality = MaxValue(child_1_card, child_2_card);
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
+		auto &join = op.Cast<LogicalComparisonJoin>();
+		switch (join.join_type) {
+		case JoinType::RIGHT_ANTI:
+		case JoinType::RIGHT_SEMI:
+			ret.cardinality = child_2_card;
+			break;
+		case JoinType::ANTI:
+		case JoinType::SEMI:
+		case JoinType::SINGLE:
+			ret.cardinality = child_1_card;
+			break;
+		default:
+			break;
+		}
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_UNION: {
+		auto &setop = op.Cast<LogicalSetOperation>();
+		if (setop.setop_all) {
+			// setop returns all records
+			ret.cardinality = child_1_card + child_2_card;
+		} else {
+			ret.cardinality = MaxValue(child_1_card, child_2_card);
+		}
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_INTERSECT: {
+		ret.cardinality = MinValue(child_1_card, child_2_card);
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_EXCEPT: {
+		ret.cardinality = child_1_card;
+		break;
+	}
+	default:
+		break;
+	}
+
 	ret.stats_initialized = true;
 	ret.filter_strength = 1;
 	ret.table_name = child_stats[0].table_name + " joined with " + child_stats[1].table_name;
@@ -280,6 +320,32 @@ RelationStats RelationStatisticsHelper::ExtractAggregationStats(LogicalAggregate
 	// TODO: look at child distinct count to better estimate cardinality.
 	stats.cardinality = child_stats.cardinality;
 	stats.column_distinct_count = child_stats.column_distinct_count;
+	double new_card = -1;
+	for (auto &g_set : aggr.grouping_sets) {
+		for (auto &ind : g_set) {
+			if (aggr.groups[ind]->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
+				continue;
+			}
+			auto bound_col = &aggr.groups[ind]->Cast<BoundColumnRefExpression>();
+			auto col_index = bound_col->binding.column_index;
+			if (col_index >= child_stats.column_distinct_count.size()) {
+				// it is possible the column index of the grouping_set is not in the child stats.
+				// this can happen when delim joins are present, since delim scans are not currently
+				// reorderable. Meaning they don't add a relation or column_ids that could potentially
+				// be grouped by. Hopefully this can be fixed with duckdb-internal#606
+				continue;
+			}
+			if (new_card < child_stats.column_distinct_count[col_index].distinct_count) {
+				new_card = child_stats.column_distinct_count[col_index].distinct_count;
+			}
+		}
+	}
+	if (new_card < 0 || new_card >= child_stats.cardinality) {
+		// We have no good statistics on distinct count.
+		// most likely we are running on parquet files. Therefore we divide by 2.
+		new_card = (double)child_stats.cardinality / 2;
+	}
+	stats.cardinality = new_card;
 	stats.column_names = child_stats.column_names;
 	stats.stats_initialized = true;
 	auto num_child_columns = aggr.GetColumnBindings().size();
@@ -292,6 +358,16 @@ RelationStats RelationStatisticsHelper::ExtractAggregationStats(LogicalAggregate
 	return stats;
 }
 
+RelationStats RelationStatisticsHelper::ExtractEmptyResultStats(LogicalEmptyResult &empty) {
+	RelationStats stats;
+	for (idx_t i = 0; i < empty.GetColumnBindings().size(); i++) {
+		stats.column_distinct_count.push_back(DistinctCount({0, false}));
+		stats.column_names.push_back("empty_result_column");
+	}
+	stats.stats_initialized = true;
+	return stats;
+}
+
 idx_t RelationStatisticsHelper::InspectConjunctionAND(idx_t cardinality, idx_t column_index,
                                                       ConjunctionAndFilter &filter, BaseStatistics &base_stats) {
 	auto cardinality_after_filters = cardinality;
@@ -304,12 +380,10 @@ idx_t RelationStatisticsHelper::InspectConjunctionAND(idx_t cardinality, idx_t c
 			continue;
 		}
 		auto column_count = base_stats.GetDistinctCount();
-		auto filtered_card = cardinality;
 		// column_count = 0 when there is no column count (i.e parquet scans)
 		if (column_count > 0) {
 			// we want the ceil of cardinality/column_count. We also want to avoid compiler errors
-			filtered_card = (cardinality + column_count - 1) / column_count;
-			cardinality_after_filters = filtered_card;
+			cardinality_after_filters = (cardinality + column_count - 1) / column_count;
 		}
 	}
 	return cardinality_after_filters;

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

@@ -6,21 +6,21 @@
 
 namespace duckdb {
 
-static bool HasSideEffects(LogicalProjection &proj, const unique_ptr<Expression> &expr) {
+static bool IsVolatile(LogicalProjection &proj, const unique_ptr<Expression> &expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.table_index);
 		D_ASSERT(colref.binding.column_index < proj.expressions.size());
 		D_ASSERT(colref.depth == 0);
-		if (proj.expressions[colref.binding.column_index]->HasSideEffects()) {
+		if (proj.expressions[colref.binding.column_index]->IsVolatile()) {
 			return true;
 		}
 		return false;
 	}
-	bool has_side_effects = false;
+	bool is_volatile = false;
 	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { has_side_effects |= HasSideEffects(proj, child); });
-	return has_side_effects;
+	    *expr, [&](unique_ptr<Expression> &child) { is_volatile |= IsVolatile(proj, child); });
+	return is_volatile;
 }
 
 static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj, unique_ptr<Expression> expr) {
@@ -50,8 +50,8 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<Logica
 	for (auto &filter : filters) {
 		auto &f = *filter;
 		D_ASSERT(f.bindings.size() <= 1);
-		bool has_side_effects = HasSideEffects(proj, f.filter);
-		if (has_side_effects) {
+		bool is_volatile = IsVolatile(proj, f.filter);
+		if (is_volatile) {
 			// We can't push down related expressions if the column in the
 			// expression is generated by the functions which have side effects
 			remain_expressions.push_back(std::move(f.filter));

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

@@ -0,0 +1,56 @@
+#include "duckdb/optimizer/filter_pushdown.hpp"
+#include "duckdb/planner/operator/logical_any_join.hpp"
+#include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_cross_product.hpp"
+#include "duckdb/planner/operator/logical_empty_result.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+
+namespace duckdb {
+
+using Filter = FilterPushdown::Filter;
+
+unique_ptr<LogicalOperator> FilterPushdown::PushdownSemiAntiJoin(unique_ptr<LogicalOperator> op) {
+	auto &join = op->Cast<LogicalJoin>();
+	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return FinishPushdown(std::move(op));
+	}
+
+	// push all current filters down the left side
+	op->children[0] = Rewrite(std::move(op->children[0]));
+	FilterPushdown right_pushdown(optimizer);
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
+
+	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
+	bool right_empty = op->children[1]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
+	if (left_empty && right_empty) {
+		// both empty: return empty result
+		return make_uniq<LogicalEmptyResult>(std::move(op));
+	}
+	// TODO: if semi/anti join is created from a intersect/except statement, then we can
+	//  push filters down into both children.
+	// filter pushdown happens before join order optimization, so right_anti and right_semi are not possible yet here
+	if (left_empty) {
+		// left child is empty result
+		switch (join.join_type) {
+		case JoinType::ANTI:
+		case JoinType::SEMI:
+			return make_uniq<LogicalEmptyResult>(std::move(op));
+		default:
+			break;
+		}
+	} else if (right_empty) {
+		// right child is empty result
+		switch (join.join_type) {
+		case JoinType::ANTI:
+			// just return the left child.
+			return std::move(op->children[0]);
+		case JoinType::SEMI:
+			return make_uniq<LogicalEmptyResult>(std::move(op));
+		default:
+			break;
+		}
+	}
+	return op;
+}
+
+} // namespace duckdb

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

@@ -319,6 +319,27 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 	}
 	LogicalOperatorVisitor::VisitOperatorExpressions(op);
 	LogicalOperatorVisitor::VisitOperatorChildren(op);
+
+	if (op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN ||
+	    op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+		auto &comp_join = op.Cast<LogicalComparisonJoin>();
+		// after removing duplicate columns we may have duplicate join conditions (if the join graph is cyclical)
+		vector<JoinCondition> unique_conditions;
+		for (auto &cond : comp_join.conditions) {
+			bool found = false;
+			for (auto &unique_cond : unique_conditions) {
+				if (cond.comparison == unique_cond.comparison && cond.left->Equals(*unique_cond.left) &&
+				    cond.right->Equals(*unique_cond.right)) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				unique_conditions.push_back(std::move(cond));
+			}
+		}
+		comp_join.conditions = std::move(unique_conditions);
+	}
 }
 
 unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundColumnRefExpression &expr,

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

@@ -92,11 +92,11 @@ unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, ve
 	vector<unique_ptr<Expression>> children;
 	children.push_back(std::move(date_part.children[1]));
 
-	string error;
+	ErrorData error;
 	FunctionBinder binder(rewriter.context);
 	auto function = binder.BindScalarFunction(DEFAULT_SCHEMA, new_function_name, std::move(children), error, false);
 	if (!function) {
-		throw BinderException(error);
+		error.Throw();
 	}
 	return function;
 }

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

@@ -21,8 +21,12 @@ MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewrit
 	arithmetic->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*"});
 	// we match only on integral numeric types
 	arithmetic->type = make_uniq<IntegerTypeMatcher>();
-	arithmetic->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	arithmetic->matchers.push_back(make_uniq<ExpressionMatcher>());
+	auto child_constant_matcher = make_uniq<ConstantExpressionMatcher>();
+	auto child_expression_matcher = make_uniq<ExpressionMatcher>();
+	child_constant_matcher->type = make_uniq<IntegerTypeMatcher>();
+	child_expression_matcher->type = make_uniq<IntegerTypeMatcher>();
+	arithmetic->matchers.push_back(std::move(child_constant_matcher));
+	arithmetic->matchers.push_back(std::move(child_expression_matcher));
 	arithmetic->policy = SetMatcher::Policy::SOME;
 	op->matchers.push_back(std::move(arithmetic));
 	root = std::move(op);
@@ -34,9 +38,8 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 	auto &outer_constant = bindings[1].get().Cast<BoundConstantExpression>();
 	auto &arithmetic = bindings[2].get().Cast<BoundFunctionExpression>();
 	auto &inner_constant = bindings[3].get().Cast<BoundConstantExpression>();
-	if (!TypeIsIntegral(arithmetic.return_type.InternalType())) {
-		return nullptr;
-	}
+	D_ASSERT(arithmetic.return_type.IsIntegral());
+	D_ASSERT(arithmetic.children[0]->return_type.IsIntegral());
 	if (inner_constant.value.IsNull() || outer_constant.value.IsNull()) {
 		return make_uniq<BoundConstantExpression>(Value(comparison.return_type));
 	}
@@ -50,7 +53,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		// [x + 1 COMP 10] OR [1 + x COMP 10]
 		// order does not matter in addition:
 		// simply change right side to 10-1 (outer_constant - inner_constant)
-		if (!Hugeint::SubtractInPlace(outer_value, inner_value)) {
+		if (!Hugeint::TrySubtractInPlace(outer_value, inner_value)) {
 			return nullptr;
 		}
 		auto result_value = Value::HUGEINT(outer_value);
@@ -71,7 +74,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		if (arithmetic_child_index == 0) {
 			// [x - 1 COMP 10]
 			// change right side to 10+1 (outer_constant + inner_constant)
-			if (!Hugeint::AddInPlace(outer_value, inner_value)) {
+			if (!Hugeint::TryAddInPlace(outer_value, inner_value)) {
 				return nullptr;
 			}
 			auto result_value = Value::HUGEINT(outer_value);
@@ -87,7 +90,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		} else {
 			// [1 - x COMP 10]
 			// change right side to 1-10=-9
-			if (!Hugeint::SubtractInPlace(inner_value, outer_value)) {
+			if (!Hugeint::TrySubtractInPlace(inner_value, outer_value)) {
 				return nullptr;
 			}
 			auto result_value = Value::HUGEINT(inner_value);
@@ -115,8 +118,10 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 			// we let the arithmetic_simplification rule take care of simplifying this first
 			return nullptr;
 		}
-		if (outer_value % inner_value != 0) {
-			// not cleanly divisible
+		// check out of range for HUGEINT or not cleanly divisible
+		// HUGEINT is not cleanly divisible when outer_value == minimum and inner value == -1. (modulo overflow)
+		if ((outer_value == NumericLimits<hugeint_t>::Minimum() && inner_value == -1) ||
+		    outer_value % inner_value != 0) {
 			bool is_equality = comparison.type == ExpressionType::COMPARE_EQUAL;
 			bool is_inequality = comparison.type == ExpressionType::COMPARE_NOTEQUAL;
 			if (is_equality || is_inequality) {

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

@@ -1,7 +1,13 @@
 #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"
+#include "duckdb/optimizer/expression_rewriter.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/operator/logical_aggregate.hpp"
 
 namespace duckdb {
 
@@ -24,6 +30,70 @@ unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vec
 		changes_made = true;
 		return nullptr;
 	}
+
+	// Remove unnecessary ORDER BY clauses and return if nothing remains
+	if (aggr.order_bys->Simplify(op.Cast<LogicalAggregate>().groups)) {
+		aggr.order_bys.reset();
+		changes_made = true;
+		return nullptr;
+	}
+
+	//	Rewrite first/last/arbitrary/any_value to use arg_xxx[_null] and create_sort_key
+	const auto &aggr_name = aggr.function.name;
+	string arg_xxx_name;
+	if (aggr_name == "last") {
+		arg_xxx_name = "arg_max_null";
+	} else if (aggr_name == "first" || aggr_name == "arbitrary") {
+		arg_xxx_name = "arg_min_null";
+	} else if (aggr_name == "any_value") {
+		arg_xxx_name = "arg_min";
+	} else {
+		return nullptr;
+	}
+
+	auto &context = rewriter.context;
+	FunctionBinder binder(context);
+	vector<unique_ptr<Expression>> sort_children;
+	for (auto &order : aggr.order_bys->orders) {
+		sort_children.emplace_back(std::move(order.expression));
+
+		string modifier;
+		modifier += (order.type == OrderType::ASCENDING) ? "ASC" : "DESC";
+		modifier += " NULLS";
+		modifier += (order.null_order == OrderByNullType::NULLS_FIRST) ? " FIRST" : " LAST";
+		sort_children.emplace_back(make_uniq<BoundConstantExpression>(Value(modifier)));
+	}
+	aggr.order_bys.reset();
+
+	ErrorData error;
+	auto sort_key = binder.BindScalarFunction(DEFAULT_SCHEMA, "create_sort_key", std::move(sort_children), error);
+	if (!sort_key) {
+		error.Throw();
+	}
+
+	auto &children = aggr.children;
+	children.emplace_back(std::move(sort_key));
+
+	//  Look up the arg_xxx_name function in the catalog
+	QueryErrorContext error_context;
+	auto &func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, SYSTEM_CATALOG, DEFAULT_SCHEMA, arg_xxx_name,
+	                                                              error_context);
+	D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+
+	// bind the aggregate
+	vector<LogicalType> types;
+	for (const auto &child : children) {
+		types.emplace_back(child->return_type);
+	}
+	auto best_function = binder.BindFunction(func.name, func.functions, types, error);
+	if (best_function == DConstants::INVALID_INDEX) {
+		error.Throw();
+	}
+	// found a matching function!
+	auto bound_function = func.functions.GetFunctionByOffset(best_function);
+	return binder.BindAggregateFunction(bound_function, std::move(children), std::move(aggr.filter),
+	                                    aggr.IsDistinct() ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
+
 	return nullptr;
 }
 

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

@@ -5,6 +5,7 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/scalar/regexp.hpp"
+#include "utf8proc_wrapper.hpp"
 
 #include "re2/re2.h"
 #include "re2/regexp.h"
@@ -39,6 +40,19 @@ static void AddCharacter(char chr, LikeString &ret, bool contains) {
 	ret.like_string += run_as_str;
 }
 
+static void AddCodepoint(int32_t codepoint, LikeString &ret, bool contains) {
+	int sz = 0;
+	char utf8_str[4];
+	if (!Utf8Proc::CodepointToUtf8(codepoint, sz, utf8_str)) {
+		// invalid codepoint
+		ret.exists = false;
+		return;
+	}
+	for (idx_t i = 0; i < idx_t(sz); i++) {
+		AddCharacter(utf8_str[i], ret, contains);
+	}
+}
+
 static LikeString GetLikeStringEscaped(duckdb_re2::Regexp *regexp, bool contains = false) {
 	D_ASSERT(regexp->op() == duckdb_re2::kRegexpLiteralString || regexp->op() == duckdb_re2::kRegexpLiteral);
 	LikeString ret;
@@ -57,16 +71,14 @@ static LikeString GetLikeStringEscaped(duckdb_re2::Regexp *regexp, bool contains
 		auto nrunes = (idx_t)regexp->nrunes();
 		auto runes = regexp->runes();
 		for (idx_t i = 0; i < nrunes; i++) {
-			char chr = toascii(runes[i]);
-			AddCharacter(chr, ret, contains);
+			AddCodepoint(runes[i], ret, contains);
 			if (!ret.exists) {
 				return ret;
 			}
 		}
 	} else {
 		auto rune = regexp->rune();
-		char chr = toascii(rune);
-		AddCharacter(chr, ret, contains);
+		AddCodepoint(rune, ret, contains);
 	}
 	D_ASSERT(ret.like_string.size() >= 1 || !ret.exists);
 	return ret;
@@ -143,13 +155,13 @@ unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<
 
 	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), constant_expr);
 	D_ASSERT(constant_value.type() == constant_expr.return_type);
-	auto patt_str = StringValue::Get(constant_value);
 
 	duckdb_re2::RE2::Options parsed_options = regexp_bind_data.options;
 
 	if (constant_expr.value.IsNull()) {
 		return make_uniq<BoundConstantExpression>(Value(root.return_type));
 	}
+	auto patt_str = StringValue::Get(constant_value);
 
 	// the constant_expr is a scalar expression that we have to fold
 	if (!constant_expr.IsFoldable()) {

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

@@ -32,6 +32,7 @@ static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatisti
 		default:
 			break;
 		}
+		break;
 	default:
 		break;
 	}

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

@@ -14,6 +14,7 @@ FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &
 	case PhysicalType::UINT16:
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
+	case PhysicalType::UINT128:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32:

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

@@ -234,8 +234,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 			filter.expressions.erase(filter.expressions.begin() + i);
 			i--;
 			if (filter.expressions.empty()) {
-				// all conditions have been erased: remove the entire filter
-				*node_ptr = std::move(filter.children[0]);
+				// just break. The physical filter planner will plan a projection instead
 				break;
 			}
 		} else if (ExpressionIsConstant(*condition, Value::BOOLEAN(false)) ||

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

@@ -36,18 +36,19 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 			case FilterPropagateResult::FILTER_ALWAYS_FALSE:
 				// filter is always false or null, none of the join conditions matter
 				switch (join.join_type) {
+				case JoinType::RIGHT_SEMI:
 				case JoinType::SEMI:
 				case JoinType::INNER:
 					// semi or inner join on false; entire node can be pruned
 					ReplaceWithEmptyResult(*node_ptr);
 					return;
+				case JoinType::RIGHT_ANTI:
 				case JoinType::ANTI: {
-					// when the right child has data, return the left child
-					// when the right child has no data, return an empty set
-					auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
-					limit->AddChild(std::move(join.children[1]));
-					auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
-					*node_ptr = std::move(cross_product);
+					if (join.join_type == JoinType::RIGHT_ANTI) {
+						std::swap(join.children[0], join.children[1]);
+					}
+					// If the filter is always false or Null, just return the left child.
+					*node_ptr = std::move(join.children[0]);
 					return;
 				}
 				case JoinType::LEFT:
@@ -92,9 +93,16 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 				} else {
 					// this is the only condition and it is always true: all conditions are true
 					switch (join.join_type) {
+					case JoinType::RIGHT_SEMI:
 					case JoinType::SEMI: {
-						// when the right child has data, return the left child
+						if (join.join_type == JoinType::RIGHT_SEMI) {
+							std::swap(join.children[0], join.children[1]);
+						}
 						// when the right child has no data, return an empty set
+						// cannot just return the left child because if the right child has no cardinality
+						// then the whole result should be empty.
+						// TODO: write better CE logic for limits so that we can just look at
+						//  join.children[1].estimated_cardinality.
 						auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
 						limit->AddChild(std::move(join.children[1]));
 						auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
@@ -108,6 +116,11 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						*node_ptr = std::move(cross_product);
 						return;
 					}
+					case JoinType::ANTI:
+					case JoinType::RIGHT_ANTI: {
+						ReplaceWithEmptyResult(*node_ptr);
+						return;
+					}
 					default:
 						// we don't handle mark/single join here yet
 						break;
@@ -142,8 +155,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 			auto updated_stats_right = PropagateExpression(condition.right);
 
 			// Try to push lhs stats down rhs and vice versa
-			if (!context.config.force_index_join && stats_left && stats_right && updated_stats_left &&
-			    updated_stats_right && condition.left->type == ExpressionType::BOUND_COLUMN_REF &&
+			if (stats_left && stats_right && updated_stats_left && updated_stats_right &&
+			    condition.left->type == ExpressionType::BOUND_COLUMN_REF &&
 			    condition.right->type == ExpressionType::BOUND_COLUMN_REF) {
 				CreateFilterFromJoinStats(join.children[0], condition.left, *stats_left, *updated_stats_left);
 				CreateFilterFromJoinStats(join.children[1], condition.right, *stats_right, *updated_stats_right);

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

@@ -11,13 +11,37 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalWind
 
 	// then propagate to each of the order expressions
 	for (auto &window_expr : window.expressions) {
-		auto over_expr = reinterpret_cast<BoundWindowExpression *>(window_expr.get());
-		for (auto &expr : over_expr->partitions) {
-			over_expr->partitions_stats.push_back(PropagateExpression(expr));
+		auto &over_expr = window_expr->Cast<BoundWindowExpression>();
+		for (auto &expr : over_expr.partitions) {
+			over_expr.partitions_stats.push_back(PropagateExpression(expr));
 		}
-		for (auto &bound_order : over_expr->orders) {
+		for (auto &bound_order : over_expr.orders) {
 			bound_order.stats = PropagateExpression(bound_order.expression);
 		}
+
+		if (over_expr.start_expr) {
+			over_expr.expr_stats.push_back(PropagateExpression(over_expr.start_expr));
+		} else {
+			over_expr.expr_stats.push_back(nullptr);
+		}
+
+		if (over_expr.end_expr) {
+			over_expr.expr_stats.push_back(PropagateExpression(over_expr.end_expr));
+		} else {
+			over_expr.expr_stats.push_back(nullptr);
+		}
+
+		if (over_expr.offset_expr) {
+			over_expr.expr_stats.push_back(PropagateExpression(over_expr.offset_expr));
+		} else {
+			over_expr.expr_stats.push_back(nullptr);
+		}
+
+		if (over_expr.default_expr) {
+			over_expr.expr_stats.push_back(PropagateExpression(over_expr.default_expr));
+		} else {
+			over_expr.expr_stats.push_back(nullptr);
+		}
 	}
 	return std::move(node_stats);
 }