duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -0,0 +1,65 @@
+#include "duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp"
+#include "duckdb/optimizer/expression_rewriter.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/operator/logical_aggregate.hpp"
+
+namespace duckdb {
+
+DistinctAggregateOptimizer::DistinctAggregateOptimizer(ExpressionRewriter &rewriter) : Rule(rewriter) {
+	root = make_uniq<ExpressionMatcher>();
+	root->expr_class = ExpressionClass::BOUND_AGGREGATE;
+}
+
+unique_ptr<Expression> DistinctAggregateOptimizer::Apply(ClientContext &context, BoundAggregateExpression &aggr,
+                                                         bool &changes_made) {
+	if (!aggr.IsDistinct()) {
+		// no DISTINCT defined
+		return nullptr;
+	}
+	if (aggr.function.distinct_dependent == AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT) {
+		// not a distinct-sensitive aggregate but we have an DISTINCT modifier - remove it
+		aggr.aggr_type = AggregateType::NON_DISTINCT;
+		changes_made = true;
+		return nullptr;
+	}
+	return nullptr;
+}
+
+unique_ptr<Expression> DistinctAggregateOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                         bool &changes_made, bool is_root) {
+	auto &aggr = bindings[0].get().Cast<BoundAggregateExpression>();
+	return Apply(rewriter.context, aggr, changes_made);
+}
+
+DistinctWindowedOptimizer::DistinctWindowedOptimizer(ExpressionRewriter &rewriter) : Rule(rewriter) {
+	root = make_uniq<ExpressionMatcher>();
+	root->expr_class = ExpressionClass::BOUND_WINDOW;
+}
+
+unique_ptr<Expression> DistinctWindowedOptimizer::Apply(ClientContext &context, BoundWindowExpression &wexpr,
+                                                        bool &changes_made) {
+	if (!wexpr.distinct) {
+		// no DISTINCT defined
+		return nullptr;
+	}
+	if (!wexpr.aggregate) {
+		// not an aggregate
+		return nullptr;
+	}
+	if (wexpr.aggregate->distinct_dependent == AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT) {
+		// not a distinct-sensitive aggregate but we have an DISTINCT modifier - remove it
+		wexpr.distinct = false;
+		changes_made = true;
+		return nullptr;
+	}
+	return nullptr;
+}
+
+unique_ptr<Expression> DistinctWindowedOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                        bool &changes_made, bool is_root) {
+	auto &wexpr = bindings[0].get().Cast<BoundWindowExpression>();
+	return Apply(rewriter.context, wexpr, changes_made);
+}
+
+} // namespace duckdb

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

@@ -15,7 +15,7 @@ DistributivityRule::DistributivityRule(ExpressionRewriter &rewriter) : Rule(rewr
 }
 
 void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &set) {
-	if (expr.type == ExpressionType::CONJUNCTION_AND) {
+	if (expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
 		auto &and_expr = expr.Cast<BoundConjunctionExpression>();
 		for (auto &child : and_expr.children) {
 			set.insert(*child);
@@ -29,7 +29,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
                                                              Expression &expr) {
 	auto &child = conj.children[idx];
 	unique_ptr<Expression> result;
-	if (child->type == ExpressionType::CONJUNCTION_AND) {
+	if (child->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
 		// AND, remove expression from the list
 		auto &and_expr = child->Cast<BoundConjunctionExpression>();
 		for (idx_t i = 0; i < and_expr.children.size(); i++) {

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

@@ -65,7 +65,8 @@ unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<ref
 
 	auto cast_left_to_right =
 	    BoundCastExpression::AddDefaultCastToType(std::move(left_child.child), right_child.child->return_type, true);
-	return make_uniq<BoundComparisonExpression>(root.type, std::move(cast_left_to_right), std::move(right_child.child));
+	return make_uniq<BoundComparisonExpression>(root.GetExpressionType(), std::move(cast_left_to_right),
+	                                            std::move(right_child.child));
 }
 
 } // namespace duckdb

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

@@ -38,7 +38,8 @@ EqualOrNullSimplification::EqualOrNullSimplification(ExpressionRewriter &rewrite
 
 // a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
 static unique_ptr<Expression> TryRewriteEqualOrIsNull(Expression &equal_expr, Expression &and_expr) {
-	if (equal_expr.type != ExpressionType::COMPARE_EQUAL || and_expr.type != ExpressionType::CONJUNCTION_AND) {
+	if (equal_expr.GetExpressionType() != ExpressionType::COMPARE_EQUAL ||
+	    and_expr.GetExpressionType() != ExpressionType::CONJUNCTION_AND) {
 		return nullptr;
 	}
 
@@ -58,7 +59,7 @@ static unique_ptr<Expression> TryRewriteEqualOrIsNull(Expression &equal_expr, Ex
 	for (const auto &item : and_cast.children) {
 		auto &next_exp = *item;
 
-		if (next_exp.type == ExpressionType::OPERATOR_IS_NULL) {
+		if (next_exp.GetExpressionType() == ExpressionType::OPERATOR_IS_NULL) {
 			auto &next_exp_cast = next_exp.Cast<BoundOperatorExpression>();
 			auto &child = *next_exp_cast.children[0];
 
@@ -85,7 +86,7 @@ unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vec
                                                         bool &changes_made, bool is_root) {
 	const Expression &or_exp = bindings[0].get();
 
-	if (or_exp.type != ExpressionType::CONJUNCTION_OR) {
+	if (or_exp.GetExpressionType() != ExpressionType::CONJUNCTION_OR) {
 		return nullptr;
 	}
 

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

@@ -16,11 +16,11 @@ InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewri
 unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                          bool &changes_made, bool is_root) {
 	auto &expr = bindings[0].get().Cast<BoundOperatorExpression>();
-	if (expr.children[0]->expression_class != ExpressionClass::BOUND_CAST) {
+	if (expr.children[0]->GetExpressionClass() != ExpressionClass::BOUND_CAST) {
 		return nullptr;
 	}
 	auto &cast_expression = expr.children[0]->Cast<BoundCastExpression>();
-	if (cast_expression.child->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
+	if (cast_expression.child->GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
 		return nullptr;
 	}
 	//! The goal here is to remove the cast from the probe expression
@@ -34,7 +34,7 @@ unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, ve
 	vector<unique_ptr<BoundConstantExpression>> cast_list;
 	//! First check if we can cast all children
 	for (size_t i = 1; i < expr.children.size(); i++) {
-		if (expr.children[i]->expression_class != ExpressionClass::BOUND_CONSTANT) {
+		if (expr.children[i]->GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
 			return nullptr;
 		}
 		D_ASSERT(expr.children[i]->IsFoldable());

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

@@ -1,6 +1,8 @@
 #include "duckdb/optimizer/rule/like_optimizations.hpp"
 
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
@@ -132,7 +134,7 @@ unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<r
 		return ApplyRule(root, SuffixFun::GetFunction(), patt_str, is_not_like);
 	} else if (PatternIsContains(patt_str)) {
 		// Contains LIKE pattern: [%]+[^%_]*[%]+, ignoring underscore
-		return ApplyRule(root, ContainsFun::GetStringContains(), patt_str, is_not_like);
+		return ApplyRule(root, GetStringContains(), patt_str, is_not_like);
 	}
 	return nullptr;
 }

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

@@ -41,8 +41,8 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 	D_ASSERT(arithmetic.return_type.IsIntegral());
 	D_ASSERT(arithmetic.children[0]->return_type.IsIntegral());
 	if (inner_constant.value.IsNull() || outer_constant.value.IsNull()) {
-		if (comparison.type == ExpressionType::COMPARE_DISTINCT_FROM ||
-		    comparison.type == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+		if (comparison.GetExpressionType() == ExpressionType::COMPARE_DISTINCT_FROM ||
+		    comparison.GetExpressionType() == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 			return nullptr;
 		}
 		return make_uniq<BoundConstantExpression>(Value(comparison.return_type));
@@ -62,7 +62,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		}
 		auto result_value = Value::HUGEINT(outer_value);
 		if (!result_value.DefaultTryCastAs(constant_type)) {
-			if (comparison.type != ExpressionType::COMPARE_EQUAL) {
+			if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
 				return nullptr;
 			}
 			// if the cast is not possible then the comparison is not possible
@@ -84,7 +84,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 			auto result_value = Value::HUGEINT(outer_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
 				// if the cast is not possible then an equality comparison is not possible
-				if (comparison.type != ExpressionType::COMPARE_EQUAL) {
+				if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
 					return nullptr;
 				}
 				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
@@ -100,7 +100,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 			auto result_value = Value::HUGEINT(inner_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
 				// if the cast is not possible then an equality comparison is not possible
-				if (comparison.type != ExpressionType::COMPARE_EQUAL) {
+				if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
 					return nullptr;
 				}
 				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
@@ -109,7 +109,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 			outer_constant.value = std::move(result_value);
 			// in this case, we should also flip the comparison
 			// e.g. if we have [4 - x < 2] then we should have [x > 2]
-			comparison.type = FlipComparisonExpression(comparison.type);
+			comparison.SetExpressionTypeUnsafe(FlipComparisonExpression(comparison.GetExpressionType()));
 		}
 	} else {
 		D_ASSERT(op_type == "*");
@@ -126,8 +126,8 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		// 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;
+			bool is_equality = comparison.GetExpressionType() == ExpressionType::COMPARE_EQUAL;
+			bool is_inequality = comparison.GetExpressionType() == ExpressionType::COMPARE_NOTEQUAL;
 			if (is_equality || is_inequality) {
 				// we know the values are not equal
 				// the result will be either FALSE or NULL (if COMPARE_EQUAL)
@@ -141,7 +141,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<refe
 		}
 		if (inner_value < 0) {
 			// multiply by negative value, need to flip expression
-			comparison.type = FlipComparisonExpression(comparison.type);
+			comparison.SetExpressionTypeUnsafe(FlipComparisonExpression(comparison.GetExpressionType()));
 		}
 		// else divide the RHS by the LHS
 		// we need to do a range check on the cast even though we do a division

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

@@ -3,6 +3,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/scalar/regexp.hpp"
 #include "utf8proc_wrapper.hpp"
@@ -184,7 +185,7 @@ unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<
 			return nullptr;
 		}
 		auto parameter = make_uniq<BoundConstantExpression>(Value(std::move(escaped_like_string.like_string)));
-		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, ContainsFun::GetStringContains(),
+		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, GetStringContains(),
 		                                                   std::move(root.children), nullptr);
 		contains->children[1] = std::move(parameter);
 
@@ -205,8 +206,8 @@ unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<
 		D_ASSERT(root.children.size() == 2);
 	}
 
-	auto like_expression = make_uniq<BoundFunctionExpression>(root.return_type, LikeFun::GetLikeFunction(),
-	                                                          std::move(root.children), nullptr);
+	auto like_expression =
+	    make_uniq<BoundFunctionExpression>(root.return_type, LikeFun::GetFunction(), std::move(root.children), nullptr);
 	auto parameter = make_uniq<BoundConstantExpression>(Value(std::move(like_string.like_string)));
 	like_expression->children[1] = std::move(parameter);
 	return std::move(like_expression);

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

@@ -43,7 +43,7 @@ TimeStampComparison::TimeStampComparison(ClientContext &context, ExpressionRewri
 }
 
 static void ExpressionIsConstant(Expression &expr, bool &is_constant) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		is_constant = false;
 		return;
 	}

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

@@ -0,0 +1,24 @@
+#include "duckdb/optimizer/sampling_pushdown.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_sample.hpp"
+#include "duckdb/common/types/value.hpp"
+namespace duckdb {
+
+unique_ptr<LogicalOperator> SamplingPushdown::Optimize(unique_ptr<LogicalOperator> op) {
+	if (op->type == LogicalOperatorType::LOGICAL_SAMPLE &&
+	    op->Cast<LogicalSample>().sample_options->method == SampleMethod::SYSTEM_SAMPLE &&
+	    op->Cast<LogicalSample>().sample_options->is_percentage && !op->children.empty() &&
+	    op->children[0]->type == LogicalOperatorType::LOGICAL_GET &&
+	    op->children[0]->Cast<LogicalGet>().function.sampling_pushdown && op->children[0]->children.empty()) {
+		auto &get = op->children[0]->Cast<LogicalGet>();
+		// set sampling option
+		get.extra_info.sample_options = std::move(op->Cast<LogicalSample>().sample_options);
+		op = std::move(op->children[0]);
+	}
+	for (auto &child : op->children) {
+		child = Optimize(std::move(child));
+	}
+	return op;
+}
+
+} // namespace duckdb

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

@@ -99,7 +99,7 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCompar
 		return nullptr;
 	}
 	// propagate the statistics of the comparison operator
-	auto propagate_result = PropagateComparison(*left_stats, *right_stats, expr.type);
+	auto propagate_result = PropagateComparison(*left_stats, *right_stats, expr.GetExpressionType());
 	switch (propagate_result) {
 	case FilterPropagateResult::FILTER_ALWAYS_TRUE:
 		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));

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

@@ -9,7 +9,7 @@ namespace duckdb {
 
 unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjunctionExpression &expr,
                                                                      unique_ptr<Expression> &expr_ptr) {
-	auto is_and = expr.type == ExpressionType::CONJUNCTION_AND;
+	auto is_and = expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND;
 	for (idx_t expr_idx = 0; expr_idx < expr.children.size(); expr_idx++) {
 		auto &child = expr.children[expr_idx];
 		auto stats = PropagateExpression(child);

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

@@ -19,7 +19,7 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundOperat
 	if (!all_have_stats) {
 		return nullptr;
 	}
-	switch (expr.type) {
+	switch (expr.GetExpressionType()) {
 	case ExpressionType::OPERATOR_COALESCE:
 		// COALESCE, merge stats of all children
 		for (idx_t i = 0; i < expr.children.size(); i++) {

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

@@ -1,8 +1,78 @@
 #include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
+#include "duckdb/planner/operator/logical_dummy_scan.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_expression_get.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
 
+void StatisticsPropagator::TryExecuteAggregates(LogicalAggregate &aggr, unique_ptr<LogicalOperator> &node_ptr) {
+	if (!aggr.groups.empty()) {
+		// not possible with groups
+		return;
+	}
+	if (aggr.children[0]->type != LogicalOperatorType::LOGICAL_GET) {
+		// child must be a LOGICAL_GET
+		// FIXME: we could do this with projections as well
+		return;
+	}
+	auto &get = aggr.children[0]->Cast<LogicalGet>();
+	if (!get.function.get_partition_stats) {
+		// GET does not support getting the partition stats
+		return;
+	}
+	if (!get.table_filters.filters.empty()) {
+		// we cannot do this if the GET has filters
+		return;
+	}
+	// check if all aggregates are COUNT(*)
+	for (auto &aggr_ref : aggr.expressions) {
+		if (aggr_ref->GetExpressionClass() != ExpressionClass::BOUND_AGGREGATE) {
+			// not an aggregate
+			return;
+		}
+		auto &aggr_expr = aggr_ref->Cast<BoundAggregateExpression>();
+		if (aggr_expr.function.name != "count_star") {
+			// aggregate is not count star - bail
+			return;
+		}
+		if (aggr_expr.filter) {
+			// aggregate has a filter - bail
+			return;
+		}
+	}
+	// we can do the rewrite! get the stats
+	GetPartitionStatsInput input(get.function, get.bind_data.get());
+	auto partition_stats = get.function.get_partition_stats(context, input);
+	idx_t count = 0;
+	for (auto &stats : partition_stats) {
+		if (stats.count_type == CountType::COUNT_APPROXIMATE) {
+			// we cannot get an exact count
+			return;
+		}
+		count += stats.count;
+	}
+	// we got an exact count - replace the entire aggregate with a scan of the result
+	vector<LogicalType> types;
+	vector<unique_ptr<Expression>> count_results;
+	for (idx_t aggregate_index = 0; aggregate_index < aggr.expressions.size(); ++aggregate_index) {
+		auto count_result = make_uniq<BoundConstantExpression>(Value::BIGINT(NumericCast<int64_t>(count)));
+		count_result->SetAlias(aggr.expressions[aggregate_index]->GetName());
+		count_results.push_back(std::move(count_result));
+
+		types.push_back(LogicalType::BIGINT);
+	}
+
+	vector<vector<unique_ptr<Expression>>> expressions;
+	expressions.push_back(std::move(count_results));
+	auto expression_get =
+	    make_uniq<LogicalExpressionGet>(aggr.aggregate_index, std::move(types), std::move(expressions));
+	expression_get->children.push_back(make_uniq<LogicalDummyScan>(aggr.group_index));
+	node_ptr = std::move(expression_get);
+}
+
 unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggregate &aggr,
                                                                      unique_ptr<LogicalOperator> &node_ptr) {
 	// first propagate statistics in the child node
@@ -34,6 +104,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggr
 		ColumnBinding aggregate_binding(aggr.aggregate_index, aggregate_idx);
 		statistics_map[aggregate_binding] = std::move(stats);
 	}
+
+	// after we propagate statistics - try to directly execute aggregates using statistics
+	TryExecuteAggregates(aggr, node_ptr);
+
 	// the max cardinality of an aggregate is the max cardinality of the input (i.e. when every row is a unique group)
 	return std::move(node_stats);
 }

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

@@ -1,5 +1,5 @@
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/function/scalar/generic_common.hpp"
 #include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/expression/bound_between_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
@@ -161,23 +161,26 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 	// first check if either side is a bound column ref
 	// any column ref involved in a comparison will not be null after the comparison
 	bool compare_distinct = IsCompareDistinct(comparison_type);
-	if (!compare_distinct && left.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (!compare_distinct && left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		SetStatisticsNotNull((left.Cast<BoundColumnRefExpression>()).binding);
 	}
-	if (!compare_distinct && right.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (!compare_distinct && right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		SetStatisticsNotNull((right.Cast<BoundColumnRefExpression>()).binding);
 	}
 	// check if this is a comparison between a constant and a column ref
 	optional_ptr<BoundConstantExpression> constant;
 	optional_ptr<BoundColumnRefExpression> columnref;
-	if (left.type == ExpressionType::VALUE_CONSTANT && right.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (left.GetExpressionType() == ExpressionType::VALUE_CONSTANT &&
+	    right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		constant = &left.Cast<BoundConstantExpression>();
 		columnref = &right.Cast<BoundColumnRefExpression>();
 		comparison_type = FlipComparisonExpression(comparison_type);
-	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::VALUE_CONSTANT) {
+	} else if (left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
+	           right.GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 		columnref = &left.Cast<BoundColumnRefExpression>();
 		constant = &right.Cast<BoundConstantExpression>();
-	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::BOUND_COLUMN_REF) {
+	} else if (left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
+	           right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		// comparison between two column refs
 		auto &left_column_ref = left.Cast<BoundColumnRefExpression>();
 		auto &right_column_ref = right.Cast<BoundColumnRefExpression>();
@@ -213,7 +216,7 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &condition) {
 	}
 	case ExpressionClass::BOUND_COMPARISON: {
 		auto &comparison = condition.Cast<BoundComparisonExpression>();
-		UpdateFilterStatistics(*comparison.left, *comparison.right, comparison.type);
+		UpdateFilterStatistics(*comparison.left, *comparison.right, comparison.GetExpressionType());
 		break;
 	}
 	default:

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

@@ -41,7 +41,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 	}
 	auto &column_ids = get.GetColumnIds();
 	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto stats = get.function.statistics(context, get.bind_data.get(), column_ids[i]);
+		auto stats = get.function.statistics(context, get.bind_data.get(), column_ids[i].GetPrimaryIndex());
 		if (stats) {
 			ColumnBinding binding(get.table_index, i);
 			statistics_map.insert(make_pair(binding, std::move(stats)));
@@ -57,12 +57,12 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 	for (auto &table_filter_column : column_indexes) {
 		idx_t column_index;
 		for (column_index = 0; column_index < column_ids.size(); column_index++) {
-			if (column_ids[column_index] == table_filter_column) {
+			if (column_ids[column_index].GetPrimaryIndex() == table_filter_column) {
 				break;
 			}
 		}
 		D_ASSERT(column_index < column_ids.size());
-		D_ASSERT(column_ids[column_index] == table_filter_column);
+		D_ASSERT(column_ids[column_index].GetPrimaryIndex() == table_filter_column);
 
 		// find the stats
 		ColumnBinding stats_binding(get.table_index, column_index);

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

@@ -157,8 +157,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 
 			// Try to push lhs stats down rhs and vice versa
 			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) {
+			    condition.left->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
+			    condition.right->GetExpressionType() == 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);
 			}
@@ -324,7 +324,7 @@ void StatisticsPropagator::CreateFilterFromJoinStats(unique_ptr<LogicalOperator>
                                                      const BaseStatistics &stats_before,
                                                      const BaseStatistics &stats_after) {
 	// Only do this for integral colref's that have stats
-	if (expr->type != ExpressionType::BOUND_COLUMN_REF || !expr->return_type.IsIntegral() ||
+	if (expr->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF || !expr->return_type.IsIntegral() ||
 	    !NumericStats::HasMinMax(stats_before) || !NumericStats::HasMinMax(stats_after)) {
 		return;
 	}

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

@@ -42,6 +42,9 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalWind
 		} else {
 			over_expr.expr_stats.push_back(nullptr);
 		}
+		for (auto &bound_order : over_expr.arg_orders) {
+			bound_order.stats = PropagateExpression(bound_order.expression);
+		}
 	}
 	return std::move(node_stats);
 }