duckdb 0.7.2-dev1898.0 → 0.7.2-dev2144.0

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

@@ -17,10 +17,10 @@ struct RadixPartitionInfo {
 	const idx_t n_partitions;
 	const idx_t radix_bits;
 	const hash_t radix_mask;
-	constexpr static idx_t RADIX_SHIFT = 40;
+	const idx_t radix_shift;
 
 	inline hash_t GetHashPartition(hash_t hash) const {
-		return (hash & radix_mask) >> RADIX_SHIFT;
+		return (hash & radix_mask) >> radix_shift;
 	}
 };
 

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/main/query_result.hpp"
 

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

@@ -58,7 +58,16 @@ protected:
 	//! The error (in case execution was not successful)
 	PreservedError error;
 };
-
+struct CurrentChunk {
+	//! The current data chunk
+	unique_ptr<DataChunk> data_chunk;
+	//! The current position in the data chunk
+	idx_t position;
+	//! If we have a current chunk we must scan for result production
+	bool Valid();
+	//! The remaining size of the current chunk
+	idx_t RemainingSize();
+};
 //! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
 //! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
 //! incrementally fetch data from the database.
@@ -75,6 +84,10 @@ public:
 	ClientProperties client_properties;
 	//! The next result (if any)
 	unique_ptr<QueryResult> next;
+	//! In case we are converting the result from Native DuckDB to a different library (e.g., Arrow, Polars)
+	//! We might be producing chunks of a pre-determined size.
+	//! To comply, we use the following variable to store the current chunk, and it's position.
+	CurrentChunk current_chunk;
 
 public:
 	//! Returns the name of the column for the given index

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

@@ -37,11 +37,11 @@ public:
 
 private:
 	//! Apply a set of rules to a specific expression
-	static unique_ptr<Expression> ApplyRules(LogicalOperator &op, const vector<Rule *> &rules,
+	static unique_ptr<Expression> ApplyRules(LogicalOperator &op, const vector<reference<Rule>> &rules,
 	                                         unique_ptr<Expression> expr, bool &changes_made, bool is_root = false);
 
-	LogicalOperator *op;
-	vector<Rule *> to_apply_rules;
+	optional_ptr<LogicalOperator> op;
+	vector<reference<Rule>> to_apply_rules;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp

@@ -41,9 +41,9 @@ struct RelationsToTDom {
 
 struct NodeOp {
 	unique_ptr<JoinNode> node;
-	LogicalOperator *op;
+	LogicalOperator &op;
 
-	NodeOp(unique_ptr<JoinNode> node, LogicalOperator *op) : node(std::move(node)), op(op) {};
+	NodeOp(unique_ptr<JoinNode> node, LogicalOperator &op) : node(std::move(node)), op(op) {};
 };
 
 struct Subgraph2Denominator {
@@ -71,7 +71,7 @@ private:
 public:
 	static constexpr double DEFAULT_SELECTIVITY = 0.2;
 
-	static void VerifySymmetry(JoinNode *result, JoinNode *entry);
+	static void VerifySymmetry(JoinNode &result, JoinNode &entry);
 
 	//! given a binding of (relation, column) used for DP, and a (table, column) in that catalog
 	//! Add the key value entry into the relation_column_to_original_column
@@ -83,20 +83,20 @@ public:
 	// in the child join plan.
 	void CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map);
 	void MergeBindings(idx_t, idx_t relation_id, vector<column_binding_map_t<ColumnBinding>> &child_binding_maps);
-	void AddRelationColumnMapping(LogicalGet *get, idx_t relation_id);
+	void AddRelationColumnMapping(LogicalGet &get, idx_t relation_id);
 
 	void InitTotalDomains();
-	void UpdateTotalDomains(JoinNode *node, LogicalOperator *op);
-	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos);
+	void UpdateTotalDomains(JoinNode &node, LogicalOperator &op);
+	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> &filter_infos);
 
-	void InitCardinalityEstimatorProps(vector<NodeOp> *node_ops, vector<unique_ptr<FilterInfo>> *filter_infos);
-	double EstimateCardinalityWithSet(JoinRelationSet *new_set);
-	void EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op);
-	double EstimateCrossProduct(const JoinNode *left, const JoinNode *right);
-	static double ComputeCost(JoinNode *left, JoinNode *right, double expected_cardinality);
+	void InitCardinalityEstimatorProps(vector<NodeOp> &node_ops, vector<unique_ptr<FilterInfo>> &filter_infos);
+	double EstimateCardinalityWithSet(JoinRelationSet &new_set);
+	void EstimateBaseTableCardinality(JoinNode &node, LogicalOperator &op);
+	double EstimateCrossProduct(const JoinNode &left, const JoinNode &right);
+	static double ComputeCost(JoinNode &left, JoinNode &right, double expected_cardinality);
 
 private:
-	bool SingleColumnFilter(FilterInfo *filter_info);
+	bool SingleColumnFilter(FilterInfo &filter_info);
 	//! Filter & bindings -> list of indexes into the equivalent_relations array.
 	// The column binding set at each index is an equivalence set.
 	vector<idx_t> DetermineMatchingEquivalentSets(FilterInfo *filter_info);
@@ -106,16 +106,16 @@ private:
 	//! If there are multiple equivalence sets, they are merged.
 	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
 
-	TableFilterSet *GetTableFilters(LogicalOperator *op, idx_t table_index);
+	optional_ptr<TableFilterSet> GetTableFilters(LogicalOperator &op, idx_t table_index);
 
-	void AddRelationTdom(FilterInfo *filter_info);
-	bool EmptyFilter(FilterInfo *filter_info);
+	void AddRelationTdom(FilterInfo &filter_info);
+	bool EmptyFilter(FilterInfo &filter_info);
 
 	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *fil,
 	                            unique_ptr<BaseStatistics> base_stats);
 	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *fil,
 	                           unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters, idx_t table_index);
+	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator &op, TableFilterSet &table_filters, idx_t table_index);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp

@@ -25,27 +25,27 @@ class JoinOrderOptimizer;
 class JoinNode {
 public:
 	//! Represents a node in the join plan
-	JoinRelationSet *set;
-	NeighborInfo *info;
+	JoinRelationSet &set;
+	optional_ptr<NeighborInfo> info;
 	//! If the JoinNode is a base table, then base_cardinality is the cardinality before filters
 	//! estimated_props.cardinality will be the cardinality after filters. With no filters, the two are equal
 	bool has_filter;
-	JoinNode *left;
-	JoinNode *right;
+	optional_ptr<JoinNode> left;
+	optional_ptr<JoinNode> right;
 
 	unique_ptr<EstimatedProperties> estimated_props;
 
 	//! Create a leaf node in the join tree
 	//! set cost to 0 for leaf nodes
 	//! cost will be the cost to *produce* an intermediate table
-	JoinNode(JoinRelationSet *set, const double base_cardinality);
+	JoinNode(JoinRelationSet &set, const double base_cardinality);
 
 	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
-	JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right, const double base_cardinality,
-	         double cost);
+	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right,
+	         const double base_cardinality, double cost);
 
 	bool operator==(const JoinNode &other) {
-		return other.set->ToString().compare(set->ToString()) == 0;
+		return other.set.ToString().compare(set.ToString()) == 0;
 	}
 
 private:

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp

@@ -22,6 +22,14 @@
 
 namespace duckdb {
 
+struct GenerateJoinRelation {
+	GenerateJoinRelation(JoinRelationSet &set, unique_ptr<LogicalOperator> op_p) : set(set), op(std::move(op_p)) {
+	}
+
+	JoinRelationSet &set;
+	unique_ptr<LogicalOperator> op;
+};
+
 class JoinOrderOptimizer {
 public:
 	explicit JoinOrderOptimizer(ClientContext &context)
@@ -31,8 +39,9 @@ public:
 	//! Perform join reordering inside a plan
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
 
-	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet *set, const vector<NeighborInfo *> &possible_connections,
-	                                    JoinNode *left, JoinNode *right);
+	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet &set,
+	                                    const vector<reference<NeighborInfo>> &possible_connections, JoinNode &left,
+	                                    JoinNode &right);
 
 private:
 	ClientContext &context;
@@ -71,23 +80,23 @@ private:
 
 	//! Traverse the query tree to find (1) base relations, (2) existing join conditions and (3) filters that can be
 	//! rewritten into joins. Returns true if there are joins in the tree that can be reordered, false otherwise.
-	bool ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
-	                          LogicalOperator *parent = nullptr);
+	bool ExtractJoinRelations(LogicalOperator &input_op, vector<reference<LogicalOperator>> &filter_operators,
+	                          optional_ptr<LogicalOperator> parent = nullptr);
 
 	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
 	//! the newly created plan, or an existing plan)
-	JoinNode *EmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+	JoinNode &EmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
 	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
 	//! cancelling the dynamic programming step.
-	bool TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+	bool TryEmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
 
-	bool EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right, unordered_set<idx_t> exclusion_set);
+	bool EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right, unordered_set<idx_t> exclusion_set);
 	//! Emit a relation set node
-	bool EmitCSG(JoinRelationSet *node);
+	bool EmitCSG(JoinRelationSet &node);
 	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
-	bool EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	bool EnumerateCSGRecursive(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set);
 	//! Rewrite a logical query plan given the join plan
-	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node);
+	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode &node);
 	//! Generate cross product edges inside the side
 	void GenerateCrossProducts();
 	//! Perform the join order solving
@@ -98,13 +107,12 @@ private:
 	//! Solve the join order approximately using a greedy algorithm
 	void SolveJoinOrderApproximately();
 
-	void UpdateDPTree(JoinNode *new_plan);
+	void UpdateDPTree(JoinNode &new_plan);
 
-	void UpdateJoinNodesInFullPlan(JoinNode *node);
-	bool NodeInFullPlan(JoinNode *node);
+	void UpdateJoinNodesInFullPlan(JoinNode &node);
+	bool NodeInFullPlan(JoinNode &node);
 
-	std::pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
-	GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node);
+	GenerateJoinRelation GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode &node);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp

@@ -11,18 +11,17 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class LogicalOperator;
 
 //! Represents a single relation and any metadata accompanying that relation
 struct SingleJoinRelation {
-	LogicalOperator *op;
-	LogicalOperator *parent;
+	LogicalOperator &op;
+	optional_ptr<LogicalOperator> parent;
 
-	SingleJoinRelation() {
-	}
-	SingleJoinRelation(LogicalOperator *op, LogicalOperator *parent) : op(op), parent(parent) {
+	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent) : op(op), parent(parent) {
 	}
 };
 
@@ -36,7 +35,7 @@ struct JoinRelationSet {
 	unique_ptr<idx_t[]> relations;
 	idx_t count;
 
-	static bool IsSubset(JoinRelationSet *super, JoinRelationSet *sub);
+	static bool IsSubset(JoinRelationSet &super, JoinRelationSet &sub);
 };
 
 //! The JoinRelationTree is a structure holding all the created JoinRelationSet objects and allowing fast lookup on to
@@ -52,13 +51,13 @@ public:
 
 public:
 	//! Create or get a JoinRelationSet from a single node with the given index
-	JoinRelationSet *GetJoinRelation(idx_t index);
+	JoinRelationSet &GetJoinRelation(idx_t index);
 	//! Create or get a JoinRelationSet from a set of relation bindings
-	JoinRelationSet *GetJoinRelation(unordered_set<idx_t> &bindings);
+	JoinRelationSet &GetJoinRelation(unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet *GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
+	JoinRelationSet &GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set
-	JoinRelationSet *Union(JoinRelationSet *left, JoinRelationSet *right);
+	JoinRelationSet &Union(JoinRelationSet &left, JoinRelationSet &right);
 	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)
 	// JoinRelationSet *Difference(JoinRelationSet *left, JoinRelationSet *right);
 

package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/optimizer/join_order/join_relation.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/planner/column_binding.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -23,22 +24,28 @@ class Expression;
 class LogicalOperator;
 
 struct FilterInfo {
+	FilterInfo(JoinRelationSet &set, idx_t filter_index) : set(set), filter_index(filter_index) {
+	}
+
+	JoinRelationSet &set;
 	idx_t filter_index;
-	JoinRelationSet *left_set = nullptr;
-	JoinRelationSet *right_set = nullptr;
+	optional_ptr<JoinRelationSet> left_set;
+	optional_ptr<JoinRelationSet> right_set;
 	ColumnBinding left_binding;
 	ColumnBinding right_binding;
-	JoinRelationSet *set = nullptr;
 };
 
 struct FilterNode {
-	vector<FilterInfo *> filters;
+	vector<reference<FilterInfo>> filters;
 	unordered_map<idx_t, unique_ptr<FilterNode>> children;
 };
 
 struct NeighborInfo {
-	JoinRelationSet *neighbor;
-	vector<FilterInfo *> filters;
+	NeighborInfo(JoinRelationSet &neighbor) : neighbor(neighbor) {
+	}
+
+	JoinRelationSet &neighbor;
+	vector<reference<FilterInfo>> filters;
 };
 
 //! The QueryGraph contains edges between relations and allows edges to be created/queried
@@ -55,18 +62,18 @@ public:
 	void Print();
 
 	//! Create an edge in the edge_set
-	void CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *info);
+	void CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> info);
 	//! Returns a connection if there is an edge that connects these two sets, or nullptr otherwise
-	vector<NeighborInfo *> GetConnections(JoinRelationSet *node, JoinRelationSet *other);
+	vector<reference<NeighborInfo>> GetConnections(JoinRelationSet &node, JoinRelationSet &other);
 	//! Enumerate the neighbors of a specific node that do not belong to any of the exclusion_set. Note that if a
 	//! neighbor has multiple nodes, this function will return the lowest entry in that set.
-	vector<idx_t> GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	vector<idx_t> GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set);
 	//! Enumerate all neighbors of a given JoinRelationSet node
-	void EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback);
+	void EnumerateNeighbors(JoinRelationSet &node, const std::function<bool(NeighborInfo &)> &callback);
 
 private:
 	//! Get the QueryEdge of a specific node
-	QueryEdge *GetQueryEdge(JoinRelationSet *left);
+	QueryEdge &GetQueryEdge(JoinRelationSet &left);
 
 	QueryEdge root;
 };

package/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp

@@ -61,7 +61,7 @@ public:
 
 public:
 	//! Build the MetaPipeline with 'op' as the first operator (excl. the shared sink)
-	void Build(PhysicalOperator *op);
+	void Build(PhysicalOperator &op);
 	//! Ready all the pipelines (recursively)
 	void Ready();
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp

@@ -29,7 +29,11 @@ struct ExportedTableData {
 };
 
 struct ExportedTableInfo {
-	TableCatalogEntry *entry;
+	ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data)
+	    : entry(entry), table_data(std::move(table_data)) {
+	}
+
+	TableCatalogEntry &entry;
 	ExportedTableData table_data;
 };
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/parser/tableref.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
@@ -22,7 +23,7 @@ struct VacuumOptions {
 
 struct VacuumInfo : public ParseInfo {
 public:
-	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false), table(nullptr) {};
+	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false) {};
 
 	unique_ptr<VacuumInfo> Copy() {
 		auto result = make_uniq<VacuumInfo>(options);
@@ -38,7 +39,7 @@ public:
 public:
 	bool has_table;
 	unique_ptr<TableRef> ref;
-	TableCatalogEntry *table;
+	optional_ptr<TableCatalogEntry> table;
 	unordered_map<idx_t, idx_t> column_id_map;
 	vector<string> columns;
 };

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

@@ -11,18 +11,20 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/exception_format_value.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class SQLStatement;
 
 class QueryErrorContext {
 public:
-	explicit QueryErrorContext(SQLStatement *statement_ = nullptr, idx_t query_location_ = DConstants::INVALID_INDEX)
+	explicit QueryErrorContext(optional_ptr<SQLStatement> statement_ = nullptr,
+	                           idx_t query_location_ = DConstants::INVALID_INDEX)
 	    : statement(statement_), query_location(query_location_) {
 	}
 
 	//! The query statement
-	SQLStatement *statement;
+	optional_ptr<SQLStatement> statement;
 	//! The location in which the error should be thrown
 	idx_t query_location;
 

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

@@ -49,19 +49,17 @@ class Transformer {
 
 public:
 	explicit Transformer(ParserOptions &options);
-	explicit Transformer(Transformer *parent);
+	explicit Transformer(Transformer &parent);
 	~Transformer();
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
 	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
 	string NodetypeToString(duckdb_libpgquery::PGNodeTag type);
 
-	idx_t ParamCount() {
-		return parent ? parent->ParamCount() : prepared_statement_parameter_index;
-	}
+	idx_t ParamCount() const;
 
 private:
-	Transformer *parent;
+	optional_ptr<Transformer> parent;
 	//! Parser options
 	ParserOptions &options;
 	//! The current prepared statement parameter index
@@ -80,36 +78,12 @@ private:
 	void Clear();
 	bool InWindowDefinition();
 
-	void SetParamCount(idx_t new_count) {
-		if (parent) {
-			parent->SetParamCount(new_count);
-		} else {
-			this->prepared_statement_parameter_index = new_count;
-		}
-	}
-	void SetNamedParam(const string &name, int32_t index) {
-		if (parent) {
-			parent->SetNamedParam(name, index);
-		} else {
-			D_ASSERT(!named_param_map.count(name));
-			this->named_param_map[name] = index;
-		}
-	}
-	bool GetNamedParam(const string &name, int32_t &index) {
-		if (parent) {
-			return parent->GetNamedParam(name, index);
-		} else {
-			auto entry = named_param_map.find(name);
-			if (entry == named_param_map.end()) {
-				return false;
-			}
-			index = entry->second;
-			return true;
-		}
-	}
-	bool HasNamedParameters() const {
-		return parent ? parent->HasNamedParameters() : !named_param_map.empty();
-	}
+	Transformer &RootTransformer();
+	const Transformer &RootTransformer() const;
+	void SetParamCount(idx_t new_count);
+	void SetNamedParam(const string &name, int32_t index);
+	bool GetNamedParam(const string &name, int32_t &index);
+	bool HasNamedParameters() const;
 
 	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column);
 	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);

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

@@ -21,6 +21,7 @@
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/common/reference_map.hpp"
 
 namespace duckdb {
 class BoundResultModifier;
@@ -76,43 +77,43 @@ class Binder : public std::enable_shared_from_this<Binder> {
 	friend class RecursiveSubqueryPlanner;
 
 public:
-	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, Binder *parent = nullptr,
+	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, optional_ptr<Binder> parent = nullptr,
 	                                                  bool inherit_ctes = true);
 
 	//! The client context
 	ClientContext &context;
 	//! A mapping of names to common table expressions
-	case_insensitive_map_t<CommonTableExpressionInfo *> CTE_bindings; // NOLINT
+	case_insensitive_map_t<reference<CommonTableExpressionInfo>> CTE_bindings; // NOLINT
 	//! The CTEs that have already been bound
-	unordered_set<CommonTableExpressionInfo *> bound_ctes;
+	reference_set_t<CommonTableExpressionInfo> bound_ctes;
 	//! The bind context
 	BindContext bind_context;
 	//! The set of correlated columns bound by this binder (FIXME: this should probably be an unordered_set and not a
 	//! vector)
 	vector<CorrelatedColumnInfo> correlated_columns;
 	//! The set of parameter expressions bound by this binder
-	BoundParameterMap *parameters;
+	optional_ptr<BoundParameterMap> parameters;
 	//! Statement properties
 	StatementProperties properties;
 	//! The alias for the currently processing subquery, if it exists
 	string alias;
 	//! Macro parameter bindings (if any)
-	DummyBinding *macro_binding = nullptr;
+	optional_ptr<DummyBinding> macro_binding;
 	//! The intermediate lambda bindings to bind nested lambdas (if any)
-	vector<DummyBinding> *lambda_bindings = nullptr;
+	optional_ptr<vector<DummyBinding>> lambda_bindings;
 
 public:
 	DUCKDB_API BoundStatement Bind(SQLStatement &statement);
 	DUCKDB_API BoundStatement Bind(QueryNode &node);
 
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema);
+	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema);
 
 	vector<unique_ptr<Expression>> BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info);
 
 	void BindCreateViewInfo(CreateViewInfo &base);
-	SchemaCatalogEntry *BindSchema(CreateInfo &info);
-	SchemaCatalogEntry *BindCreateFunctionInfo(CreateInfo &info);
+	SchemaCatalogEntry &BindSchema(CreateInfo &info);
+	SchemaCatalogEntry &BindCreateFunctionInfo(CreateInfo &info);
 
 	//! Check usage, and cast named parameters to their types
 	static void BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
@@ -125,22 +126,22 @@ public:
 	idx_t GenerateTableIndex();
 
 	//! Add a common table expression to the binder
-	void AddCTE(const string &name, CommonTableExpressionInfo *cte);
+	void AddCTE(const string &name, CommonTableExpressionInfo &cte);
 	//! Find a common table expression by name; returns nullptr if none exists
-	CommonTableExpressionInfo *FindCTE(const string &name, bool skip = false);
+	optional_ptr<CommonTableExpressionInfo> FindCTE(const string &name, bool skip = false);
 
-	bool CTEIsAlreadyBound(CommonTableExpressionInfo *cte);
+	bool CTEIsAlreadyBound(CommonTableExpressionInfo &cte);
 
 	//! Add the view to the set of currently bound views - used for detecting recursive view definitions
-	void AddBoundView(ViewCatalogEntry *view);
+	void AddBoundView(ViewCatalogEntry &view);
 
-	void PushExpressionBinder(ExpressionBinder *binder);
+	void PushExpressionBinder(ExpressionBinder &binder);
 	void PopExpressionBinder();
-	void SetActiveBinder(ExpressionBinder *binder);
-	ExpressionBinder *GetActiveBinder();
+	void SetActiveBinder(ExpressionBinder &binder);
+	ExpressionBinder &GetActiveBinder();
 	bool HasActiveBinder();
 
-	vector<ExpressionBinder *> &GetActiveBinders();
+	vector<reference<ExpressionBinder>> &GetActiveBinders();
 
 	void MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other);
 	//! Add a correlated column to this binder (if it does not exist)
@@ -184,7 +185,7 @@ public:
 	BindingMode GetBindingMode();
 	void AddTableName(string table_name);
 	const unordered_set<string> &GetTableNames();
-	SQLStatement *GetRootStatement() {
+	optional_ptr<SQLStatement> GetRootStatement() {
 		return root_statement;
 	}
 
@@ -194,7 +195,7 @@ private:
 	//! The parent binder (if any)
 	shared_ptr<Binder> parent;
 	//! The vector of active binders
-	vector<ExpressionBinder *> active_binders;
+	vector<reference<ExpressionBinder>> active_binders;
 	//! The count of bound_tables
 	idx_t bound_tables;
 	//! Whether or not the binder has any unplanned subqueries that still need to be planned
@@ -206,13 +207,13 @@ private:
 	//! Whether or not the binder can contain NULLs as the root of expressions
 	bool can_contain_nulls = false;
 	//! The root statement of the query that is currently being parsed
-	SQLStatement *root_statement = nullptr;
+	optional_ptr<SQLStatement> root_statement;
 	//! Binding mode
 	BindingMode mode = BindingMode::STANDARD_BINDING;
 	//! Table names extracted for BindingMode::EXTRACT_NAMES
 	unordered_set<string> table_names;
 	//! The set of bound views
-	unordered_set<ViewCatalogEntry *> bound_views;
+	reference_set_t<ViewCatalogEntry> bound_views;
 
 private:
 	//! Bind the expressions of generated columns to check for errors
@@ -273,7 +274,7 @@ private:
 
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
-	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte = nullptr);
+	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte = nullptr);
 	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
 	unique_ptr<BoundTableRef> Bind(EmptyTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
@@ -349,7 +350,7 @@ private:
 
 	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
 	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
-	SchemaCatalogEntry *BindCreateSchema(CreateInfo &info);
+	SchemaCatalogEntry &BindCreateSchema(CreateInfo &info);
 
 	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);