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

package/src/duckdb/src/include/duckdb/storage/block_manager.hpp

@@ -33,6 +33,7 @@ public:
 
 public:
 	//! Creates a new block inside the block manager
+	virtual unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) = 0;
 	virtual unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) = 0;
 	//! Return the next free block id
 	virtual block_id_t GetFreeBlockId() = 0;

package/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp

@@ -20,6 +20,9 @@ public:
 	using BlockManager::BlockManager;
 
 	// LCOV_EXCL_START
+	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override {
 		throw InternalException("Cannot perform IO in in-memory database!");
 	}

package/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp

@@ -44,7 +44,8 @@ struct PartialBlock {
 	PartialBlockState state;
 
 public:
-	virtual void Flush() = 0;
+	virtual void AddUninitializedRegion(idx_t start, idx_t end) = 0;
+	virtual void Flush(idx_t free_space_left) = 0;
 	virtual void Clear() {
 	}
 };

package/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp

@@ -15,24 +15,32 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/set.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
 class DatabaseInstance;
 
+struct StorageManagerOptions {
+	bool read_only = false;
+	bool use_direct_io = false;
+	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
+};
+
 //! SingleFileBlockManager is an implementation for a BlockManager which manages blocks in a single file
 class SingleFileBlockManager : public BlockManager {
 	//! The location in the file where the block writing starts
 	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
 
 public:
-	SingleFileBlockManager(AttachedDatabase &db, string path, bool read_only, bool use_direct_io);
+	SingleFileBlockManager(AttachedDatabase &db, string path, StorageManagerOptions options);
 
 	void GetFileFlags(uint8_t &flags, FileLockType &lock, bool create_new);
 	void CreateNewDatabase();
 	void LoadExistingDatabase();
 
 	//! Creates a new Block using the specified block_id and returns a pointer
+	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override;
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override;
 	//! Return the next free block id
 	block_id_t GetFreeBlockId() override;
@@ -96,10 +104,8 @@ private:
 	block_id_t free_list_id;
 	//! The current header iteration count
 	uint64_t iteration_count;
-	//! Whether or not the db is opened in read-only mode
-	bool read_only;
-	//! Whether or not to use Direct IO to read the blocks
-	bool use_direct_io;
+	//! The storage manager options
+	StorageManagerOptions options;
 	//! Lock for performing various operations in the single file block manager
 	mutex block_lock;
 };

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -155,7 +155,7 @@ public:
 				remaining_space -= required_space;
 				auto dict_pos = end - *dictionary_size;
 				// now write the actual string data into the dictionary
-				memcpy(dict_pos, source_data[source_idx].GetDataUnsafe(), string_length);
+				memcpy(dict_pos, source_data[source_idx].GetData(), string_length);
 
 				// place the dictionary offset into the set of vectors
 				result_data[target_idx] = *dictionary_size;

package/src/duckdb/src/main/capi/cast/from_decimal-c.cpp

@@ -35,7 +35,7 @@ bool CastDecimalCInternal(duckdb_result *source, duckdb_string &result, idx_t co
 		throw duckdb::InternalException("Unimplemented internal type for decimal");
 	}
 	result.data = (char *)duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1));
-	memcpy(result.data, result_string.GetDataUnsafe(), result_string.GetSize());
+	memcpy(result.data, result_string.GetData(), result_string.GetSize());
 	result.data[result_string.GetSize()] = '\0';
 	result.size = result_string.GetSize();
 	return true;

package/src/duckdb/src/main/capi/result-c.cpp

@@ -21,7 +21,7 @@ struct CStringConverter {
 	static DST Convert(SRC input) {
 		auto result = (char *)duckdb_malloc(input.GetSize() + 1);
 		assert(result);
-		memcpy((void *)result, input.GetDataUnsafe(), input.GetSize());
+		memcpy((void *)result, input.GetData(), input.GetSize());
 		auto write_arr = (char *)result;
 		write_arr[input.GetSize()] = '\0';
 		return result;
@@ -40,7 +40,7 @@ struct CBlobConverter {
 		result.data = (char *)duckdb_malloc(input.GetSize());
 		result.size = input.GetSize();
 		assert(result.data);
-		memcpy((void *)result.data, input.GetDataUnsafe(), input.GetSize());
+		memcpy((void *)result.data, input.GetData(), input.GetSize());
 		return result;
 	}
 

package/src/duckdb/src/main/config.cpp

@@ -54,6 +54,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(DebugCheckpointAbort),
                                                  DUCKDB_LOCAL(DebugForceExternal),
                                                  DUCKDB_LOCAL(DebugForceNoCrossProduct),
+                                                 DUCKDB_LOCAL(DebugAsOfIEJoin),
                                                  DUCKDB_GLOBAL(DebugWindowMode),
                                                  DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
                                                  DUCKDB_GLOBAL(DefaultOrderSetting),
@@ -359,4 +360,29 @@ bool DBConfig::operator!=(const DBConfig &other) {
 	return !(other.options == options);
 }
 
+OrderType DBConfig::ResolveOrder(OrderType order_type) const {
+	if (order_type != OrderType::ORDER_DEFAULT) {
+		return order_type;
+	}
+	return options.default_order_type;
+}
+
+OrderByNullType DBConfig::ResolveNullOrder(OrderType order_type, OrderByNullType null_type) const {
+	if (null_type != OrderByNullType::ORDER_DEFAULT) {
+		return null_type;
+	}
+	switch (options.default_null_order) {
+	case DefaultOrderByNullType::NULLS_FIRST:
+		return OrderByNullType::NULLS_FIRST;
+	case DefaultOrderByNullType::NULLS_LAST:
+		return OrderByNullType::NULLS_LAST;
+	case DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC:
+		return order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_FIRST : OrderByNullType::NULLS_LAST;
+	case DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC:
+		return order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_LAST : OrderByNullType::NULLS_FIRST;
+	default:
+		throw InternalException("Unknown null order setting");
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/main/settings/settings.cpp

@@ -142,7 +142,7 @@ Value DebugForceNoCrossProduct::GetSetting(ClientContext &context) {
 }
 
 //===--------------------------------------------------------------------===//
-// Debug Ordered Aggregate Threshold
+// Ordered Aggregate Threshold
 //===--------------------------------------------------------------------===//
 
 void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
@@ -185,6 +185,21 @@ Value DebugWindowMode::GetSetting(ClientContext &context) {
 	return Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Debug AsOf Join
+//===--------------------------------------------------------------------===//
+void DebugAsOfIEJoin::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_asof_iejoin;
+}
+
+void DebugAsOfIEJoin::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).force_asof_iejoin = input.GetValue<bool>();
+}
+
+Value DebugAsOfIEJoin::GetSetting(ClientContext &context) {
+	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_asof_iejoin);
+}
+
 //===--------------------------------------------------------------------===//
 // Default Collation
 //===--------------------------------------------------------------------===//
@@ -253,14 +268,18 @@ void DefaultNullOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
 	auto parameter = StringUtil::Lower(input.ToString());
 
 	if (parameter == "nulls_first" || parameter == "nulls first" || parameter == "null first" || parameter == "first") {
-		config.options.default_null_order = OrderByNullType::NULLS_FIRST;
+		config.options.default_null_order = DefaultOrderByNullType::NULLS_FIRST;
 	} else if (parameter == "nulls_last" || parameter == "nulls last" || parameter == "null last" ||
 	           parameter == "last") {
-		config.options.default_null_order = OrderByNullType::NULLS_LAST;
+		config.options.default_null_order = DefaultOrderByNullType::NULLS_LAST;
+	} else if (parameter == "nulls_first_on_asc_last_on_desc" || parameter == "sqlite" || parameter == "mysql") {
+		config.options.default_null_order = DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC;
+	} else if (parameter == "nulls_last_on_asc_first_on_desc" || parameter == "postgres") {
+		config.options.default_null_order = DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC;
 	} else {
-		throw ParserException(
-		    "Unrecognized parameter for option NULL_ORDER \"%s\", expected either NULLS FIRST or NULLS LAST",
-		    parameter);
+		throw ParserException("Unrecognized parameter for option NULL_ORDER \"%s\", expected either NULLS FIRST, NULLS "
+		                      "LAST, SQLite, MySQL or Postgres",
+		                      parameter);
 	}
 }
 
@@ -271,10 +290,14 @@ void DefaultNullOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config
 Value DefaultNullOrderSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	switch (config.options.default_null_order) {
-	case OrderByNullType::NULLS_FIRST:
+	case DefaultOrderByNullType::NULLS_FIRST:
 		return "nulls_first";
-	case OrderByNullType::NULLS_LAST:
+	case DefaultOrderByNullType::NULLS_LAST:
 		return "nulls_last";
+	case DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC:
+		return "nulls_first_on_asc_last_on_desc";
+	case DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC:
+		return "nulls_last_on_asc_first_on_desc";
 	default:
 		throw InternalException("Unknown null order setting");
 	}

package/src/duckdb/src/optimizer/cse_optimizer.cpp

@@ -73,8 +73,8 @@ void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplace
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { CountExpressions(child, state); });
 }
 
-void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> *expr_ptr, CSEReplacementState &state) {
-	Expression &expr = **expr_ptr;
+void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> &expr_ptr, CSEReplacementState &state) {
+	Expression &expr = *expr_ptr;
 	if (expr.expression_class == ExpressionClass::BOUND_COLUMN_REF) {
 		auto &bound_column_ref = expr.Cast<BoundColumnRefExpression>();
 		// bound column ref, check if this one has already been recorded in the expression list
@@ -105,20 +105,20 @@ void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression>
 			if (node.column_index == DConstants::INVALID_INDEX) {
 				// has not been pushed yet: push it
 				node.column_index = state.expressions.size();
-				state.expressions.push_back(std::move(*expr_ptr));
+				state.expressions.push_back(std::move(expr_ptr));
 			} else {
-				state.cached_expressions.push_back(std::move(*expr_ptr));
+				state.cached_expressions.push_back(std::move(expr_ptr));
 			}
 			// replace the original expression with a bound column ref
-			*expr_ptr = make_uniq<BoundColumnRefExpression>(alias, type,
-			                                                ColumnBinding(state.projection_index, node.column_index));
+			expr_ptr = make_uniq<BoundColumnRefExpression>(alias, type,
+			                                               ColumnBinding(state.projection_index, node.column_index));
 			return;
 		}
 	}
 	// this expression only occurs once, we can't perform CSE elimination
 	// look into the children to see if we can replace them
 	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(&child, state); });
+	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(child, state); });
 }
 
 void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &op) {
@@ -143,8 +143,9 @@ void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &o
 	state.projection_index = binder.GenerateTableIndex();
 	// we found common subexpressions to extract
 	// now we iterate over all the expressions and perform the actual CSE elimination
+
 	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(child, state); });
+	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(*child, state); });
 	D_ASSERT(state.expressions.size() > 0);
 	// create a projection node as the child of this node
 	auto projection = make_uniq<LogicalProjection>(state.projection_index, std::move(state.expressions));

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -77,7 +77,7 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
 void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
 	serializer.WriteProperty("subquery_type", subquery_type);
-	serializer.WriteProperty("subquery", *subquery.get());
+	serializer.WriteProperty("subquery", *subquery);
 	serializer.WriteOptionalProperty("child", child);
 	serializer.WriteProperty("comparison_type", comparison_type);
 }

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -176,6 +176,8 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	}
 	pivot_ref->pivots = std::move(columns);
 	select_node->from_table = std::move(pivot_ref);
+	// transform order by/limit modifiers
+	TransformModifiers(*stmt, *select_node);
 	return std::move(select_node);
 }
 

package/src/duckdb/src/parser/transform/statement/transform_select_node.cpp

@@ -8,6 +8,38 @@
 
 namespace duckdb {
 
+void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node) {
+	// transform the common properties
+	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
+	vector<OrderByNode> orders;
+	TransformOrderBy(stmt.sortClause, orders);
+	if (!orders.empty()) {
+		auto order_modifier = make_uniq<OrderModifier>();
+		order_modifier->orders = std::move(orders);
+		node.modifiers.push_back(std::move(order_modifier));
+	}
+	if (stmt.limitCount || stmt.limitOffset) {
+		if (stmt.limitCount && stmt.limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
+			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
+			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt.limitCount)->limit_percent;
+			limit_percent_modifier->limit = TransformExpression(expr_node);
+			if (stmt.limitOffset) {
+				limit_percent_modifier->offset = TransformExpression(stmt.limitOffset);
+			}
+			node.modifiers.push_back(std::move(limit_percent_modifier));
+		} else {
+			auto limit_modifier = make_uniq<LimitModifier>();
+			if (stmt.limitCount) {
+				limit_modifier->limit = TransformExpression(stmt.limitCount);
+			}
+			if (stmt.limitOffset) {
+				limit_modifier->offset = TransformExpression(stmt.limitOffset);
+			}
+			node.modifiers.push_back(std::move(limit_modifier));
+		}
+	}
+}
+
 unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *stmt) {
 	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
 	auto stack_checker = StackCheck();
@@ -119,35 +151,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	default:
 		throw NotImplementedException("Statement type %d not implemented!", stmt->op);
 	}
-	// transform the common properties
-	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
-	vector<OrderByNode> orders;
-	TransformOrderBy(stmt->sortClause, orders);
-	if (!orders.empty()) {
-		auto order_modifier = make_uniq<OrderModifier>();
-		order_modifier->orders = std::move(orders);
-		node->modifiers.push_back(std::move(order_modifier));
-	}
-	if (stmt->limitCount || stmt->limitOffset) {
-		if (stmt->limitCount && stmt->limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
-			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
-			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt->limitCount)->limit_percent;
-			limit_percent_modifier->limit = TransformExpression(expr_node);
-			if (stmt->limitOffset) {
-				limit_percent_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(std::move(limit_percent_modifier));
-		} else {
-			auto limit_modifier = make_uniq<LimitModifier>();
-			if (stmt->limitCount) {
-				limit_modifier->limit = TransformExpression(stmt->limitCount);
-			}
-			if (stmt->limitOffset) {
-				limit_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(std::move(limit_modifier));
-		}
-	}
+	TransformModifiers(*stmt, *node);
 	return node;
 }
 

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

@@ -60,7 +60,7 @@ 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 = fractions->Cast<BoundExpression>();
 
 	if (!bound.expr->IsFoldable()) {
 		return;
@@ -81,7 +81,8 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 	}
 }
 
-BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_ptr<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,7 +138,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.children[i];
+				auto &bound_expr = aggr.children[i]->Cast<BoundExpression>();
 				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 			}
 			if (aggr.filter) {
@@ -146,7 +147,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.filter;
+				auto &bound_expr = aggr.filter->Cast<BoundExpression>();
 				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
@@ -155,7 +156,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 					if (!success) {
 						throw BinderException(error);
 					}
-					auto &bound_expr = (BoundExpression &)*order.expression;
+					auto &bound_expr = order.expression->Cast<BoundExpression>();
 					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 				}
 			}
@@ -214,11 +215,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 		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;
+			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.expr));
 		}
 	}

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

@@ -8,7 +8,7 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
+	string error = Bind(expr.child, depth);
 	if (!error.empty()) {
 		return BindResult(error);
 	}

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

@@ -6,11 +6,11 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
+	string error = Bind(expr.child, depth);
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto &child = (BoundExpression &)*expr.child;
+	auto &child = expr.child->Cast<BoundExpression>();
 	if (child.expr->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}

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

@@ -340,7 +340,7 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 	// a generated column returns a generated expression, a struct on a column returns a struct extract
 	if (expr->type != ExpressionType::COLUMN_REF) {
 		auto alias = expr->alias;
-		auto result = BindExpression(&expr, depth);
+		auto result = BindExpression(expr, depth);
 		if (result.expression) {
 			result.expression->alias = std::move(alias);
 		}

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

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
-                                            unique_ptr<ParsedExpression> *expr_ptr) {
+                                            unique_ptr<ParsedExpression> &expr_ptr) {
 	// lookup the function in the catalog
 	QueryErrorContext error_context(binder.root_statement, function.query_location);
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
@@ -87,7 +87,8 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 	}
 }
 
-BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFunctionCatalogEntry *func, idx_t depth) {
+BindResult ExpressionBinder::BindFunction(FunctionExpression &function, optional_ptr<ScalarFunctionCatalogEntry> func,
+                                          idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -122,8 +123,8 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFu
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, ScalarFunctionCatalogEntry *func,
-                                                idx_t depth) {
+BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
+                                                optional_ptr<ScalarFunctionCatalogEntry> func, idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -140,7 +141,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// get the logical type of the children of the list
-	auto &list_child = (BoundExpression &)*function.children[0];
+	auto &list_child = function.children[0]->Cast<BoundExpression>();
 
 	if (list_child.expr->return_type.id() != LogicalTypeId::LIST &&
 	    list_child.expr->return_type.id() != LogicalTypeId::SQLNULL &&
@@ -233,8 +234,8 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function,
-                                           idx_t depth) {
+BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr,
+                                           optional_ptr<AggregateFunctionCatalogEntry> function, idx_t depth) {
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 

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

@@ -78,13 +78,13 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 
 	// bind the parameter expressions
 	for (idx_t i = 0; i < expr.params.size(); i++) {
-		auto result = BindExpression(&expr.params[i], depth, false);
+		auto result = BindExpression(expr.params[i], depth, false);
 		if (result.HasError()) {
 			throw InternalException("Error during lambda binding: %s", result.error);
 		}
 	}
 
-	auto result = BindExpression(&expr.expr, depth, false);
+	auto result = BindExpression(expr.expr, depth, false);
 	lambda_bindings->pop_back();
 
 	// successfully bound a subtree of nested lambdas, set this to nullptr in case other parts of the

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

@@ -44,10 +44,10 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 }
 
-BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry *macro_func, idx_t depth,
-                                       unique_ptr<ParsedExpression> *expr) {
+BindResult ExpressionBinder::BindMacro(FunctionExpression &function, optional_ptr<ScalarMacroCatalogEntry> macro_func,
+                                       idx_t depth, unique_ptr<ParsedExpression> &expr) {
 	// recast function so we can access the scalar member function->expression
-	auto &macro_def = (ScalarMacroFunction &)*macro_func->function;
+	auto &macro_def = macro_func->function->Cast<ScalarMacroFunction>();
 
 	// validate the arguments and separate positional and default arguments
 	vector<unique_ptr<ParsedExpression>> positionals;
@@ -56,7 +56,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	string error =
 	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
 	if (!error.empty()) {
-		throw BinderException(binder.FormatError(*expr->get(), error));
+		throw BinderException(binder.FormatError(*expr, error));
 	}
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
@@ -80,8 +80,8 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	macro_binding = new_macro_binding.get();
 
 	// replace current expression with stored macro expression, and replace params
-	*expr = macro_def.expression->Copy();
-	ReplaceMacroParametersRecursive(*expr);
+	expr = macro_def.expression->Copy();
+	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro
 	return BindExpression(expr, depth);

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

@@ -127,8 +127,8 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		break;
 	}
 	if (!function_name.empty()) {
-		auto function = make_uniq<FunctionExpression>(function_name, std::move(op.children));
-		return BindExpression(*function, depth, nullptr);
+		auto function = make_uniq_base<ParsedExpression, FunctionExpression>(function_name, std::move(op.children));
+		return BindExpression(function, depth, false);
 	}
 
 	vector<BoundExpression *> children;

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

@@ -67,7 +67,7 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	// now bind the child node of the subquery
 	if (expr.child) {
 		// first bind the children of the subquery, if any
-		string error = Bind(&expr.child, depth);
+		string error = Bind(expr.child, depth);
 		if (!error.empty()) {
 			return BindResult(error);
 		}

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

@@ -64,14 +64,6 @@ static LogicalType ResolveWindowExpressionType(ExpressionType window_type, const
 	}
 }
 
-static inline OrderType ResolveOrderType(const DBConfig &config, OrderType type) {
-	return (type == OrderType::ORDER_DEFAULT) ? config.options.default_order_type : type;
-}
-
-static inline OrderByNullType ResolveNullOrder(const DBConfig &config, OrderByNullType null_order) {
-	return (null_order == OrderByNullType::ORDER_DEFAULT) ? config.options.default_null_order : null_order;
-}
-
 static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr) {
 	if (!expr) {
 		return nullptr;
@@ -231,12 +223,12 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	LogicalType start_type = LogicalType::BIGINT;
 	if (window.start == WindowBoundary::EXPR_PRECEDING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
+		range_sense = config.ResolveOrder(window.orders[0].type);
 		const auto name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
 		start_type = BindRangeExpression(context, name, window.start_expr, window.orders[0].expression);
 	} else if (window.start == WindowBoundary::EXPR_FOLLOWING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
+		range_sense = config.ResolveOrder(window.orders[0].type);
 		const auto name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
 		start_type = BindRangeExpression(context, name, window.start_expr, window.orders[0].expression);
 	}
@@ -244,12 +236,12 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	LogicalType end_type = LogicalType::BIGINT;
 	if (window.end == WindowBoundary::EXPR_PRECEDING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
+		range_sense = config.ResolveOrder(window.orders[0].type);
 		const auto name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
 		end_type = BindRangeExpression(context, name, window.end_expr, window.orders[0].expression);
 	} else if (window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
+		range_sense = config.ResolveOrder(window.orders[0].type);
 		const auto name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
 		end_type = BindRangeExpression(context, name, window.end_expr, window.orders[0].expression);
 	}
@@ -276,8 +268,8 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	}
 
 	for (auto &order : window.orders) {
-		auto type = ResolveOrderType(config, order.type);
-		auto null_order = ResolveNullOrder(config, order.null_order);
+		auto type = config.ResolveOrder(order.type);
+		auto null_order = config.ResolveNullOrder(type, order.null_order);
 		auto expression = GetExpression(order.expression);
 		result->orders.emplace_back(type, null_order, std::move(expression));
 	}