duckdb 0.7.2-dev2320.0 → 0.7.2-dev2410.0

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

@@ -158,11 +158,8 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 				vector<unique_ptr<ParsedExpression>> order_list;
 				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
 
-				auto type =
-				    order_node.type == OrderType::ORDER_DEFAULT ? config.options.default_order_type : order_node.type;
-				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT
-				                      ? config.options.default_null_order
-				                      : order_node.null_order;
+				auto type = config.ResolveOrder(order_node.type);
+				auto null_order = config.ResolveNullOrder(type, order_node.null_order);
 				for (auto &order_expr : order_list) {
 					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
 					if (!bound_expr) {

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

@@ -19,7 +19,7 @@ namespace duckdb {
 unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
                                              idx_t depth) {
 
-	auto &macro_def = (TableMacroFunction &)*macro_func->function;
+	auto &macro_def = macro_func->function->Cast<TableMacroFunction>();
 	auto node = macro_def.query_node->Copy();
 
 	// auto &macro_def = *macro_func->function;

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

@@ -9,7 +9,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
-	PlanSubqueries(&condition, &root);
+	PlanSubqueries(condition, root);
 	auto filter = make_uniq<LogicalFilter>(std::move(condition));
 	filter->AddChild(std::move(root));
 	return std::move(filter);
@@ -34,12 +34,12 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		if (!statement.groups.group_expressions.empty()) {
 			// visit the groups
 			for (auto &group : statement.groups.group_expressions) {
-				PlanSubqueries(&group, &root);
+				PlanSubqueries(group, root);
 			}
 		}
 		// now visit all aggregate expressions
 		for (auto &expr : statement.aggregates) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
 		auto aggregate = make_uniq<LogicalAggregate>(statement.group_index, statement.aggregate_index,
@@ -59,7 +59,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	if (statement.having) {
-		PlanSubqueries(&statement.having, &root);
+		PlanSubqueries(statement.having, root);
 		auto having = make_uniq<LogicalFilter>(std::move(statement.having));
 
 		having->AddChild(std::move(root));
@@ -71,7 +71,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		win->expressions = std::move(statement.windows);
 		// visit the window expressions
 		for (auto &expr : win->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!win->expressions.empty());
 		win->AddChild(std::move(root));
@@ -79,7 +79,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	if (statement.qualify) {
-		PlanSubqueries(&statement.qualify, &root);
+		PlanSubqueries(statement.qualify, root);
 		auto qualify = make_uniq<LogicalFilter>(std::move(statement.qualify));
 
 		qualify->AddChild(std::move(root));
@@ -97,7 +97,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!unnest->expressions.empty());
 		unnest->AddChild(std::move(root));
@@ -105,7 +105,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	for (auto &expr : statement.select_list) {
-		PlanSubqueries(&expr, &root);
+		PlanSubqueries(expr, root);
 	}
 
 	auto proj = make_uniq<LogicalProjection>(statement.projection_index, std::move(statement.select_list));

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

@@ -378,14 +378,14 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 	return result_expression;
 }
 
-void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<LogicalOperator> *root) {
-	if (!*expr_ptr) {
+void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<LogicalOperator> &root) {
+	if (!expr_ptr) {
 		return;
 	}
-	auto &expr = **expr_ptr;
+	auto &expr = *expr_ptr;
 
 	// first visit the children of the node, if any
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(&expr, root); });
+	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
 	// check if this is a subquery node
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
@@ -398,7 +398,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<Logical
 			has_unplanned_subqueries = true;
 			return;
 		}
-		*expr_ptr = PlanSubquery(subquery, *root);
+		expr_ptr = PlanSubquery(subquery, root);
 	}
 }
 

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

@@ -161,7 +161,7 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = (CreateMacroInfo &)info;
-	auto &scalar_function = (ScalarMacroFunction &)*base.function;
+	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
 
 	if (scalar_function.expression->HasParameter()) {
 		throw BinderException("Parameter expressions within macro's are not supported!");
@@ -198,7 +198,7 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto sel_node = make_uniq<BoundSelectNode>();
 	auto group_info = make_uniq<BoundGroupInformation>();
 	SelectBinder binder(*this, context, *sel_node, *group_info);
-	error = binder.Bind(&expression, 0, false);
+	error = binder.Bind(expression, 0, false);
 
 	if (!error.empty()) {
 		throw BinderException(error);

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

@@ -62,7 +62,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		WhereBinder binder(*this, context);
 		condition = binder.Bind(stmt.condition);
 
-		PlanSubqueries(&condition, &root);
+		PlanSubqueries(condition, root);
 		auto filter = make_uniq<LogicalFilter>(std::move(condition));
 		filter->AddChild(std::move(root));
 		root = std::move(filter);

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

@@ -162,7 +162,7 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_pt
 			UpdateBinder binder(*this, context);
 			binder.target_type = column.Type();
 			auto bound_expr = binder.Bind(expr);
-			PlanSubqueries(&bound_expr, &root);
+			PlanSubqueries(bound_expr, root);
 
 			op.expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
@@ -225,7 +225,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		WhereBinder binder(*this, context);
 		auto condition = binder.Bind(stmt.set_info->condition);
 
-		PlanSubqueries(&condition, &root);
+		PlanSubqueries(condition, root);
 		auto filter = make_uniq<LogicalFilter>(std::move(condition));
 		filter->AddChild(std::move(root));
 		root = std::move(filter);

package/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp

@@ -10,7 +10,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundExpressionListRef &ref) {
 	// values list, first plan any subqueries in the list
 	for (auto &expr_list : ref.values) {
 		for (auto &expr : expr_list) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 	}
 	// now create a LogicalExpressionGet from the set of expressions

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -268,7 +268,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		auto filter = make_uniq<LogicalFilter>(std::move(ref.condition));
 		// visit the expressions in the filter
 		for (auto &expression : filter->expressions) {
-			PlanSubqueries(&expression, &root);
+			PlanSubqueries(expression, root);
 		}
 		filter->AddChild(std::move(root));
 		return std::move(filter);
@@ -288,7 +288,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
 			auto &filter = child->Cast<LogicalFilter>();
 			for (auto &expr : filter.expressions) {
-				PlanSubqueries(&expr, &filter.children[0]);
+				PlanSubqueries(expr, filter.children[0]);
 			}
 		}
 	}
@@ -302,8 +302,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// and the expressions on the RHS with the RHS as root node
 		auto &comp_join = join->Cast<LogicalComparisonJoin>();
 		for (idx_t i = 0; i < comp_join.conditions.size(); i++) {
-			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
-			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
+			PlanSubqueries(comp_join.conditions[i].left, comp_join.children[0]);
+			PlanSubqueries(comp_join.conditions[i].right, comp_join.children[1]);
 		}
 		break;
 	}

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

@@ -51,7 +51,8 @@ bool Expression::HasSideEffects() const {
 bool Expression::PropagatesNullValues() const {
 	if (type == ExpressionType::OPERATOR_IS_NULL || type == ExpressionType::OPERATOR_IS_NOT_NULL ||
 	    type == ExpressionType::COMPARE_NOT_DISTINCT_FROM || type == ExpressionType::COMPARE_DISTINCT_FROM ||
-	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND) {
+	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND ||
+	    type == ExpressionType::OPERATOR_COALESCE) {
 		return false;
 	}
 	bool propagate_null_values = true;

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

@@ -7,8 +7,8 @@ namespace duckdb {
 AggregateBinder::AggregateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context, true) {
 }
 
-BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
 		throw ParserException("aggregate function calls cannot contain window function calls");

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

@@ -12,8 +12,8 @@ AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEnt
 	this->target_type = std::move(target_type);
 }
 
-BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in alter statement");

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

@@ -23,8 +23,8 @@ BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, Bound
     : BaseSelectBinder(binder, context, node, info, case_insensitive_map_t<idx_t>()) {
 }
 
-BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {
@@ -69,7 +69,7 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	return DConstants::INVALID_INDEX;
 }
 
-BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
+BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth) {
 	// first try to bind the column reference regularly
 	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
@@ -77,7 +77,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_pt
 	}
 	// binding failed
 	// check in the alias map
-	auto &colref = (*expr_ptr)->Cast<ColumnRefExpression>();
+	auto &colref = (expr_ptr.get())->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/check_binder.cpp

@@ -12,8 +12,8 @@ CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p,
 	target_type = LogicalType::INTEGER;
 }
 
-BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in check constraints");
@@ -39,7 +39,7 @@ BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref
 	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
 		result = CreateStructExtract(std::move(result), colref.column_names[i]);
 	}
-	return BindExpression(&result, 0);
+	return BindExpression(result, 0);
 }
 
 BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
@@ -66,7 +66,7 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 	auto &col = columns.GetColumn(colref.column_names[0]);
 	if (col.Generated()) {
 		auto bound_expression = col.GeneratedExpression().Copy();
-		return BindExpression(&bound_expression, 0, false);
+		return BindExpression(bound_expression, 0, false);
 	}
 	bound_columns.insert(col.Physical());
 	D_ASSERT(col.StorageOid() != DConstants::INVALID_INDEX);

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

@@ -33,7 +33,7 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 
 	// since the alias has been found, pass a depth of 0. See Issue 4978 (#16)
 	// ColumnAliasBinders are only in Having, Qualify and Where Binders
-	auto result = enclosing_binder.BindExpression(&expression, 0, root_expression);
+	auto result = enclosing_binder.BindExpression(expression, 0, root_expression);
 	visited_select_indexes.erase(alias_entry->second);
 	return result;
 }

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

@@ -7,15 +7,15 @@ ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string cl
     : ExpressionBinder(binder, context), clause(std::move(clause)) {
 }
 
-BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
 		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (!colref.IsQualified()) {
 			auto value_function = GetSQLValueFunction(colref.GetColumnName());
 			if (value_function) {
-				*expr_ptr = std::move(value_function);
+				expr_ptr = std::move(value_function);
 				return BindExpression(expr_ptr, depth, root_expression);
 			}
 		}

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

@@ -14,8 +14,8 @@ GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &nod
       group_index(group_index) {
 }
 
-BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	if (root_expression && depth == 0) {
 		switch (expr.expression_class) {
 		case ExpressionClass::COLUMN_REF:

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

@@ -15,8 +15,8 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
+BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
 	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
 	if (!alias_result.HasError()) {
 		if (depth > 0) {
@@ -41,8 +41,8 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
 }
 
-BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {

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

@@ -12,8 +12,8 @@ IndexBinder::IndexBinder(Binder &binder, ClientContext &context, optional_ptr<Ta
     : ExpressionBinder(binder, context), table(table), info(info) {
 }
 
-BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in index expressions");

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

@@ -7,8 +7,8 @@ namespace duckdb {
 InsertBinder::InsertBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::DEFAULT:
 		return BindResult("DEFAULT is not allowed here!");

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

@@ -23,7 +23,7 @@ void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractCorrelatedColumns(child); });
 }
 
-BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	if (depth == 0) {
 		throw InternalException("Lateral binder can only bind correlated columns");
 	}
@@ -66,8 +66,8 @@ vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &bin
 	return all_correlated_columns;
 }
 
-BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::DEFAULT:
 		return BindResult("LATERAL join cannot contain DEFAULT clause");

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

@@ -15,8 +15,8 @@ QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelect
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
+BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
 	auto result = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
 		return result;
@@ -31,8 +31,8 @@ BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr,
 	                                     expr.ToString()));
 }
 
-BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {

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

@@ -6,8 +6,8 @@ RelationBinder::RelationBinder(Binder &binder, ClientContext &context, string op
     : ExpressionBinder(binder, context), op(std::move(op)) {
 }
 
-BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::AGGREGATE:
 		return BindResult("aggregate functions are not allowed in " + op);

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

@@ -7,8 +7,8 @@ namespace duckdb {
 ReturningBinder::ReturningBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::SUBQUERY:
 		return BindResult("SUBQUERY is not supported in returning statements");

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

@@ -22,16 +22,16 @@ BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr, i
 	}
 	auto value_function = ExpressionBinder::GetSQLValueFunction(expr.GetColumnName());
 	if (value_function) {
-		return BindExpression(&value_function, depth, root_expression);
+		return BindExpression(value_function, depth, root_expression);
 	}
 
 	auto result_name = StringUtil::Join(expr.column_names, ".");
 	return BindResult(make_uniq<BoundConstantExpression>(Value(result_name)));
 }
 
-BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
                                                bool root_expression) {
-	auto &expr = **expr_ptr;
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF:
 		return BindColumnReference(expr.Cast<ColumnRefExpression>(), depth, root_expression);

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

@@ -5,8 +5,8 @@ namespace duckdb {
 UpdateBinder::UpdateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult UpdateBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult UpdateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in UPDATE");

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

@@ -9,8 +9,8 @@ WhereBinder::WhereBinder(Binder &binder, ClientContext &context, optional_ptr<Co
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (*expr_ptr)->Cast<ColumnRefExpression>();
+BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
 	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError() || !column_alias_binder) {
 		return result;
@@ -25,8 +25,8 @@ BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, id
 	return result;
 }
 
-BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::DEFAULT:
 		return BindResult("WHERE clause cannot contain DEFAULT clause");

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

@@ -28,8 +28,8 @@ ExpressionBinder::~ExpressionBinder() {
 	}
 }
 
-BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression) {
-	auto &expr_ref = **expr;
+BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
+	auto &expr_ref = *expr;
 	switch (expr_ref.expression_class) {
 	case ExpressionClass::BETWEEN:
 		return BindExpression(expr_ref.Cast<BetweenExpression>(), depth);
@@ -84,7 +84,7 @@ bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr)
 	while (!active_binders.empty()) {
 		auto &next_binder = active_binders.back().get();
 		ExpressionBinder::QualifyColumnNames(next_binder.binder, expr);
-		auto bind_result = next_binder.Bind(&expr, depth);
+		auto bind_result = next_binder.Bind(expr, depth);
 		if (bind_result.empty()) {
 			success = true;
 			break;
@@ -98,7 +98,7 @@ bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr)
 
 void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, string &error) {
 	if (expr) {
-		string bind_error = Bind(&expr, depth);
+		string bind_error = Bind(expr, depth);
 		if (error.empty()) {
 			error = bind_error;
 		}
@@ -184,10 +184,10 @@ LogicalType ExpressionBinder::ExchangeNullType(const LogicalType &type) {
 	return ExchangeType(type, LogicalTypeId::SQLNULL, LogicalType::INTEGER);
 }
 
-unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type,
+unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, optional_ptr<LogicalType> result_type,
                                               bool root_expression) {
 	// bind the main expression
-	auto error_msg = Bind(&expr, 0, root_expression);
+	auto error_msg = Bind(expr, 0, root_expression);
 	if (!error_msg.empty()) {
 		// failed to bind: try to bind correlated columns in the expression (if any)
 		bool success = BindCorrelatedColumns(expr);
@@ -207,8 +207,8 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 			// SQL NULL type is only used internally in the binder
 			// cast to INTEGER if we encounter it outside of the binder
 			if (ContainsNullType(result->return_type)) {
-				auto result_type = ExchangeNullType(result->return_type);
-				result = BoundCastExpression::AddCastToType(context, std::move(result), result_type);
+				auto exchanged_type = ExchangeNullType(result->return_type);
+				result = BoundCastExpression::AddCastToType(context, std::move(result), exchanged_type);
 			}
 		}
 		if (result->return_type.id() == LogicalTypeId::UNKNOWN) {
@@ -221,9 +221,9 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 	return result;
 }
 
-string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression) {
+string ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
 	// bind the node, but only if it has not been bound yet
-	auto &expression = **expr;
+	auto &expression = *expr;
 	auto alias = expression.alias;
 	if (expression.GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION) {
 		// already bound, don't bind it again
@@ -235,8 +235,8 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 		return result.error;
 	}
 	// successfully bound: replace the node with a BoundExpression
-	*expr = make_uniq<BoundExpression>(std::move(result.expression));
-	auto &be = (*expr)->Cast<BoundExpression>();
+	expr = make_uniq<BoundExpression>(std::move(result.expression));
+	auto &be = expr->Cast<BoundExpression>();
 	be.alias = alias;
 	if (!alias.empty()) {
 		be.expr->alias = alias;

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

@@ -33,7 +33,6 @@ void BlockManager::ClearMetaBlockHandles() {
 }
 
 shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block) {
-
 	// pin the old block to ensure we have it loaded in memory
 	auto old_handle = buffer_manager.Pin(old_block);
 	D_ASSERT(old_block->state == BlockState::BLOCK_LOADED);
@@ -50,7 +49,7 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 
 	// move the data from the old block into data for the new block
 	new_block->state = BlockState::BLOCK_LOADED;
-	new_block->buffer = CreateBlock(block_id, old_block->buffer.get());
+	new_block->buffer = ConvertBlock(block_id, *old_block->buffer);
 	new_block->memory_usage = old_block->memory_usage;
 	new_block->memory_charge = std::move(old_block->memory_charge);
 

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -33,7 +33,7 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 	size_t compressed_size = 0;
 	compressed_size = s.MaxCompressedLength(uncompressed_size);
 	auto compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-	s.Compress((const char *)string.GetDataUnsafe(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
+	s.Compress((const char *)string.GetData(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
 	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
 
 	// store sizes
@@ -43,7 +43,7 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 
 	// now write the remainder of the string
 	offset += 2 * sizeof(uint32_t);
-	auto strptr = compressed_string.GetDataUnsafe();
+	auto strptr = compressed_string.GetData();
 	uint32_t remaining = compressed_size;
 	while (remaining > 0) {
 		uint32_t to_write = MinValue<uint32_t>(remaining, STRING_SPACE - offset);