duckdb 1.3.4 → 1.4.0

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

@@ -0,0 +1,446 @@
+#include "duckdb/optimizer/rule/date_trunc_simplification.hpp"
+
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
+#include "duckdb/optimizer/matcher/expression_matcher.hpp"
+#include "duckdb/optimizer/expression_rewriter.hpp"
+#include "duckdb/common/enums/date_part_specifier.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/function/function_binder.hpp"
+
+namespace duckdb {
+
+DateTruncSimplificationRule::DateTruncSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
+	auto op = make_uniq<ComparisonExpressionMatcher>();
+
+	auto lhs = make_uniq<FunctionExpressionMatcher>();
+	lhs->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"date_trunc", "datetrunc"});
+	lhs->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
+	lhs->matchers.push_back(make_uniq<ExpressionMatcher>());
+	lhs->policy = SetMatcher::Policy::ORDERED;
+
+	auto rhs = make_uniq<ConstantExpressionMatcher>();
+
+	op->matchers.push_back(std::move(lhs));
+	op->matchers.push_back(std::move(rhs));
+	op->policy = SetMatcher::Policy::UNORDERED;
+
+	root = std::move(op);
+}
+
+unique_ptr<Expression> DateTruncSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                          bool &changes_made, bool is_root) {
+	auto &expr = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto comparison_type = expr.GetExpressionType();
+
+	auto &date_part = bindings[2].get().Cast<BoundConstantExpression>();
+	// We must have only a column on the LHS.
+	if (bindings[3].get().GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
+		return nullptr;
+	}
+
+	auto &column_part = bindings[3].get().Cast<BoundColumnRefExpression>();
+	auto &rhs = bindings[4].get().Cast<BoundConstantExpression>();
+
+	// Determine whether or not the column name is on the lhs or rhs.
+	const bool col_is_lhs = (expr.left->GetExpressionClass() == ExpressionClass::BOUND_FUNCTION);
+
+	// We want to treat rhs >= col equivalently to col <= rhs.
+	// So, get the expression type if it was ordered such that the constant was actually on the right hand side.
+	ExpressionType rhs_comparison_type = comparison_type;
+	if (!col_is_lhs) {
+		rhs_comparison_type = FlipComparisonExpression(comparison_type);
+	}
+
+	// Check whether trunc(date_part, constant_rhs) = constant_rhs.
+	const bool is_truncated = DateIsTruncated(date_part, rhs);
+
+	switch (rhs_comparison_type) {
+	case ExpressionType::COMPARE_EQUAL:
+	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		// We handle two very similar optimizations here:
+		//
+		// date_trunc(part, column) = constant_rhs  -->  column >= date_trunc(part, constant_rhs) AND
+		//                                               column < date_trunc(part, date_add(constant_rhs,
+		//                                                                                  INTERVAL 1 part))
+		//    or, if date_trunc(part, constant_rhs) <> constant_rhs, this is unsatisfiable
+		//
+		// ----
+		//
+		// date_trunc(part, column) IS NOT DISTINCT FROM constant_rhs
+		//
+		//   Here we have two cases: when constant_rhs is NULL, this simplifies to:
+		//
+		// column IS NULL
+		//
+		//   Otherwise, the expression becomes:
+		//
+		// (column >= date_trunc(part, constant_rhs) AND
+		//  column < date_trunc(part, date_add(constant_rhs, INTERVAL 1 part)) AND
+		//  column IS NOT NULL)
+		//
+		{
+			// First check if we can just return `column IS NULL`.
+			if (rhs_comparison_type == ExpressionType::COMPARE_NOT_DISTINCT_FROM && rhs.value.IsNull()) {
+				auto op = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
+				op->children.push_back(column_part.Copy());
+				return std::move(op);
+			} else {
+				if (!is_truncated) {
+					return make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
+				}
+
+				auto trunc = CreateTrunc(date_part, rhs, column_part.return_type);
+				if (!trunc) {
+					return nullptr;
+				}
+
+				auto trunc_add = CreateTruncAdd(date_part, rhs, column_part.return_type);
+				if (!trunc_add) {
+					return nullptr;
+				}
+
+				auto gteq = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
+				                                                 column_part.Copy(), std::move(trunc));
+				auto lt = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHAN, column_part.Copy(),
+				                                               std::move(trunc_add));
+
+				// For IS NOT DISTINCT FROM, we also have to add the extra NULL term.
+				if (rhs_comparison_type == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+					auto comp = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(gteq),
+					                                                  std::move(lt));
+
+					auto isnotnull =
+					    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
+					isnotnull->children.push_back(column_part.Copy());
+
+					return make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(comp),
+					                                             std::move(isnotnull));
+				} else {
+					return make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(gteq),
+					                                             std::move(lt));
+				}
+			}
+		}
+
+	case ExpressionType::COMPARE_NOTEQUAL:
+	case ExpressionType::COMPARE_DISTINCT_FROM:
+		// We handle two very similar optimizations here:
+		//
+		// date_trunc(part, column) <> constant_rhs  -->  column < date_trunc(part, constant_rhs) OR
+		//                                                column >= date_trunc(part, date_add(constant_rhs,
+		//                                                                                    INTERVAL 1 part))
+		//   or, if date_trunc(part, constant_rhs) <> constant_rhs, this is always true
+		//
+		// ----
+		//
+		// date_trunc(part, column) IS DISTINCT FROM constant_rhs
+		//
+		//   Here we have two cases: when constant_rhs is NULL, this simplifies to:
+		//
+		// column IS NOT NULL
+		//
+		//   Otherwise, the expression becomes:
+		//
+		// (column < date_trunc(part, constant_rhs) OR
+		//  column >= date_trunc(part, date_add(constant_rhs, INTERVAL 1 part)) OR
+		//  column IS NULL)
+		//
+		{
+			if (rhs_comparison_type == ExpressionType::COMPARE_DISTINCT_FROM && rhs.value.IsNull()) {
+				// Return 'column IS NOT NULL'.
+				auto op =
+				    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
+				op->children.push_back(column_part.Copy());
+				return std::move(op);
+			} else {
+				if (!is_truncated) {
+					return make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
+				}
+
+				auto trunc = CreateTrunc(date_part, rhs, column_part.return_type);
+				if (!trunc) {
+					return nullptr;
+				}
+
+				auto trunc_add = CreateTruncAdd(date_part, rhs, column_part.return_type);
+				if (!trunc_add) {
+					return nullptr;
+				}
+
+				auto lt = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHAN, column_part.Copy(),
+				                                               std::move(trunc));
+				auto gteq = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
+				                                                 column_part.Copy(), std::move(trunc_add));
+
+				// If this is a DISTINCT FROM, we need to add the 'column IS NULL' term.
+				if (rhs_comparison_type == ExpressionType::COMPARE_DISTINCT_FROM) {
+					auto comp = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(gteq),
+					                                                  std::move(lt));
+
+					auto isnull =
+					    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
+					isnull->children.push_back(column_part.Copy());
+
+					return make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(comp),
+					                                             std::move(isnull));
+				} else {
+					return make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(gteq),
+					                                             std::move(lt));
+				}
+			}
+		}
+		return nullptr;
+
+	case ExpressionType::COMPARE_LESSTHAN:
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		// date_trunc(part, column) <  constant_rhs  -->  column <  date_trunc(part, date_add(constant_rhs,
+		//                                                                                    INTERVAL 1 part))
+		// date_trunc(part, column) >= constant_rhs  -->  column >= date_trunc(part, date_add(constant_rhs,
+		//                                                                                    INTERVAL 1 part))
+		{
+			// The optimization for < and >= is a little tricky: if trunc(rhs) = rhs, then we need to just
+			// use the rhs as-is, instead of using trunc(rhs + 1 date_part).
+			if (!is_truncated) {
+				// Create date_trunc(part, date_add(rhs, INTERVAL 1 part)) and fold the constant.
+				auto trunc = CreateTruncAdd(date_part, rhs, column_part.return_type);
+				if (!trunc) {
+					return nullptr; // Something went wrong---don't do the optimization.
+				}
+
+				if (col_is_lhs) {
+					expr.left = column_part.Copy();
+					expr.right = std::move(trunc);
+				} else {
+					expr.right = column_part.Copy();
+					expr.left = std::move(trunc);
+				}
+			} else {
+				// If the RHS is already truncated (i.e.  date_trunc(part, rhs) = rhs), then we can use
+				// it as-is.
+				if (col_is_lhs) {
+					expr.left = column_part.Copy();
+					// Determine whether the RHS needs to be casted.
+					if (rhs.return_type.id() != expr.left->return_type.id()) {
+						expr.right = CastAndEvaluate(std::move(expr.right), expr.left->return_type);
+					}
+				} else {
+					expr.right = column_part.Copy();
+					// Determine whether the RHS needs to be casted.
+					if (rhs.return_type.id() != expr.right->return_type.id()) {
+						expr.left = CastAndEvaluate(std::move(expr.left), expr.right->return_type);
+					}
+				}
+			}
+
+			changes_made = true;
+			return nullptr;
+		}
+
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+	case ExpressionType::COMPARE_GREATERTHAN:
+		// date_trunc(part, column) <= constant_rhs  -->  column <= date_trunc(part, date_add(constant_rhs,
+		//                                                                                    INTERVAL 1 part))
+		// date_trunc(part, column) >  constant_rhs  -->  column >= date_trunc(part, date_add(constant_rhs,
+		//                                                                                    INTERVAL 1 part))
+		{
+			// Create date_trunc(part, date_add(rhs, INTERVAL 1 part)) and fold the constant.
+			auto trunc = CreateTruncAdd(date_part, rhs, column_part.return_type);
+			if (!trunc) {
+				return nullptr; // Something went wrong---don't do the optimization.
+			}
+
+			if (col_is_lhs) {
+				expr.left = column_part.Copy();
+				expr.right = std::move(trunc);
+			} else {
+				expr.right = column_part.Copy();
+				expr.left = std::move(trunc);
+			}
+
+			// If this is a >, we need to change it to >= for correctness.
+			if (rhs_comparison_type == ExpressionType::COMPARE_GREATERTHAN) {
+				if (col_is_lhs) {
+					expr.SetExpressionTypeUnsafe(ExpressionType::COMPARE_GREATERTHANOREQUALTO);
+				} else {
+					expr.SetExpressionTypeUnsafe(ExpressionType::COMPARE_LESSTHANOREQUALTO);
+				}
+			}
+
+			changes_made = true;
+			return nullptr;
+		}
+
+	default:
+		return nullptr;
+	}
+}
+
+string DateTruncSimplificationRule::DatePartToFunc(const DatePartSpecifier &date_part) {
+	switch (date_part) {
+	// These specifiers can be used as intervals.
+	case DatePartSpecifier::YEAR:
+		return "to_years";
+	case DatePartSpecifier::MONTH:
+		return "to_months";
+	case DatePartSpecifier::DAY:
+		return "to_days";
+	case DatePartSpecifier::DECADE:
+		return "to_decades";
+	case DatePartSpecifier::CENTURY:
+		return "to_centuries";
+	case DatePartSpecifier::MILLENNIUM:
+		return "to_millennia";
+	case DatePartSpecifier::MICROSECONDS:
+		return "to_microseconds";
+	case DatePartSpecifier::MILLISECONDS:
+		return "to_milliseconds";
+	case DatePartSpecifier::SECOND:
+		return "to_seconds";
+	case DatePartSpecifier::MINUTE:
+		return "to_minutes";
+	case DatePartSpecifier::HOUR:
+		return "to_hours";
+	case DatePartSpecifier::WEEK:
+		return "to_weeks";
+	case DatePartSpecifier::QUARTER:
+		return "to_quarters";
+
+	// These specifiers cannot be used as intervals and can only be used as
+	// date parts.
+	case DatePartSpecifier::DOW:
+	case DatePartSpecifier::ISODOW:
+	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::ISOYEAR:
+	case DatePartSpecifier::YEARWEEK:
+	case DatePartSpecifier::ERA:
+	case DatePartSpecifier::TIMEZONE:
+	case DatePartSpecifier::TIMEZONE_HOUR:
+	case DatePartSpecifier::TIMEZONE_MINUTE:
+	default:
+		return "";
+	}
+}
+
+unique_ptr<Expression> DateTruncSimplificationRule::CreateTrunc(const BoundConstantExpression &date_part,
+                                                                const BoundConstantExpression &rhs,
+                                                                const LogicalType &return_type) {
+	FunctionBinder binder(rewriter.context);
+	ErrorData error;
+
+	vector<unique_ptr<Expression>> args;
+	args.emplace_back(date_part.Copy());
+	args.emplace_back(rhs.Copy());
+	auto trunc = binder.BindScalarFunction(DEFAULT_SCHEMA, "date_trunc", std::move(args), error);
+
+	// Ensure that the RHS type matches the column type.
+	if (trunc->return_type.id() != return_type.id()) {
+		trunc = BoundCastExpression::AddDefaultCastToType(std::move(trunc), return_type, true);
+	}
+
+	if (trunc->IsFoldable()) {
+		Value result;
+		if (!ExpressionExecutor::TryEvaluateScalar(rewriter.context, *trunc, result)) {
+			return trunc;
+		}
+
+		return make_uniq<BoundConstantExpression>(result);
+	}
+
+	return trunc;
+}
+
+unique_ptr<Expression> DateTruncSimplificationRule::CreateTruncAdd(const BoundConstantExpression &date_part,
+                                                                   const BoundConstantExpression &rhs,
+                                                                   const LogicalType &return_type) {
+	DatePartSpecifier part = GetDatePartSpecifier(StringValue::Get(date_part.value));
+	const string interval_func_name = DatePartToFunc(part);
+
+	// If the date part cannot be represented as an interval, then we cannot
+	// perform the optimization.
+	if (interval_func_name.empty()) {
+		return nullptr;
+	}
+
+	FunctionBinder binder(rewriter.context);
+	ErrorData error;
+
+	vector<unique_ptr<Expression>> args1;
+	auto constant_param = make_uniq<BoundConstantExpression>(Value::INTEGER(1));
+	args1.emplace_back(std::move(constant_param));
+	auto interval = binder.BindScalarFunction(DEFAULT_SCHEMA, interval_func_name, std::move(args1), error);
+	if (!interval) {
+		return nullptr; // Something wrong---just don't do the optimization.
+	}
+
+	vector<unique_ptr<Expression>> args2;
+	args2.emplace_back(rhs.Copy());
+	args2.emplace_back(std::move(interval));
+	auto add = binder.BindScalarFunction(DEFAULT_SCHEMA, "+", std::move(args2), error);
+
+	vector<unique_ptr<Expression>> args3;
+	args3.emplace_back(date_part.Copy());
+	args3.emplace_back(std::move(add));
+	auto trunc = binder.BindScalarFunction(DEFAULT_SCHEMA, "date_trunc", std::move(args3), error);
+
+	// Ensure that the RHS type matches the column type.
+	if (trunc->return_type.id() != return_type.id()) {
+		trunc = BoundCastExpression::AddDefaultCastToType(std::move(trunc), return_type, true);
+	}
+
+	if (trunc->IsFoldable()) {
+		Value result;
+		if (!ExpressionExecutor::TryEvaluateScalar(rewriter.context, *trunc, result)) {
+			return trunc;
+		}
+
+		return make_uniq<BoundConstantExpression>(result);
+	}
+
+	return trunc;
+}
+
+bool DateTruncSimplificationRule::DateIsTruncated(const BoundConstantExpression &date_part,
+                                                  const BoundConstantExpression &rhs) {
+	// If the rhs is null, then the date is "truncated" in the sense that date_trunc(..., NULL) is also NULL.
+	if (rhs.value.IsNull()) {
+		return true;
+	}
+
+	// Create the node date_trunc(date_part, rhs).
+	auto trunc = CreateTrunc(date_part, rhs, rhs.return_type);
+
+	Value trunc_result, result;
+	if (!ExpressionExecutor::TryEvaluateScalar(rewriter.context, *trunc, trunc_result)) {
+		return false;
+	}
+	if (!ExpressionExecutor::TryEvaluateScalar(rewriter.context, rhs, result)) {
+		return false;
+	}
+
+	return (result == trunc_result);
+}
+
+unique_ptr<Expression> DateTruncSimplificationRule::CastAndEvaluate(unique_ptr<Expression> rhs,
+                                                                    const LogicalType &return_type) {
+	auto cast = BoundCastExpression::AddDefaultCastToType(std::move(rhs), return_type, true);
+	if (cast->IsFoldable()) {
+		Value result;
+		if (!ExpressionExecutor::TryEvaluateScalar(rewriter.context, *cast, result)) {
+			return cast;
+		}
+
+		return make_uniq<BoundConstantExpression>(result);
+	}
+
+	return cast;
+}
+
+} // namespace duckdb

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

@@ -16,15 +16,9 @@ JoinDependentFilterRule::JoinDependentFilterRule(ExpressionRewriter &rewriter) :
 	root = std::move(op);
 }
 
-static inline void GetTableIndices(const Expression &expression, unordered_set<idx_t> &table_idxs) {
-	ExpressionIterator::EnumerateChildren(expression, [&](const Expression &child) {
-		if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-			auto &colref = child.Cast<BoundColumnRefExpression>();
-			table_idxs.insert(colref.binding.table_index);
-		} else {
-			GetTableIndices(child, table_idxs);
-		}
-	});
+static void GetTableIndices(const Expression &root_expr, unordered_set<idx_t> &table_idxs) {
+	ExpressionIterator::VisitExpression<BoundColumnRefExpression>(
+	    root_expr, [&](const BoundColumnRefExpression &colref) { table_idxs.insert(colref.binding.table_index); });
 }
 
 static inline bool ExpressionReferencesMultipleTables(const Expression &binding) {

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

@@ -53,12 +53,7 @@ unique_ptr<Expression> OrderedAggregateOptimizer::Apply(ClientContext &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)));
+		sort_children.emplace_back(make_uniq<BoundConstantExpression>(Value(order.GetOrderModifier())));
 	}
 	aggr.order_bys.reset();
 

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

@@ -42,12 +42,9 @@ TimeStampComparison::TimeStampComparison(ClientContext &context, ExpressionRewri
 	root = std::move(op);
 }
 
-static void ExpressionIsConstant(Expression &expr, bool &is_constant) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		is_constant = false;
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExpressionIsConstant(child, is_constant); });
+static void ExpressionIsConstant(const Expression &root_expr, bool &is_constant) {
+	ExpressionIterator::VisitExpression<BoundColumnRefExpression>(
+	    root_expr, [&](const BoundColumnRefExpression &column_ref) { is_constant = false; });
 }
 
 unique_ptr<Expression> TimeStampComparison::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,

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

@@ -1,9 +1,11 @@
+#include "duckdb/common/enums/tuple_data_layout_enums.hpp"
 #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_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
@@ -113,10 +115,40 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggr
 		statistics_map[aggregate_binding] = std::move(stats);
 	}
 
+	// check whether all inputs to the aggregate functions are valid
+	TupleDataValidityType distinct_validity = TupleDataValidityType::CANNOT_HAVE_NULL_VALUES;
+	for (const auto &aggr_ref : aggr.expressions) {
+		if (distinct_validity == TupleDataValidityType::CAN_HAVE_NULL_VALUES) {
+			break;
+		}
+		if (aggr_ref->GetExpressionClass() != ExpressionClass::BOUND_AGGREGATE) {
+			// Bail if it's not a bound aggregate
+			distinct_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES;
+			break;
+		}
+		auto &aggr_expr = aggr_ref->Cast<BoundAggregateExpression>();
+		for (const auto &child : aggr_expr.children) {
+			if (child->GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
+				// Bail if bound aggregate child is not a colref
+				distinct_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES;
+				break;
+			}
+			const auto &col_ref = child->Cast<BoundColumnRefExpression>();
+			auto it = statistics_map.find(col_ref.binding);
+			if (it == statistics_map.end() || !it->second || it->second->CanHaveNull()) {
+				// Bail if no stats or if there can be a NULL
+				distinct_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES;
+				break;
+			}
+		}
+	}
+	aggr.distinct_validity = distinct_validity;
+
 	// 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)
+	// 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/parallel/event.cpp

@@ -81,9 +81,7 @@ void Event::SetTasks(vector<shared_ptr<Task>> tasks) {
 	D_ASSERT(total_tasks == 0);
 	D_ASSERT(!tasks.empty());
 	this->total_tasks = tasks.size();
-	for (auto &task : tasks) {
-		ts.ScheduleTask(executor.GetToken(), std::move(task));
-	}
+	ts.ScheduleTasks(executor.GetToken(), tasks);
 }
 
 } // namespace duckdb

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

@@ -373,12 +373,6 @@ void Executor::VerifyPipelines() {
 #endif
 }
 
-void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan_p) {
-	Reset();
-	owned_plan = std::move(physical_plan_p);
-	InitializeInternal(*owned_plan);
-}
-
 void Executor::Initialize(PhysicalOperator &plan) {
 	Reset();
 	InitializeInternal(plan);
@@ -621,7 +615,6 @@ void Executor::Reset() {
 	lock_guard<mutex> elock(executor_lock);
 	physical_plan = nullptr;
 	cancelled = false;
-	owned_plan.reset();
 	root_executor.reset();
 	root_pipelines.clear();
 	root_pipeline_idx = 0;

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

@@ -12,6 +12,7 @@
 #include "duckdb/parallel/pipeline_event.hpp"
 #include "duckdb/parallel/pipeline_executor.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -134,7 +135,6 @@ bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
 }
 
 bool Pipeline::IsOrderDependent() const {
-	auto &config = DBConfig::GetConfig(executor.context);
 	if (source) {
 		auto source_order = source->SourceOrder();
 		if (source_order == OrderPreservationType::FIXED_ORDER) {
@@ -153,7 +153,7 @@ bool Pipeline::IsOrderDependent() const {
 			return true;
 		}
 	}
-	if (!config.options.preserve_insertion_order) {
+	if (!DBConfig::GetSetting<PreserveInsertionOrderSetting>(executor.context)) {
 		return false;
 	}
 	if (sink && sink->SinkOrderDependent()) {

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -34,7 +34,7 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 		auto &current_operator = pipeline.operators[i].get();
 
 		auto chunk = make_uniq<DataChunk>();
-		chunk->Initialize(Allocator::Get(context.client), prev_operator.GetTypes());
+		chunk->Initialize(BufferAllocator::Get(context.client), prev_operator.GetTypes());
 		intermediate_chunks.push_back(std::move(chunk));
 
 		auto op_state = current_operator.GetOperatorState(context);
@@ -540,7 +540,7 @@ SourceResultType PipelineExecutor::FetchFromSource(DataChunk &result) {
 
 void PipelineExecutor::InitializeChunk(DataChunk &chunk) {
 	auto &last_op = pipeline.operators.empty() ? *pipeline.source : pipeline.operators.back().get();
-	chunk.Initialize(Allocator::DefaultAllocator(), last_op.GetTypes());
+	chunk.Initialize(BufferAllocator::Get(context.client), last_op.GetTypes());
 }
 
 void PipelineExecutor::StartOperator(PhysicalOperator &op) {