duckdb 0.7.2-dev321.0 → 0.7.2-dev3294.0

package/src/duckdb/src/planner/bind_context.cpp

@@ -13,7 +13,7 @@
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "re2/re2.h"
+#include "duckdb/planner/expression_binder/constant_binder.hpp"
 
 #include <algorithm>
 
@@ -51,7 +51,7 @@ vector<string> BindContext::GetSimilarBindings(const string &column_name) {
 	return StringUtil::TopNStrings(scores);
 }
 
-void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet *set) {
+void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet &set) {
 	using_columns[column_name].insert(set);
 }
 
@@ -59,25 +59,18 @@ void BindContext::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
 	using_column_sets.push_back(std::move(set));
 }
 
-bool BindContext::FindUsingBinding(const string &column_name, unordered_set<UsingColumnSet *> **out) {
+optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name) {
 	auto entry = using_columns.find(column_name);
-	if (entry != using_columns.end()) {
-		*out = &entry->second;
-		return true;
-	}
-	return false;
-}
-
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name) {
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
+	if (entry == using_columns.end()) {
 		return nullptr;
 	}
-	if (using_bindings->size() > 1) {
+	auto &using_bindings = entry->second;
+	if (using_bindings.size() > 1) {
 		string error = "Ambiguous column reference: column \"" + column_name + "\" can refer to either:\n";
-		for (auto &using_set : *using_bindings) {
+		for (auto &using_set_ref : using_bindings) {
+			auto &using_set = using_set_ref.get();
 			string result_bindings;
-			for (auto &binding : using_set->bindings) {
+			for (auto &binding : using_set.bindings) {
 				if (result_bindings.empty()) {
 					result_bindings = "[";
 				} else {
@@ -91,33 +84,32 @@ UsingColumnSet *BindContext::GetUsingBinding(const string &column_name) {
 		}
 		throw BinderException(error);
 	}
-	for (auto &using_set : *using_bindings) {
-		return using_set;
+	for (auto &using_set : using_bindings) {
+		return &using_set.get();
 	}
 	throw InternalException("Using binding found but no entries");
 }
 
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name, const string &binding_name) {
+optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name, const string &binding_name) {
 	if (binding_name.empty()) {
 		throw InternalException("GetUsingBinding: expected non-empty binding_name");
 	}
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
+	auto entry = using_columns.find(column_name);
+	if (entry == using_columns.end()) {
 		return nullptr;
 	}
-	for (auto &using_set : *using_bindings) {
-		auto &bindings = using_set->bindings;
+	auto &using_bindings = entry->second;
+	for (auto &using_set_ref : using_bindings) {
+		auto &using_set = using_set_ref.get();
+		auto &bindings = using_set.bindings;
 		if (bindings.find(binding_name) != bindings.end()) {
-			return using_set;
+			return &using_set;
 		}
 	}
 	return nullptr;
 }
 
-void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet *set) {
-	if (!set) {
-		return;
-	}
+void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet &set) {
 	auto entry = using_columns.find(column_name);
 	if (entry == using_columns.end()) {
 		throw InternalException("Attempting to remove using binding that is not there");
@@ -131,10 +123,12 @@ void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet *
 	}
 }
 
-void BindContext::TransferUsingBinding(BindContext &current_context, UsingColumnSet *current_set,
-                                       UsingColumnSet *new_set, const string &binding, const string &using_column) {
+void BindContext::TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
+                                       UsingColumnSet &new_set, const string &binding, const string &using_column) {
 	AddUsingBinding(using_column, new_set);
-	current_context.RemoveUsingBinding(using_column, current_set);
+	if (current_set) {
+		current_context.RemoveUsingBinding(using_column, *current_set);
+	}
 }
 
 string BindContext::GetActualColumnName(const string &binding_name, const string &column_name) {
@@ -167,7 +161,7 @@ unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(const string &ta
 
 	auto binding = GetBinding(table_name, error_message);
 	D_ASSERT(binding);
-	auto &table_binding = *(TableBinding *)binding;
+	auto &table_binding = (TableBinding &)*binding;
 	auto result = table_binding.ExpandGeneratedColumn(column_name);
 	result->alias = column_name;
 	return result;
@@ -178,12 +172,12 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ta
 	return CreateColumnReference(schema_name, table_name, column_name);
 }
 
-static bool ColumnIsGenerated(Binding *binding, column_t index) {
-	if (binding->binding_type != BindingType::TABLE) {
+static bool ColumnIsGenerated(Binding &binding, column_t index) {
+	if (binding.binding_type != BindingType::TABLE) {
 		return false;
 	}
-	auto table_binding = (TableBinding *)binding;
-	auto catalog_entry = table_binding->GetStandardEntry();
+	auto &table_binding = (TableBinding &)binding;
+	auto catalog_entry = table_binding.GetStandardEntry();
 	if (!catalog_entry) {
 		return false;
 	}
@@ -191,8 +185,8 @@ static bool ColumnIsGenerated(Binding *binding, column_t index) {
 		return false;
 	}
 	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto table_entry = (TableCatalogEntry *)catalog_entry;
-	return table_entry->GetColumn(LogicalIndex(index)).Generated();
+	auto &table_entry = catalog_entry->Cast<TableCatalogEntry>();
+	return table_entry.GetColumn(LogicalIndex(index)).Generated();
 }
 
 unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &catalog_name, const string &schema_name,
@@ -208,13 +202,13 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ca
 	names.push_back(table_name);
 	names.push_back(column_name);
 
-	auto result = make_unique<ColumnRefExpression>(std::move(names));
+	auto result = make_uniq<ColumnRefExpression>(std::move(names));
 	auto binding = GetBinding(table_name, error_message);
 	if (!binding) {
 		return std::move(result);
 	}
 	auto column_index = binding->GetBindingIndex(column_name);
-	if (ColumnIsGenerated(binding, column_index)) {
+	if (ColumnIsGenerated(*binding, column_index)) {
 		return ExpandGeneratedColumn(table_name, column_name);
 	} else if (column_index < binding->names.size() && binding->names[column_index] != column_name) {
 		// because of case insensitivity in the binder we rename the column to the original name
@@ -230,7 +224,7 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &sc
 	return CreateColumnReference(catalog_name, schema_name, table_name, column_name);
 }
 
-Binding *BindContext::GetCTEBinding(const string &ctename) {
+optional_ptr<Binding> BindContext::GetCTEBinding(const string &ctename) {
 	auto match = cte_bindings.find(ctename);
 	if (match == cte_bindings.end()) {
 		return nullptr;
@@ -238,7 +232,7 @@ Binding *BindContext::GetCTEBinding(const string &ctename) {
 	return match->second.get();
 }
 
-Binding *BindContext::GetBinding(const string &name, string &out_error) {
+optional_ptr<Binding> BindContext::GetBinding(const string &name, string &out_error) {
 	auto match = bindings.find(name);
 	if (match == bindings.end()) {
 		// alias not found in this BindContext
@@ -271,16 +265,17 @@ string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table
 	idx_t total_columns = 0;
 	idx_t current_position = ref.index - 1;
 	for (auto &entry : bindings_list) {
-		idx_t entry_column_count = entry.second->names.size();
+		auto &binding = entry.get();
+		idx_t entry_column_count = binding.names.size();
 		if (ref.index == 0) {
 			// this is a row id
-			table_name = entry.first;
+			table_name = binding.alias;
 			column_name = "rowid";
 			return string();
 		}
 		if (current_position < entry_column_count) {
-			table_name = entry.first;
-			column_name = entry.second->names[current_position];
+			table_name = binding.alias;
+			column_name = binding.names[current_position];
 			return string();
 		} else {
 			total_columns += entry_column_count;
@@ -297,11 +292,11 @@ BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t dep
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto column_ref = make_unique<ColumnRefExpression>(column_name, table_name);
+	auto column_ref = make_uniq<ColumnRefExpression>(column_name, table_name);
 	return BindColumn(*column_ref, depth);
 }
 
-bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, const string &column_name,
+bool BindContext::CheckExclusionList(StarExpression &expr, const string &column_name,
                                      vector<unique_ptr<ParsedExpression>> &new_select_list,
                                      case_insensitive_set_t &excluded_columns) {
 	if (expr.exclude_list.find(column_name) != expr.exclude_list.end()) {
@@ -319,45 +314,26 @@ bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, con
 	return false;
 }
 
-bool CheckRegex(const string &column_name, duckdb_re2::RE2 *regex) {
-	if (!regex) {
-		return true;
-	}
-	return RE2::PartialMatch(column_name, *regex);
-}
-
 void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
                                                vector<unique_ptr<ParsedExpression>> &new_select_list) {
 	if (bindings_list.empty()) {
-		throw BinderException("SELECT * expression without FROM clause!");
+		throw BinderException("* expression without FROM clause!");
 	}
 	case_insensitive_set_t excluded_columns;
 	if (expr.relation_name.empty()) {
 		// SELECT * case
 		// bind all expressions of each table in-order
-		unique_ptr<duckdb_re2::RE2> regex;
-		bool found_match = true;
-		if (!expr.regex.empty()) {
-			regex = make_unique<duckdb_re2::RE2>(expr.regex);
-			if (!regex->error().empty()) {
-				throw BinderException("Failed to compile regex \"%s\": %s", expr.regex, regex->error());
-			}
-			found_match = false;
-		}
-		unordered_set<UsingColumnSet *> handled_using_columns;
+		reference_set_t<UsingColumnSet> handled_using_columns;
 		for (auto &entry : bindings_list) {
-			auto binding = entry.second;
-			for (auto &column_name : binding->names) {
-				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
+			auto &binding = entry.get();
+			for (auto &column_name : binding.names) {
+				if (CheckExclusionList(expr, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
-				if (!CheckRegex(column_name, regex.get())) {
-					continue;
-				}
-				found_match = true;
 				// check if this column is a USING column
-				auto using_binding = GetUsingBinding(column_name, binding->alias);
-				if (using_binding) {
+				auto using_binding_ptr = GetUsingBinding(column_name, binding.alias);
+				if (using_binding_ptr) {
+					auto &using_binding = *using_binding_ptr;
 					// it is!
 					// check if we have already emitted the using column
 					if (handled_using_columns.find(using_binding) != handled_using_columns.end()) {
@@ -365,28 +341,25 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 						continue;
 					}
 					// we have not! output the using column
-					if (using_binding->primary_binding.empty()) {
+					if (using_binding.primary_binding.empty()) {
 						// no primary binding: output a coalesce
-						auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-						for (auto &child_binding : using_binding->bindings) {
-							coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, child_binding));
+						auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
+						for (auto &child_binding : using_binding.bindings) {
+							coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, child_binding));
 						}
 						coalesce->alias = column_name;
 						new_select_list.push_back(std::move(coalesce));
 					} else {
 						// primary binding: output the qualified column ref
 						new_select_list.push_back(
-						    make_unique<ColumnRefExpression>(column_name, using_binding->primary_binding));
+						    make_uniq<ColumnRefExpression>(column_name, using_binding.primary_binding));
 					}
 					handled_using_columns.insert(using_binding);
 					continue;
 				}
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_name, binding.alias));
 			}
 		}
-		if (!found_match) {
-			throw BinderException("No matching columns found that match regex \"%s\"", expr.regex);
-		}
 	} else {
 		// SELECT tbl.* case
 		// SELECT struct.* case
@@ -414,19 +387,19 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 			column_names[0] = binding->alias;
 			column_names[1] = expr.relation_name;
 			for (auto &child : struct_children) {
-				if (CheckExclusionList(expr, binding, child.first, new_select_list, excluded_columns)) {
+				if (CheckExclusionList(expr, child.first, new_select_list, excluded_columns)) {
 					continue;
 				}
 				column_names[2] = child.first;
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_names));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_names));
 			}
 		} else {
 			for (auto &column_name : binding->names) {
-				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
+				if (CheckExclusionList(expr, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
 
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_name, binding->alias));
 			}
 		}
 	}
@@ -444,24 +417,35 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 	}
 }
 
+void BindContext::GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types) {
+	for (auto &binding_entry : bindings_list) {
+		auto &binding = binding_entry.get();
+		D_ASSERT(binding.names.size() == binding.types.size());
+		for (idx_t i = 0; i < binding.names.size(); i++) {
+			result_names.push_back(binding.names[i]);
+			result_types.push_back(binding.types[i]);
+		}
+	}
+}
+
 void BindContext::AddBinding(const string &alias, unique_ptr<Binding> binding) {
 	if (bindings.find(alias) != bindings.end()) {
 		throw BinderException("Duplicate alias \"%s\" in query!", alias);
 	}
-	bindings_list.emplace_back(alias, binding.get());
+	bindings_list.push_back(*binding);
 	bindings[alias] = std::move(binding);
 }
 
 void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
                                const vector<LogicalType> &types, vector<column_t> &bound_column_ids,
                                StandardEntry *entry, bool add_row_id) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index, add_row_id));
+	AddBinding(alias, make_uniq<TableBinding>(alias, types, names, bound_column_ids, entry, index, add_row_id));
 }
 
 void BindContext::AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
                                    const vector<LogicalType> &types, vector<column_t> &bound_column_ids,
                                    StandardEntry *entry) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index));
+	AddBinding(alias, make_uniq<TableBinding>(alias, types, names, bound_column_ids, entry, index));
 }
 
 static string AddColumnNameToBinding(const string &base_name, case_insensitive_set_t &current_names) {
@@ -501,7 +485,7 @@ void BindContext::AddSubquery(idx_t index, const string &alias, SubqueryRef &ref
 void BindContext::AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
                                   const vector<LogicalType> &types, StandardEntry *entry) {
 	D_ASSERT(entry);
-	AddBinding(alias, make_unique<EntryBinding>(alias, types, names, index, *entry));
+	AddBinding(alias, make_uniq<EntryBinding>(alias, types, names, index, *entry));
 }
 
 void BindContext::AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery,
@@ -517,7 +501,7 @@ void BindContext::AddSubquery(idx_t index, const string &alias, TableFunctionRef
 
 void BindContext::AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
                                     const vector<LogicalType> &types) {
-	AddBinding(alias, make_unique<Binding>(BindingType::BASE, alias, types, names, index));
+	AddBinding(alias, make_uniq<Binding>(BindingType::BASE, alias, types, names, index));
 }
 
 void BindContext::AddCTEBinding(idx_t index, const string &alias, const vector<string> &names,
@@ -539,14 +523,14 @@ void BindContext::AddContext(BindContext other) {
 		bindings[binding.first] = std::move(binding.second);
 	}
 	for (auto &binding : other.bindings_list) {
-		bindings_list.push_back(std::move(binding));
+		bindings_list.push_back(binding);
 	}
 	for (auto &entry : other.using_columns) {
 		for (auto &alias : entry.second) {
 #ifdef DEBUG
 			for (auto &other_alias : using_columns[entry.first]) {
-				for (auto &col : alias->bindings) {
-					D_ASSERT(other_alias->bindings.find(col) == other_alias->bindings.end());
+				for (auto &col : alias.get().bindings) {
+					D_ASSERT(other_alias.get().bindings.find(col) == other_alias.get().bindings.end());
 				}
 			}
 #endif
@@ -555,19 +539,19 @@ void BindContext::AddContext(BindContext other) {
 	}
 }
 
-void BindContext::RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list) {
+void BindContext::RemoveContext(vector<reference<Binding>> &other_bindings_list) {
 	for (auto &other_binding : other_bindings_list) {
-		if (bindings.find(other_binding.first) != bindings.end()) {
-			bindings.erase(other_binding.first);
-		}
+		auto it = std::remove_if(bindings_list.begin(), bindings_list.end(), [other_binding](reference<Binding> x) {
+			return x.get().alias == other_binding.get().alias;
+		});
+		bindings_list.erase(it, bindings_list.end());
 	}
 
-	vector<idx_t> delete_list_indexes;
 	for (auto &other_binding : other_bindings_list) {
-		auto it =
-		    std::remove_if(bindings_list.begin(), bindings_list.end(),
-		                   [other_binding](std::pair<string, Binding *> &x) { return x.first == other_binding.first; });
-		bindings_list.erase(it, bindings_list.end());
+		auto &alias = other_binding.get().alias;
+		if (bindings.find(alias) != bindings.end()) {
+			bindings.erase(alias);
+		}
 	}
 }
 

package/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp

@@ -7,7 +7,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
@@ -60,13 +60,13 @@ static Value NegatePercentileValue(const Value &v, const bool desc) {
 static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedExpression> &fractions, bool desc) {
 	D_ASSERT(fractions.get());
 	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*fractions;
+	auto &bound = BoundExpression::GetExpression(*fractions);
 
-	if (!bound.expr->IsFoldable()) {
+	if (!bound->IsFoldable()) {
 		return;
 	}
 
-	Value value = ExpressionExecutor::EvaluateScalar(context, *bound.expr);
+	Value value = ExpressionExecutor::EvaluateScalar(context, *bound);
 	if (value.type().id() == LogicalTypeId::LIST) {
 		vector<Value> values;
 		for (const auto &element_val : ListValue::GetChildren(value)) {
@@ -75,13 +75,13 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		if (values.empty()) {
 			throw BinderException("Empty list in percentile not allowed");
 		}
-		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
+		bound = make_uniq<BoundConstantExpression>(Value::LIST(values));
 	} else {
-		bound.expr = make_unique<BoundConstantExpression>(NegatePercentileValue(value, desc));
+		bound = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
 	}
 }
 
-BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry &func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -137,8 +137,8 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.children[i];
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.children[i]);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.filter) {
 				bool success = aggregate_binder.BindCorrelatedColumns(aggr.filter);
@@ -146,8 +146,8 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.filter;
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.filter);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
 				for (auto &order : aggr.order_bys->orders) {
@@ -155,8 +155,8 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 					if (!success) {
 						throw BinderException(error);
 					}
-					auto &bound_expr = (BoundExpression &)*order.expression;
-					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+					auto &bound_expr = BoundExpression::GetExpression(*order.expression);
+					ExtractCorrelatedExpressions(binder, *bound_expr);
 				}
 			}
 		} else {
@@ -171,8 +171,8 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	}
 
 	if (aggr.filter) {
-		auto &child = (BoundExpression &)*aggr.filter;
-		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child.expr), LogicalType::BOOLEAN);
+		auto &child = BoundExpression::GetExpression(*aggr.filter);
+		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN);
 	}
 
 	// all children bound successfully
@@ -183,59 +183,58 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 
 	if (ordered_set_agg) {
 		for (auto &order : aggr.order_bys->orders) {
-			auto &child = (BoundExpression &)*order.expression;
-			types.push_back(child.expr->return_type);
-			arguments.push_back(child.expr->return_type);
-			children.push_back(std::move(child.expr));
+			auto &child = BoundExpression::GetExpression(*order.expression);
+			types.push_back(child->return_type);
+			arguments.push_back(child->return_type);
+			children.push_back(std::move(child));
 		}
 		aggr.order_bys->orders.clear();
 	}
 
 	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = (BoundExpression &)*aggr.children[i];
-		types.push_back(child.expr->return_type);
-		arguments.push_back(child.expr->return_type);
-		children.push_back(std::move(child.expr));
+		auto &child = BoundExpression::GetExpression(*aggr.children[i]);
+		types.push_back(child->return_type);
+		arguments.push_back(child->return_type);
+		children.push_back(std::move(child));
 	}
 
 	// bind the aggregate
 	FunctionBinder function_binder(context);
-	idx_t best_function = function_binder.BindFunction(func->name, func->functions, types, error);
+	idx_t best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
 		throw BinderException(binder.FormatError(aggr, error));
 	}
 	// found a matching function!
-	auto bound_function = func->functions.GetFunctionByOffset(best_function);
+	auto bound_function = func.functions.GetFunctionByOffset(best_function);
 
 	// Bind any sort columns, unless the aggregate is order-insensitive
-	auto order_bys = make_unique<BoundOrderModifier>();
+	unique_ptr<BoundOrderModifier> order_bys;
 	if (!aggr.order_bys->orders.empty()) {
+		order_bys = make_uniq<BoundOrderModifier>();
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
-			auto &order_expr = (BoundExpression &)*order.expression;
-			const auto sense =
-			    (order.type == OrderType::ORDER_DEFAULT) ? config.options.default_order_type : order.type;
-			const auto null_order = (order.null_order == OrderByNullType::ORDER_DEFAULT)
-			                            ? config.options.default_null_order
-			                            : order.null_order;
-			order_bys->orders.emplace_back(BoundOrderByNode(sense, null_order, std::move(order_expr.expr)));
+			auto &order_expr = BoundExpression::GetExpression(*order.expression);
+			const auto sense = config.ResolveOrder(order.type);
+			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
+			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));
 		}
 	}
 
-	auto aggregate = function_binder.BindAggregateFunction(
-	    bound_function, std::move(children), std::move(bound_filter),
-	    aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT, std::move(order_bys));
+	auto aggregate =
+	    function_binder.BindAggregateFunction(bound_function, std::move(children), std::move(bound_filter),
+	                                          aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
 	if (aggr.export_state) {
 		aggregate = ExportAggregateFunction::Bind(std::move(aggregate));
 	}
+	aggregate->order_bys = std::move(order_bys);
 
 	// check for all the aggregates if this aggregate already exists
 	idx_t aggr_index;
-	auto entry = node.aggregate_map.find(aggregate.get());
+	auto entry = node.aggregate_map.find(*aggregate);
 	if (entry == node.aggregate_map.end()) {
 		// new aggregate: insert into aggregate list
 		aggr_index = node.aggregates.size();
-		node.aggregate_map.insert(make_pair(aggregate.get(), aggr_index));
+		node.aggregate_map[*aggregate] = aggr_index;
 		node.aggregates.push_back(std::move(aggregate));
 	} else {
 		// duplicate aggregate: simplify refer to this aggregate
@@ -243,7 +242,7 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	}
 
 	// now create a column reference referring to the aggregate
-	auto colref = make_unique<BoundColumnRefExpression>(
+	auto colref = make_uniq<BoundColumnRefExpression>(
 	    aggr.alias.empty() ? node.aggregates[aggr_index]->ToString() : aggr.alias,
 	    node.aggregates[aggr_index]->return_type, ColumnBinding(node.aggregate_index, aggr_index), depth);
 	// move the aggregate expression into the set of bound aggregates