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

package/src/duckdb/src/include/duckdb/common/types/string_type.hpp

@@ -68,10 +68,12 @@ public:
 		return GetSize() <= INLINE_LENGTH;
 	}
 
-	//! this is unsafe since the string will not be terminated at the end
-	const char *GetDataUnsafe() const {
+	const char *GetData() const {
 		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
 	}
+	const char *GetDataUnsafe() const {
+		return GetData();
+	}
 
 	char *GetDataWriteable() const {
 		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
@@ -86,7 +88,7 @@ public:
 	}
 
 	string GetString() const {
-		return string(GetDataUnsafe(), GetSize());
+		return string(GetData(), GetSize());
 	}
 
 	explicit operator string() const {
@@ -108,7 +110,7 @@ public:
 		} else {
 			// copy the data into the prefix
 #ifndef DUCKDB_DEBUG_NO_INLINE
-			auto dataptr = (char *)GetDataUnsafe();
+			auto dataptr = (char *)GetData();
 			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
 #else
 			memset(value.pointer.prefix, 0, PREFIX_BYTES);
@@ -124,7 +126,7 @@ public:
 #ifdef DUCKDB_DEBUG_NO_INLINE
 			if (a.GetSize() != b.GetSize())
 				return false;
-			return (memcmp(a.GetDataUnsafe(), b.GetDataUnsafe(), a.GetSize()) == 0);
+			return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
 #endif
 			uint64_t A = Load<uint64_t>((const_data_ptr_t)&a);
 			uint64_t B = Load<uint64_t>((const_data_ptr_t)&b);
@@ -177,7 +179,7 @@ public:
 			if (A != B)
 				return bswap(A) > bswap(B);
 #endif
-			auto memcmp_res = memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), min_length);
+			auto memcmp_res = memcmp(left.GetData(), right.GetData(), min_length);
 			return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);
 		}
 	};

package/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp

@@ -143,7 +143,7 @@ public:
 		return heap.AddString(data);
 	}
 	string_t AddBlob(string_t data) {
-		return heap.AddBlob(data.GetDataUnsafe(), data.GetSize());
+		return heap.AddBlob(data.GetData(), data.GetSize());
 	}
 	string_t EmptyString(idx_t len) {
 		return heap.EmptyString(len);

package/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp

@@ -29,7 +29,7 @@ struct OuterJoinLocalScanState {
 
 class OuterJoinMarker {
 public:
-	OuterJoinMarker(bool enabled);
+	explicit OuterJoinMarker(bool enabled);
 
 	bool Enabled() {
 		return enabled;
@@ -60,6 +60,11 @@ public:
 	//! Perform the scan
 	void Scan(OuterJoinGlobalScanState &gstate, OuterJoinLocalScanState &lstate, DataChunk &result);
 
+	//! Read-only matches vector
+	const bool *GetMatches() const {
+		return found_match.get();
+	}
+
 private:
 	bool enabled;
 	unique_ptr<bool[]> found_match;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp

@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/join/physical_asof_join.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
+
+namespace duckdb {
+
+//! PhysicalAsOfJoin represents a piecewise merge loop join between
+//! two tables
+class PhysicalAsOfJoin : public PhysicalComparisonJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ASOF_JOIN;
+
+public:
+	PhysicalAsOfJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right);
+
+	vector<LogicalType> join_key_types;
+	vector<column_t> null_sensitive;
+
+	// Equalities
+	vector<unique_ptr<Expression>> lhs_partitions;
+	vector<unique_ptr<Expression>> rhs_partitions;
+
+	// Inequality Only
+	vector<BoundOrderByNode> lhs_orders;
+	vector<BoundOrderByNode> rhs_orders;
+
+	// Projection mappings
+	vector<column_t> right_projection_map;
+
+public:
+	// Operator Interface
+	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
+	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
+
+	bool ParallelOperator() const override {
+		return true;
+	}
+
+protected:
+	// CachingOperator Interface
+	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
+
+public:
+	// Source interface
+	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
+	                                                 GlobalSourceState &gstate) const override;
+	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
+	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	             LocalSourceState &lstate) const override;
+
+	bool IsSource() const override {
+		return IsRightOuterJoin(join_type);
+	}
+	bool ParallelSource() const override {
+		return true;
+	}
+
+public:
+	// Sink Interface
+	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
+	                    DataChunk &input) const override;
+	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+	                          GlobalSinkState &gstate) const override;
+
+	bool IsSink() const override {
+		return true;
+	}
+	bool ParallelSink() const override {
+		return true;
+	}
+
+private:
+	// resolve joins that output max N elements (SEMI, ANTI, MARK)
+	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
+	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
+	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                                      OperatorState &state) const;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp

@@ -199,7 +199,7 @@ public:
 	~CachingOperatorState() override {
 	}
 
-	virtual void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
 	}
 
 	unique_ptr<DataChunk> cached_chunk;

package/src/duckdb/src/include/duckdb/function/macro_function.hpp

@@ -44,6 +44,23 @@ public:
 	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 
 	virtual string ToSQL(const string &schema, const string &name) const;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp

@@ -22,7 +22,7 @@ void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result,
 void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
 
 inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
-	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
+	return duckdb_re2::StringPiece(input.GetData(), input.GetSize());
 }
 
 inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -58,7 +58,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR Length(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		TR length = 0;
 		for (idx_t i = 0; i < input_length; i++) {
@@ -69,7 +69,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR GraphemeCount(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		for (idx_t i = 0; i < input_length; i++) {
 			if (input_data[i] & 0x80) {

package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp

@@ -19,6 +19,9 @@
 namespace duckdb {
 
 class ScalarMacroFunction : public MacroFunction {
+public:
+	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
+
 public:
 	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 

package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp

@@ -19,6 +19,9 @@
 namespace duckdb {
 
 class TableMacroFunction : public MacroFunction {
+public:
+	static constexpr const MacroType TYPE = MacroType::TABLE_MACRO;
+
 public:
 	explicit TableMacroFunction(unique_ptr<QueryNode> query_node);
 	TableMacroFunction(void);

package/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp

@@ -80,7 +80,7 @@ struct ToCStringCastWrapper {
 		Vector result_vector(LogicalType::VARCHAR, nullptr);
 		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
 		auto result_size = result_string.GetSize();
-		auto result_data = result_string.GetDataUnsafe();
+		auto result_data = result_string.GetData();
 
 		char *allocated_data = (char *)duckdb_malloc(result_size + 1);
 		memcpy(allocated_data, result_data, result_size);

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -71,6 +71,8 @@ struct ClientConfig {
 	bool force_external = false;
 	//! Force disable cross product generation when hyper graph isn't connected, used for testing
 	bool force_no_cross_product = false;
+	//! Force use of IEJoin to implement AsOfJoin, used for testing
+	bool force_asof_iejoin = false;
 	//! If this context should also try to use the available replacement scans
 	//! True by default
 	bool use_replacement_scans = true;

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -106,8 +106,8 @@ struct DBConfigOptions {
 	string collation = string();
 	//! The order type used when none is specified (default: ASC)
 	OrderType default_order_type = OrderType::ASCENDING;
-	//! Null ordering used when none is specified (default: NULLS FIRST)
-	OrderByNullType default_null_order = OrderByNullType::NULLS_FIRST;
+	//! Null ordering used when none is specified (default: NULLS LAST)
+	DefaultOrderByNullType default_null_order = DefaultOrderByNullType::NULLS_LAST;
 	//! enable COPY and related commands
 	bool enable_external_access = true;
 	//! Whether or not object cache is used
@@ -145,6 +145,8 @@ struct DBConfigOptions {
 	bool enable_fsst_vectors = false;
 	//! Start transactions immediately in all attached databases - instead of lazily when a database is referenced
 	bool immediate_transaction_mode = false;
+	//! Debug setting - how to initialize  blocks in the storage layer when allocating
+	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
 	//! The set of unrecognized (other) options
 	unordered_map<string, Value> unrecognized_options;
 
@@ -226,6 +228,9 @@ public:
 	void SetDefaultMaxThreads();
 	void SetDefaultMaxMemory();
 
+	OrderType ResolveOrder(OrderType order_type) const;
+	OrderByNullType ResolveNullOrder(OrderType order_type, OrderByNullType null_type) const;
+
 private:
 	unique_ptr<CompressionFunctionSet> compression_functions;
 	unique_ptr<CastFunctionSet> cast_functions;

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -66,9 +66,19 @@ struct DebugForceNoCrossProduct {
 };
 
 struct OrderedAggregateThreshold {
-	static constexpr const char *Name = "ordered_aggregate_threshold";
-	static constexpr const char *Description = "the number of rows to accumulate before sorting, used for tuning";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
+	static constexpr const char *Name = "ordered_aggregate_threshold"; // NOLINT
+	static constexpr const char *Description =                         // NOLINT
+	    "the number of rows to accumulate before sorting, used for tuning";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; // NOLINT
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
+struct DebugAsOfIEJoin {
+	static constexpr const char *Name = "debug_asof_iejoin";                                                 // NOLINT
+	static constexpr const char *Description = "DEBUG SETTING: force use of IEJoin to implement AsOf joins"; // NOLINT
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;                                 // NOLINT
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);

package/src/duckdb/src/include/duckdb/optimizer/cse_optimizer.hpp

@@ -30,7 +30,7 @@ private:
 	//! First iteration: count how many times each expression occurs
 	void CountExpressions(Expression &expr, CSEReplacementState &state);
 	//! Second iteration: perform the actual replacement of the duplicate expressions with common subexpressions nodes
-	void PerformCSEReplacement(unique_ptr<Expression> *expr, CSEReplacementState &state);
+	void PerformCSEReplacement(unique_ptr<Expression> &expr, CSEReplacementState &state);
 
 	//! Main method to extract common subexpressions
 	void ExtractCommonSubExpresions(LogicalOperator &op);

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -87,8 +87,10 @@ public:
 		// Start with function call
 		string result = schema.empty() ? function_name : schema + "." + function_name;
 		result += "(";
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-		                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+		if (entry.children.size()) {
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+		}
 		// Lead/Lag extra arguments
 		if (entry.offset_expr.get()) {
 			result += ", ";

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -184,6 +184,7 @@ private:
 	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
 	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGSelectStmt *node);
 	unique_ptr<QueryNode> TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *node);
+	void TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node);
 
 	//===--------------------------------------------------------------------===//
 	// Expression Transform

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -321,7 +321,7 @@ private:
 
 	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
 
-	void PlanSubqueries(unique_ptr<Expression> *expr, unique_ptr<LogicalOperator> *root);
+	void PlanSubqueries(unique_ptr<Expression> &expr, unique_ptr<LogicalOperator> &root);
 	unique_ptr<Expression> PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root);
 	unique_ptr<LogicalOperator> PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
 	                                            vector<CorrelatedColumnInfo> &correlated_columns,

package/src/duckdb/src/include/duckdb/planner/expression_binder/aggregate_binder.hpp

@@ -21,7 +21,7 @@ public:
 	AggregateBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

package/src/duckdb/src/include/duckdb/planner/expression_binder/alter_binder.hpp

@@ -24,7 +24,7 @@ public:
 	vector<LogicalIndex> &bound_columns;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	BindResult BindColumn(ColumnRefExpression &expr);

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -40,10 +40,11 @@ public:
 	}
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
-	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth) override;
+	BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
+	                         idx_t depth) override;
 
 	bool inside_window;
 	bool bound_aggregate = false;
@@ -53,7 +54,7 @@ protected:
 	case_insensitive_map_t<idx_t> alias_map;
 
 protected:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth);
 	BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth) override;
 	BindResult BindWindow(WindowExpression &expr, idx_t depth);
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/check_binder.hpp

@@ -25,7 +25,7 @@ public:
 	physical_index_set_t &bound_columns;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	BindResult BindCheckColumn(ColumnRefExpression &expr);

package/src/duckdb/src/include/duckdb/planner/expression_binder/constant_binder.hpp

@@ -21,7 +21,7 @@ public:
 	string clause;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 };

package/src/duckdb/src/include/duckdb/planner/expression_binder/group_binder.hpp

@@ -27,7 +27,7 @@ public:
 	idx_t bind_index;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
 
 	string UnsupportedAggregateMessage() override;
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp

@@ -21,11 +21,11 @@ public:
 	             case_insensitive_map_t<idx_t> &alias_map, AggregateHandling aggregate_handling);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	ColumnAliasBinder column_alias_binder;
 	AggregateHandling aggregate_handling;

package/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp

@@ -23,7 +23,7 @@ public:
 	            optional_ptr<CreateIndexInfo> info = nullptr);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 	string UnsupportedAggregateMessage() override;
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/insert_binder.hpp

@@ -18,7 +18,7 @@ public:
 	InsertBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

package/src/duckdb/src/include/duckdb/planner/expression_binder/lateral_binder.hpp

@@ -29,13 +29,13 @@ public:
 	static void ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &info);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 	void ExtractCorrelatedColumns(Expression &expr);
 
 private:

package/src/duckdb/src/include/duckdb/planner/expression_binder/qualify_binder.hpp

@@ -20,11 +20,11 @@ public:
 	              case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	ColumnAliasBinder column_alias_binder;
 };

package/src/duckdb/src/include/duckdb/planner/expression_binder/relation_binder.hpp

@@ -20,7 +20,7 @@ public:
 	string op;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

package/src/duckdb/src/include/duckdb/planner/expression_binder/returning_binder.hpp

@@ -18,7 +18,7 @@ public:
 	ReturningBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 };
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp

@@ -19,7 +19,7 @@ public:
 
 protected:
 	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression);
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 };

package/src/duckdb/src/include/duckdb/planner/expression_binder/update_binder.hpp

@@ -18,7 +18,7 @@ public:
 	UpdateBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

package/src/duckdb/src/include/duckdb/planner/expression_binder/where_binder.hpp

@@ -20,13 +20,13 @@ public:
 	WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder = nullptr);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	optional_ptr<ColumnAliasBinder> column_alias_binder;
 };

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -63,7 +63,7 @@ public:
 	optional_ptr<vector<DummyBinding>> lambda_bindings;
 
 public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type = nullptr,
+	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, optional_ptr<LogicalType> result_type = nullptr,
 	                            bool root_expression = true);
 
 	//! Returns whether or not any columns have been bound by the expression binder
@@ -74,7 +74,7 @@ public:
 		return bound_columns;
 	}
 
-	string Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false);
+	string Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false);
 
 	unique_ptr<ParsedExpression> CreateStructExtract(unique_ptr<ParsedExpression> base, string field_name);
 	unique_ptr<ParsedExpression> CreateStructPack(ColumnRefExpression &colref);
@@ -103,7 +103,7 @@ public:
 
 	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
 	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
-	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	virtual BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                                  bool root_expression = false);
 
 	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
@@ -117,7 +117,7 @@ protected:
 	BindResult BindExpression(ComparisonExpression &expr, idx_t depth);
 	BindResult BindExpression(ConjunctionExpression &expr, idx_t depth);
 	BindResult BindExpression(ConstantExpression &expr, idx_t depth);
-	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> *expr_ptr);
+	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> &expr_ptr);
 	BindResult BindExpression(LambdaExpression &expr, idx_t depth, const bool is_lambda,
 	                          const LogicalType &list_child_type);
 	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
@@ -134,12 +134,15 @@ protected:
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindLambdaFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth);
+	virtual BindResult BindFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
+	                                idx_t depth);
+	virtual BindResult BindLambdaFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
+	                                      idx_t depth);
+	virtual BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
+	                                 idx_t depth);
 	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression);
-	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry *macro, idx_t depth,
-	                             unique_ptr<ParsedExpression> *expr_ptr);
+	virtual BindResult BindMacro(FunctionExpression &expr, optional_ptr<ScalarMacroCatalogEntry> macro, idx_t depth,
+	                             unique_ptr<ParsedExpression> &expr_ptr);
 
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();