duckdb 0.7.2-dev1734.0 → 0.7.2-dev1867.0

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

@@ -10,9 +10,9 @@ namespace duckdb {
 //! The ConstantFoldingExpressionMatcher matches on any scalar expression (i.e. Expression::IsFoldable is true)
 class ConstantFoldingExpressionMatcher : public FoldableConstantMatcher {
 public:
-	bool Match(Expression *expr, vector<Expression *> &bindings) override {
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override {
 		// we also do not match on ConstantExpressions, because we cannot fold those any further
-		if (expr->type == ExpressionType::VALUE_CONSTANT) {
+		if (expr.type == ExpressionType::VALUE_CONSTANT) {
 			return false;
 		}
 		return FoldableConstantMatcher::Match(expr, bindings);
@@ -24,18 +24,18 @@ ConstantFoldingRule::ConstantFoldingRule(ExpressionRewriter &rewriter) : Rule(re
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                   bool &changes_made, bool is_root) {
-	auto root = bindings[0];
+	auto &root = bindings[0].get();
 	// the root is a scalar expression that we have to fold
-	D_ASSERT(root->IsFoldable() && root->type != ExpressionType::VALUE_CONSTANT);
+	D_ASSERT(root.IsFoldable() && root.type != ExpressionType::VALUE_CONSTANT);
 
 	// use an ExpressionExecutor to execute the expression
 	Value result_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *root, result_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), root, result_value)) {
 		return nullptr;
 	}
-	D_ASSERT(result_value.type().InternalType() == root->return_type.InternalType());
+	D_ASSERT(result_value.type().InternalType() == root.return_type.InternalType());
 	// now get the value from the result vector and insert it back into the plan as a constant expression
 	return make_uniq<BoundConstantExpression>(result_value);
 }

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

@@ -20,10 +20,10 @@ DatePartSimplificationRule::DatePartSimplificationRule(ExpressionRewriter &rewri
 	root = std::move(func);
 }
 
-unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                          bool &changes_made, bool is_root) {
-	auto &date_part = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[1]->Cast<BoundConstantExpression>();
+	auto &date_part = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[1].get().Cast<BoundConstantExpression>();
 	auto &constant = constant_expr.value;
 
 	if (constant.IsNull()) {

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

@@ -18,10 +18,10 @@ void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &se
 	if (expr.type == ExpressionType::CONJUNCTION_AND) {
 		auto &and_expr = expr.Cast<BoundConjunctionExpression>();
 		for (auto &child : and_expr.children) {
-			set.insert(child.get());
+			set.insert(*child);
 		}
 	} else {
-		set.insert(&expr);
+		set.insert(expr);
 	}
 }
 
@@ -53,9 +53,9 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 	return result;
 }
 
-unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                  bool &changes_made, bool is_root) {
-	auto &initial_or = bindings[0]->Cast<BoundConjunctionExpression>();
+	auto &initial_or = bindings[0].get().Cast<BoundConjunctionExpression>();
 
 	// we want to find expressions that occur in each of the children of the OR
 	// i.e. (X AND A) OR (X AND B) => X occurs in all branches
@@ -88,7 +88,7 @@ unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Exp
 		D_ASSERT(initial_or.children.size() > 0);
 
 		// extract the expression from the first child of the OR
-		auto result = ExtractExpression(initial_or, 0, (Expression &)*expr);
+		auto result = ExtractExpression(initial_or, 0, expr.get());
 		// now for the subsequent expressions, simply remove the expression
 		for (idx_t i = 1; i < initial_or.children.size(); i++) {
 			ExtractExpression(initial_or, i, *result);

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

@@ -21,25 +21,25 @@ EmptyNeedleRemovalRule::EmptyNeedleRemovalRule(ExpressionRewriter &rewriter) : R
 	root = std::move(func);
 }
 
-unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
 	D_ASSERT(root.children.size() == 2);
-	auto prefix_expr = bindings[2];
+	auto &prefix_expr = bindings[2].get();
 
 	// the constant_expr is a scalar expression that we have to fold
-	if (!prefix_expr->IsFoldable()) {
+	if (!prefix_expr.IsFoldable()) {
 		return nullptr;
 	}
 	D_ASSERT(root.return_type.id() == LogicalTypeId::BOOLEAN);
 
-	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), *prefix_expr);
+	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), prefix_expr);
 
 	if (prefix_value.IsNull()) {
 		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
 
-	D_ASSERT(prefix_value.type() == prefix_expr->return_type);
+	D_ASSERT(prefix_value.type() == prefix_expr.return_type);
 	auto &needle_string = StringValue::Get(prefix_value);
 
 	// PREFIX('xyz', '') is TRUE

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

@@ -44,12 +44,12 @@ bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
 	}
 	return false;
 }
-unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                  bool &changes_made, bool is_root) {
 
-	auto &root = bindings[0]->Cast<BoundComparisonExpression>();
-	auto &left_child = bindings[1]->Cast<BoundCastExpression>();
-	auto &right_child = bindings[3]->Cast<BoundCastExpression>();
+	auto &root = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto &left_child = bindings[1].get().Cast<BoundCastExpression>();
+	auto &right_child = bindings[3].get().Cast<BoundCastExpression>();
 
 	if (!AreMatchesPossible(left_child.child->return_type, right_child.child->return_type)) {
 		vector<unique_ptr<Expression>> children;

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

@@ -37,31 +37,30 @@ 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(const Expression *equal_expr, const Expression *and_expr) {
-	if (equal_expr->type != ExpressionType::COMPARE_EQUAL || and_expr->type != ExpressionType::CONJUNCTION_AND) {
+static unique_ptr<Expression> TryRewriteEqualOrIsNull(Expression &equal_expr, Expression &and_expr) {
+	if (equal_expr.type != ExpressionType::COMPARE_EQUAL || and_expr.type != ExpressionType::CONJUNCTION_AND) {
 		return nullptr;
 	}
 
-	const auto equal_cast = (BoundComparisonExpression *)equal_expr;
-	const auto and_cast = (BoundConjunctionExpression *)and_expr;
+	auto &equal_cast = equal_expr.Cast<BoundComparisonExpression>();
+	auto &and_cast = and_expr.Cast<BoundConjunctionExpression>();
 
-	if (and_cast->children.size() != 2) {
+	if (and_cast.children.size() != 2) {
 		return nullptr;
 	}
 
 	// Make sure on the AND conjuction the relevant conditions appear
-	const auto a_exp = equal_cast->left.get();
-	const auto b_exp = equal_cast->right.get();
-	bool valid = true;
+	auto &a_exp = *equal_cast.left;
+	auto &b_exp = *equal_cast.right;
 	bool a_is_null_found = false;
 	bool b_is_null_found = false;
 
-	for (const auto &item : and_cast->children) {
-		const auto next_exp = item.get();
+	for (const auto &item : and_cast.children) {
+		auto &next_exp = *item;
 
-		if (next_exp->type == ExpressionType::OPERATOR_IS_NULL) {
-			const auto next_exp_cast = (BoundOperatorExpression *)next_exp;
-			const auto child = next_exp_cast->children[0].get();
+		if (next_exp.type == ExpressionType::OPERATOR_IS_NULL) {
+			auto &next_exp_cast = next_exp.Cast<BoundOperatorExpression>();
+			auto &child = *next_exp_cast.children[0];
 
 			// Test for equality on both 'a' and 'b' expressions
 			if (Expression::Equals(child, a_exp)) {
@@ -69,37 +68,35 @@ static unique_ptr<Expression> TryRewriteEqualOrIsNull(const Expression *equal_ex
 			} else if (Expression::Equals(child, b_exp)) {
 				b_is_null_found = true;
 			} else {
-				valid = false;
-				break;
+				return nullptr;
 			}
 		} else {
-			valid = false;
-			break;
+			return nullptr;
 		}
 	}
-	if (valid && a_is_null_found && b_is_null_found) {
+	if (a_is_null_found && b_is_null_found) {
 		return make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-		                                            std::move(equal_cast->left), std::move(equal_cast->right));
+		                                            std::move(equal_cast.left), std::move(equal_cast.right));
 	}
 	return nullptr;
 }
 
-unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                         bool &changes_made, bool is_root) {
-	const Expression *or_exp = bindings[0];
+	const Expression &or_exp = bindings[0].get();
 
-	if (or_exp->type != ExpressionType::CONJUNCTION_OR) {
+	if (or_exp.type != ExpressionType::CONJUNCTION_OR) {
 		return nullptr;
 	}
 
-	const auto or_exp_cast = (BoundConjunctionExpression *)or_exp;
+	const auto &or_exp_cast = or_exp.Cast<BoundConjunctionExpression>();
 
-	if (or_exp_cast->children.size() != 2) {
+	if (or_exp_cast.children.size() != 2) {
 		return nullptr;
 	}
 
-	const auto left_exp = or_exp_cast->children[0].get();
-	const auto right_exp = or_exp_cast->children[1].get();
+	auto &left_exp = *or_exp_cast.children[0];
+	auto &right_exp = *or_exp_cast.children[1];
 	// Test for: a=b OR (a IS NULL AND b IS NULL)
 	auto first_try = TryRewriteEqualOrIsNull(left_exp, right_exp);
 	if (first_try) {

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

@@ -12,10 +12,9 @@ InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewri
 	root = std::move(op);
 }
 
-unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                          bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_OPERATOR);
-	auto &expr = bindings[0]->Cast<BoundOperatorExpression>();
+	auto &expr = bindings[0].get().Cast<BoundOperatorExpression>();
 	if (expr.children[0]->expression_class != ExpressionClass::BOUND_CAST) {
 		return nullptr;
 	}

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

@@ -99,10 +99,10 @@ static bool PatternIsContains(const string &pattern) {
 	return true;
 }
 
-unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                    bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
 	D_ASSERT(root.children.size() == 2);
 
 	if (constant_expr.value.IsNull()) {

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

@@ -28,12 +28,12 @@ MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewrit
 	root = std::move(op);
 }
 
-unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-                                                bool is_root) {
-	auto &comparison = bindings[0]->Cast<BoundComparisonExpression>();
-	auto &outer_constant = bindings[1]->Cast<BoundConstantExpression>();
-	auto &arithmetic = bindings[2]->Cast<BoundFunctionExpression>();
-	auto &inner_constant = bindings[3]->Cast<BoundConstantExpression>();
+unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                bool &changes_made, bool is_root) {
+	auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
+	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;
 	}

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

@@ -11,9 +11,9 @@ OrderedAggregateOptimizer::OrderedAggregateOptimizer(ExpressionRewriter &rewrite
 	root->expr_class = ExpressionClass::BOUND_AGGREGATE;
 }
 
-unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                         bool &changes_made, bool is_root) {
-	auto &aggr = bindings[0]->Cast<BoundAggregateExpression>();
+	auto &aggr = bindings[0].get().Cast<BoundAggregateExpression>();
 	if (!aggr.order_bys) {
 		// no ORDER BYs defined
 		return nullptr;

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

@@ -18,10 +18,10 @@ RegexOptimizationRule::RegexOptimizationRule(ExpressionRewriter &rewriter) : Rul
 	root = std::move(func);
 }
 
-unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                     bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
 	D_ASSERT(root.children.size() == 2);
 
 	if (constant_expr.value.IsNull()) {
@@ -44,17 +44,18 @@ unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<
 
 	if (pattern.Regexp()->op() == duckdb_re2::kRegexpLiteralString ||
 	    pattern.Regexp()->op() == duckdb_re2::kRegexpLiteral) {
-		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, ContainsFun::GetFunction(),
-		                                                   std::move(root.children), nullptr);
 
 		string min;
 		string max;
-		pattern.PossibleMatchRange(&min, &max, patt_str.size());
-		if (min == max) {
-			contains->children[1] = make_uniq<BoundConstantExpression>(Value(std::move(min)));
-		} else {
-			contains->children[1] = make_uniq<BoundConstantExpression>(Value(std::move(patt_str)));
+		pattern.PossibleMatchRange(&min, &max, patt_str.size() + 1);
+		if (min != max) {
+			return nullptr;
 		}
+		auto parameter = make_uniq<BoundConstantExpression>(Value(std::move(min)));
+		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, ContainsFun::GetFunction(),
+		                                                   std::move(root.children), nullptr);
+		contains->children[1] = std::move(parameter);
+
 		return std::move(contains);
 	}
 	return nullptr;

package/src/duckdb/src/parser/expression_util.cpp

@@ -18,7 +18,7 @@ bool ExpressionUtil::ExpressionListEquals(const vector<unique_ptr<T>> &a, const
 	return true;
 }
 
-template <class T>
+template <class T, class EXPRESSION_MAP>
 bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
 	if (a.size() != b.size()) {
 		return false;
@@ -26,14 +26,14 @@ bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const v
 	// we create a map of expression -> count for the left side
 	// we keep the count because the same expression can occur multiple times (e.g. "1 AND 1" is legal)
 	// in this case we track the following value: map["Constant(1)"] = 2
-	expression_map_t<idx_t> map;
+	EXPRESSION_MAP map;
 	for (idx_t i = 0; i < a.size(); i++) {
-		map[a[i].get()]++;
+		map[*a[i]]++;
 	}
 	// now on the right side we reduce the counts again
 	// if the conjunctions are identical, all the counts will be 0 after the
 	for (auto &expr : b) {
-		auto entry = map.find(expr.get());
+		auto entry = map.find(*expr);
 		// first we check if we can find the expression in the map at all
 		if (entry == map.end()) {
 			return false;
@@ -62,11 +62,11 @@ bool ExpressionUtil::ListEquals(const vector<unique_ptr<Expression>> &a, const v
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<ParsedExpression>> &a,
                                const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionSetEquals<ParsedExpression>(a, b);
+	return ExpressionSetEquals<ParsedExpression, parsed_expression_map_t<idx_t>>(a, b);
 }
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionSetEquals<Expression>(a, b);
+	return ExpressionSetEquals<Expression, expression_map_t<idx_t>>(a, b);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp

@@ -22,7 +22,7 @@ static void CheckGroupingSetCubes(idx_t current_count, idx_t cube_count) {
 }
 
 struct GroupingExpressionMap {
-	expression_map_t<idx_t> map;
+	parsed_expression_map_t<idx_t> map;
 };
 
 static GroupingSet VectorToGroupingSet(vector<idx_t> &indexes) {
@@ -49,11 +49,11 @@ void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression,
 			return;
 		}
 	}
-	auto entry = map.map.find(expression.get());
+	auto entry = map.map.find(*expression);
 	idx_t result_idx;
 	if (entry == map.map.end()) {
 		result_idx = result.group_expressions.size();
-		map.map[expression.get()] = result_idx;
+		map.map[*expression] = result_idx;
 		result.group_expressions.push_back(std::move(expression));
 	} else {
 		result_idx = entry->second;

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

@@ -233,11 +233,11 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 
 	// 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

package/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp

@@ -329,7 +329,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
 	case_insensitive_map_t<idx_t> alias_map;
-	expression_map_t<idx_t> projection_map;
+	parsed_expression_map_t<idx_t> projection_map;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
@@ -338,7 +338,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			alias_map[expr->alias] = i;
 			result->names[i] = expr->alias;
 		}
-		projection_map[expr.get()] = i;
+		projection_map[*expr] = i;
 		result->original_expressions.push_back(expr->Copy());
 	}
 	result->column_count = statement.select_list.size();
@@ -391,7 +391,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			// hence we convert "a" -> "test.a" in the unbound expression
 			unbound_groups[i] = std::move(group_binder.unbound_expression);
 			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
-			info.map[unbound_groups[i].get()] = i;
+			info.map[*unbound_groups[i]] = i;
 		}
 	}
 	result->groups.grouping_sets = std::move(statement.groups.grouping_sets);

package/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp

@@ -13,7 +13,7 @@
 namespace duckdb {
 
 static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
-                          expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
+                          parsed_expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
 		auto &setop = node.Cast<BoundSetOperationNode>();
@@ -66,16 +66,16 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 				aliases[name] = index;
 			}
 			// now check if the node is already in the set of expressions
-			auto expr_entry = expressions.find(expr.get());
+			auto expr_entry = expressions.find(*expr);
 			if (expr_entry != expressions.end()) {
 				// the node is in there
 				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
 				if (expr_entry->second != index) {
-					expressions[expr.get()] = DConstants::INVALID_INDEX;
+					expressions[*expr] = DConstants::INVALID_INDEX;
 				}
 			} else {
 				// not in there yet, just place it in there
-				expressions[expr.get()] = index;
+				expressions[*expr] = index;
 			}
 		}
 	}
@@ -240,7 +240,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced
 		// in the ORDER BY
 		case_insensitive_map_t<idx_t> alias_map;
-		expression_map_t<idx_t> expression_map;
+		parsed_expression_map_t<idx_t> expression_map;
 
 		if (result->setop_type == SetOperationType::UNION_BY_NAME) {
 			GatherAliases(*result->left, alias_map, expression_map, result->left_reorder_idx);

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -297,10 +297,10 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		auto type_dependency = LogicalType::GetCatalog(column.Type());
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(type_dependency);
+			result->dependencies.AddDependency(*type_dependency);
 		}
 	}
-	result->dependencies.VerifyDependencies(schema->catalog, result->Base().table);
+	result->dependencies.VerifyDependencies(*schema->catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -56,14 +56,14 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 	// no alias reference found
 	// check the list of group columns for a match
-	auto entry = info.map.find(&expr);
+	auto entry = info.map.find(expr);
 	if (entry != info.map.end()) {
 		return entry->second;
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first->Equals(&expr));
-		D_ASSERT(!expr.Equals(entry.first));
+		D_ASSERT(!entry.first.get().Equals(&expr));
+		D_ASSERT(!expr.Equals(&entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;
@@ -77,7 +77,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_pt
 	}
 	// binding failed
 	// check in the alias map
-	auto &colref = (ColumnRefExpression &)**expr_ptr;
+	auto &colref = (*expr_ptr)->Cast<ColumnRefExpression>();
 	if (!colref.IsQualified()) {
 		auto alias_entry = alias_map.find(colref.column_names[0]);
 		if (alias_entry != alias_map.end()) {

package/src/duckdb/src/planner/expression_binder/order_binder.cpp

@@ -13,12 +13,12 @@
 namespace duckdb {
 
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-                         expression_map_t<idx_t> &projection_map, idx_t max_count)
+                         parsed_expression_map_t<idx_t> &projection_map, idx_t max_count)
     : binders(std::move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
       alias_map(alias_map), projection_map(projection_map) {
 }
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
+                         case_insensitive_map_t<idx_t> &alias_map, parsed_expression_map_t<idx_t> &projection_map)
     : binders(std::move(binders)), projection_index(projection_index), alias_map(alias_map),
       projection_map(projection_map) {
 	this->max_count = node.select_list.size();
@@ -111,7 +111,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		ExpressionBinder::QualifyColumnNames(*binder, expr);
 	}
 	// first check if the ORDER BY clause already points to an entry in the projection list
-	auto entry = projection_map.find(expr.get());
+	auto entry = projection_map.find(*expr);
 	if (entry != projection_map.end()) {
 		if (entry->second == DConstants::INVALID_INDEX) {
 			throw BinderException("Ambiguous reference to column");

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -3,13 +3,14 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 #include "duckdb/common/file_buffer.hpp"
 
 namespace duckdb {
 
 BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p)
     : block_manager(block_manager), readers(0), block_id(block_id_p), buffer(nullptr), eviction_timestamp(0),
-      can_destroy(false), unswizzled(nullptr) {
+      can_destroy(false), memory_charge(block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr) {
 	eviction_timestamp = 0;
 	state = BlockState::BLOCK_UNLOADED;
 	memory_usage = Storage::BLOCK_ALLOC_SIZE;
@@ -18,7 +19,7 @@ BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p)
 BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
                          bool can_destroy_p, idx_t block_size, BufferPoolReservation &&reservation)
     : block_manager(block_manager), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p),
-      unswizzled(nullptr) {
+      memory_charge(block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr) {
 	buffer = std::move(buffer_p);
 	state = BlockState::BLOCK_LOADED;
 	memory_usage = block_size;
@@ -34,11 +35,11 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
 		D_ASSERT(memory_charge.size > 0);
 		// the block is still loaded in memory: erase it
 		buffer.reset();
-		memory_charge.Resize(buffer_manager.buffer_pool.current_memory, 0);
+		memory_charge.Resize(0);
 	} else {
 		D_ASSERT(memory_charge.size == 0);
 	}
-	buffer_manager.buffer_pool.PurgeQueue();
+	buffer_manager.GetBufferPool().PurgeQueue();
 	block_manager.UnregisterBlock(block_id, can_destroy);
 }
 
@@ -97,7 +98,7 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 		// temporary block that cannot be destroyed: write to temporary file
 		block_manager.buffer_manager.WriteTemporaryBuffer(block_id, *buffer);
 	}
-	memory_charge.Resize(block_manager.buffer_manager.buffer_pool.current_memory, 0);
+	memory_charge.Resize(0);
 	state = BlockState::BLOCK_UNLOADED;
 	return std::move(buffer);
 }
@@ -116,7 +117,7 @@ bool BlockHandle::CanUnload() {
 		// there are active readers
 		return false;
 	}
-	if (block_id >= MAXIMUM_BLOCK && !can_destroy && block_manager.buffer_manager.temp_directory.empty()) {
+	if (block_id >= MAXIMUM_BLOCK && !can_destroy && !block_manager.buffer_manager.HasTemporaryDirectory()) {
 		// in order to unload this block we need to write it to a temporary buffer
 		// however, no temporary directory is specified!
 		// hence we cannot unload the block

package/src/duckdb/src/storage/buffer/block_manager.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 
 namespace duckdb {
 
@@ -62,7 +64,7 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	// persist the new block to disk
 	Write(*new_block->buffer, block_id);
 
-	buffer_manager.buffer_pool.AddToEvictionQueue(new_block);
+	buffer_manager.GetBufferPool().AddToEvictionQueue(new_block);
 
 	return new_block;
 }

package/src/duckdb/src/storage/buffer/buffer_handle.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {