duckdb 0.7.2-dev1901.0 → 0.7.2-dev2233.0

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_buffer.hpp

@@ -21,14 +21,15 @@ public:
 
 	//! Constructor for Initial Buffer
 	CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
-	          idx_t &global_csv_current_position);
+	          idx_t &global_csv_current_position, idx_t file_number);
 
 	//! Constructor for `Next()` Buffers
 	CSVBuffer(ClientContext &context, BufferHandle handle, idx_t buffer_size_p, idx_t actual_size_p, bool final_buffer,
-	          idx_t global_csv_current_position);
+	          idx_t global_csv_current_position, idx_t file_number);
 
 	//! Creates a new buffer with the next part of the CSV File
-	unique_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t &global_csv_current_position);
+	unique_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t &global_csv_current_position,
+	                           idx_t file_number);
 
 	//! Gets the buffer actual size
 	idx_t GetBufferSize();
@@ -44,6 +45,8 @@ public:
 
 	idx_t GetCSVGlobalStart();
 
+	idx_t GetFileNumber();
+
 	BufferHandle AllocateBuffer(idx_t buffer_size);
 
 	char *Ptr() {
@@ -65,5 +68,7 @@ private:
 	bool first_buffer = false;
 	//! Global position from the CSV File where this buffer starts
 	idx_t global_csv_start = 0;
+	//! Number of the file that is in this buffer
+	idx_t file_number = 0;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -39,11 +39,6 @@ struct BufferedCSVReaderOptions {
 	bool has_newline = false;
 	//! New Line separator
 	NewLineIdentifier new_line = NewLineIdentifier::NOT_SET;
-
-	//! Whether or not an option was provided for parallel
-	bool has_parallel = false;
-	//! Whether or not the read will use the ParallelCSVReader
-	bool use_parallel = false;
 	//! Whether or not a quote was defined by the user
 	bool has_quote = false;
 	//! Quote used for columns that contain reserved characters, e.g., delimiter
@@ -114,8 +109,12 @@ struct BufferedCSVReaderOptions {
 	//! Decimal separator when reading as numeric
 	string decimal_separator = ".";
 	//! Whether or not to pad rows that do not have enough columns with NULL values
-	bool null_padding = true;
+	bool null_padding = false;
 
+	//! If we are running the parallel version of the CSV Reader. In general, the system should always auto-detect
+	//! When it can't execute a parallel run before execution. However, there are (rather specific) situations where
+	//! setting up this manually might be important
+	bool run_parallel = true;
 	//===--------------------------------------------------------------------===//
 	// WriteCSVOptions
 	//===--------------------------------------------------------------------===//
@@ -139,7 +138,6 @@ struct BufferedCSVReaderOptions {
 	void SetEscape(const string &escape);
 	void SetQuote(const string &quote);
 	void SetDelimiter(const string &delimiter);
-	void SetParallel(bool use_parallel);
 
 	void SetNewline(const string &input);
 	//! Set an option that is supported by both reading and writing functions, called by

package/src/duckdb/src/include/duckdb/execution/operator/persistent/parallel_csv_reader.hpp

@@ -99,7 +99,7 @@ struct VerificationPositions {
 class ParallelCSVReader : public BaseCSVReader {
 public:
 	ParallelCSVReader(ClientContext &context, BufferedCSVReaderOptions options, unique_ptr<CSVBufferRead> buffer,
-	                  const vector<LogicalType> &requested_types);
+	                  idx_t first_pos_first_buffer, const vector<LogicalType> &requested_types);
 	~ParallelCSVReader();
 
 	//! Current Position (Relative to the Buffer)
@@ -136,6 +136,8 @@ private:
 	bool TryParseCSV(ParserMode mode, DataChunk &insert_chunk, string &error_message);
 	//! Sets Position depending on the byte_start of this thread
 	bool SetPosition(DataChunk &insert_chunk);
+	//! Called when scanning the 1st buffer, skips empty lines
+	void SkipEmptyLines();
 	//! When a buffer finishes reading its piece, it still can try to scan up to the real end of the buffer
 	//! Up to finding a new line. This function sets the buffer_end and marks a boolean variable
 	//! when changing the buffer end the first time.
@@ -148,6 +150,8 @@ private:
 	bool TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message, bool try_add_line = false);
 	//! Position of the first read line and last read line for verification purposes
 	VerificationPositions verification_positions;
+	//! First Position of First Buffer
+	idx_t first_pos_first_buffer = 0;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp

@@ -11,6 +11,8 @@
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
 #include "duckdb/function/copy_function.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/filename_pattern.hpp"
 
 namespace duckdb {
 
@@ -27,7 +29,8 @@ public:
 	unique_ptr<FunctionData> bind_data;
 	string file_path;
 	bool use_tmp_file;
-	bool allow_overwrite;
+	FilenamePattern filename_pattern;
+	bool overwrite_or_ignore;
 	bool parallel;
 	bool per_thread_output;
 

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.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/execution/physical_operator.hpp"
 
 namespace duckdb {

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.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/execution/physical_operator.hpp"
 
 namespace duckdb {

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/function/function.hpp

@@ -91,6 +91,8 @@ public:
 
 	//! The name of the function
 	string name;
+	//! Additional Information to specify function from it's name
+	string extra_info;
 
 public:
 	//! Returns the formatted string name(arg1, arg2, ...)

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -56,6 +56,28 @@ struct WriteCSVData : public BaseCSVData {
 	idx_t flush_size = 4096 * 8;
 };
 
+struct ColumnInfo {
+	ColumnInfo() {
+	}
+	ColumnInfo(vector<std::string> names_p, vector<LogicalType> types_p) {
+		names = std::move(names_p);
+		types = std::move(types_p);
+	}
+	void Serialize(FieldWriter &writer) {
+		writer.WriteList<string>(names);
+		writer.WriteRegularSerializableList<LogicalType>(types);
+	}
+
+	static ColumnInfo Deserialize(FieldReader &reader) {
+		ColumnInfo info;
+		info.names = reader.ReadRequiredList<string>();
+		info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+		return info;
+	}
+	vector<std::string> names;
+	vector<LogicalType> types;
+};
+
 struct ReadCSVData : public BaseCSVData {
 	//! The expected SQL types to read from the file
 	vector<LogicalType> csv_types;
@@ -75,6 +97,9 @@ struct ReadCSVData : public BaseCSVData {
 	bool single_threaded = false;
 	//! Reader bind data
 	MultiFileReaderBindData reader_bind;
+	//! If all files are On-Disk file (e.g., not a pipe)
+	bool file_exists = true;
+	vector<ColumnInfo> column_info;
 
 	void Initialize(unique_ptr<BufferedCSVReader> &reader) {
 		this->initial_reader = std::move(reader);

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

@@ -58,6 +58,9 @@ struct ClientData {
 	//! The file search path
 	string file_search_path;
 
+	//! The Max Line Length Size of Last Query Executed on a CSV File. (Only used for testing)
+	idx_t max_line_length = 0;
+
 public:
 	DUCKDB_API static ClientData &Get(ClientContext &context);
 };

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

@@ -143,8 +143,6 @@ struct DBConfigOptions {
 	bool allow_unsigned_extensions = false;
 	//! Enable emitting FSST Vectors
 	bool enable_fsst_vectors = false;
-	//! Experimental parallel CSV reader
-	bool experimental_parallel_csv_reader = false;
 	//! Start transactions immediately in all attached databases - instead of lazily when a database is referenced
 	bool immediate_transaction_mode = false;
 	//! The set of unrecognized (other) options

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;
 };