duckdb 0.7.2-dev2233.0 → 0.7.2-dev2320.0

package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/adbc/adbc.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/adbc/adbc.h"
+
+namespace duckdb_adbc {
+
+AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error);
+
+AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
+                                 struct AdbcError *error);
+
+AdbcStatusCode DatabaseInit(struct AdbcDatabase *database, struct AdbcError *error);
+
+AdbcStatusCode DatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error);
+
+AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError *error);
+
+AdbcStatusCode ConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
+                                   struct AdbcError *error);
+
+AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
+                              struct AdbcError *error);
+
+AdbcStatusCode ConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error);
+
+AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, uint32_t *info_codes, size_t info_codes_length,
+                                 struct ArrowArrayStream *out, struct AdbcError *error);
+
+AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
+                                    const char *db_schema, const char *table_name, const char **table_type,
+                                    const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error);
+
+AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog, const char *db_schema,
+                                        const char *table_name, struct ArrowSchema *schema, struct AdbcError *error);
+
+AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,
+                                       struct AdbcError *error);
+
+AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
+                                       size_t serialized_length, struct ArrowArrayStream *out, struct AdbcError *error);
+
+AdbcStatusCode ConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error);
+
+AdbcStatusCode ConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error);
+
+AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
+                            struct AdbcError *error);
+
+AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcError *error);
+
+AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
+                                     int64_t *rows_affected, struct AdbcError *error);
+
+AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error);
+
+AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error);
+
+AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length,
+                                         struct AdbcError *error);
+
+AdbcStatusCode StatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schema,
+                             struct AdbcError *error);
+
+AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *stream,
+                                   struct AdbcError *error);
+
+AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
+                                           struct AdbcError *error);
+
+AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
+                                  struct AdbcError *error);
+
+AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
+                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
+                                          struct AdbcError *error);
+
+} // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/adbc/driver_manager.h

@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "duckdb/common/adbc/adbc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ADBC_DRIVER_MANAGER_H
+#define ADBC_DRIVER_MANAGER_H
+namespace duckdb_adbc {
+/// \brief Common entry point for drivers via the driver manager.
+///
+/// The driver manager can fill in default implementations of some
+/// ADBC functions for drivers. Drivers must implement a minimum level
+/// of functionality for this to be possible, however, and some
+/// functions must be implemented by the driver.
+///
+/// \param[in] driver_name An identifier for the driver (e.g. a path to a
+///   shared library on Linux).
+/// \param[in] entrypoint An identifier for the entrypoint (e.g. the
+///   symbol to call for AdbcDriverInitFunc on Linux).
+/// \param[in] version The ADBC revision to attempt to initialize.
+/// \param[out] driver The table of function pointers to initialize.
+/// \param[out] error An optional location to return an error message
+///   if necessary.
+ADBC_EXPORT
+AdbcStatusCode AdbcLoadDriver(const char *driver_name, const char *entrypoint, int version, void *driver,
+                              struct AdbcError *error);
+
+/// \brief Common entry point for drivers via the driver manager.
+///
+/// The driver manager can fill in default implementations of some
+/// ADBC functions for drivers. Drivers must implement a minimum level
+/// of functionality for this to be possible, however, and some
+/// functions must be implemented by the driver.
+///
+/// \param[in] init_func The entrypoint to call.
+/// \param[in] version The ADBC revision to attempt to initialize.
+/// \param[out] driver The table of function pointers to initialize.
+/// \param[out] error An optional location to return an error message
+///   if necessary.
+ADBC_EXPORT
+AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int version, void *driver,
+                                          struct AdbcError *error);
+
+/// \brief Set the AdbcDriverInitFunc to use.
+///
+/// This is an extension to the ADBC API. The driver manager shims
+/// the AdbcDatabase* functions to allow you to specify the
+/// driver/entrypoint dynamically. This function lets you set the
+/// entrypoint explicitly, for applications that can dynamically
+/// load drivers on their own.
+ADBC_EXPORT
+AdbcStatusCode AdbcDriverManagerDatabaseSetInitFunc(struct AdbcDatabase *database, AdbcDriverInitFunc init_func,
+                                                    struct AdbcError *error);
+
+/// \brief Get a human-friendly description of a status code.
+ADBC_EXPORT
+const char *AdbcStatusCodeMessage(AdbcStatusCode code);
+
+#endif // ADBC_DRIVER_MANAGER_H
+
+#ifdef __cplusplus
+}
+#endif
+} // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/helper.hpp

@@ -183,6 +183,9 @@ void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
 template<typename T>
 using reference = std::reference_wrapper<T>;
 
+template<typename T>
+using const_reference = std::reference_wrapper<const T>;
+
 //! Returns whether or not two reference wrappers refer to the same object
 template<class T>
 bool RefersToSameObject(const reference<T> &A, const reference<T> &B) {

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

@@ -19,7 +19,8 @@ enum class LookupResultType : uint8_t { LOOKUP_MISS, LOOKUP_HIT, LOOKUP_NULL };
 
 class ConflictManager {
 public:
-	ConflictManager(VerifyExistenceType lookup_type, idx_t input_size, ConflictInfo *conflict_info = nullptr);
+	ConflictManager(VerifyExistenceType lookup_type, idx_t input_size,
+	                optional_ptr<ConflictInfo> conflict_info = nullptr);
 
 public:
 	void SetIndexCount(idx_t count);
@@ -52,7 +53,7 @@ private:
 private:
 	VerifyExistenceType lookup_type;
 	idx_t input_size;
-	ConflictInfo *conflict_info;
+	optional_ptr<ConflictInfo> conflict_info;
 	idx_t index_count;
 	bool finalized = false;
 	ManagedSelection conflicts;

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

@@ -10,7 +10,6 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
-#include "duckdb/common/single_thread_ptr.hpp"
 #include "duckdb/common/vector.hpp"
 
 #include <limits>

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

@@ -12,7 +12,7 @@
 #include "duckdb/common/enums/pending_execution_result.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 
 namespace duckdb {
@@ -43,7 +43,7 @@ public:
 public:
 	static Executor &Get(ClientContext &context);
 
-	void Initialize(PhysicalOperator *physical_plan);
+	void Initialize(PhysicalOperator &physical_plan);
 	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
 
 	void CancelTasks();
@@ -81,7 +81,7 @@ public:
 	}
 	void AddEvent(shared_ptr<Event> event);
 
-	void AddRecursiveCTE(PhysicalOperator *rec_cte);
+	void AddRecursiveCTE(PhysicalOperator &rec_cte);
 	void ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines, vector<shared_ptr<Event>> &events);
 
 	//! Whether or not the root of the pipeline is a result collector object
@@ -93,7 +93,7 @@ public:
 	bool ExecutionIsFinished();
 
 private:
-	void InitializeInternal(PhysicalOperator *physical_plan);
+	void InitializeInternal(PhysicalOperator &physical_plan);
 
 	void ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipelines);
 	static void ScheduleEventsInternal(ScheduleEventData &event_data);
@@ -106,13 +106,13 @@ private:
 
 	bool NextExecutor();
 
-	shared_ptr<Pipeline> CreateChildPipeline(Pipeline *current, PhysicalOperator *op);
+	shared_ptr<Pipeline> CreateChildPipeline(Pipeline &current, PhysicalOperator &op);
 
 	void VerifyPipeline(Pipeline &pipeline);
 	void VerifyPipelines();
 
 private:
-	PhysicalOperator *physical_plan;
+	optional_ptr<PhysicalOperator> physical_plan;
 	unique_ptr<PhysicalOperator> owned_plan;
 
 	mutex executor_lock;
@@ -122,7 +122,7 @@ private:
 	//! The root pipelines of the query
 	vector<shared_ptr<Pipeline>> root_pipelines;
 	//! The recursive CTE's in this query plan
-	vector<PhysicalOperator *> recursive_ctes;
+	vector<reference<PhysicalOperator>> recursive_ctes;
 	//! The pipeline executor for the root pipeline
 	unique_ptr<PipelineExecutor> root_executor;
 	//! The current root pipeline index

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp

@@ -25,7 +25,7 @@ public:
 	shared_ptr<PreparedStatementData> prepared;
 
 public:
-	vector<PhysicalOperator *> GetChildren() const override;
+	vector<const_reference<PhysicalOperator>> GetChildren() const override;
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp

@@ -36,7 +36,7 @@ public:
 	}
 
 public:
-	vector<PhysicalOperator *> GetChildren() const override;
+	vector<const_reference<PhysicalOperator>> GetChildren() const override;
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
 
 	bool IsSource() const override {

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

@@ -55,7 +55,7 @@ public:
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 };
 
 class CrossProductExecutor {

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

@@ -22,14 +22,14 @@ public:
 
 public:
 	PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-	                  vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality);
+	                  vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality);
 
 	unique_ptr<PhysicalOperator> join;
 	unique_ptr<PhysicalHashAggregate> distinct;
-	vector<PhysicalOperator *> delim_scans;
+	vector<const_reference<PhysicalOperator>> delim_scans;
 
 public:
-	vector<PhysicalOperator *> GetChildren() const override;
+	vector<const_reference<PhysicalOperator>> GetChildren() const override;
 
 public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -68,7 +68,7 @@ protected:
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 
 private:
 	void GetRHSMatches(ExecutionContext &context, DataChunk &input, OperatorState &state_p) const;

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

@@ -35,7 +35,7 @@ public:
 public:
 	static void BuildJoinPipelines(Pipeline &current, MetaPipeline &confluent_pipelines, PhysicalOperator &op);
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 
 	OrderPreservationType SourceOrder() const override {
 		return OrderPreservationType::NO_ORDER;

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

@@ -48,6 +48,6 @@ public:
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 };
 } // namespace duckdb

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

@@ -128,7 +128,8 @@ struct BufferedCSVReaderOptions {
 	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
 	                                                             {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
-	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
+	std::map<LogicalTypeId, bool> has_format = {
+	    {LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}, {LogicalTypeId::TIMESTAMP_TZ, false}};
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);

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

@@ -18,7 +18,7 @@ public:
 
 public:
 	//! INSERT INTO
-	PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry *table,
+	PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry &table,
 	                    physical_index_vector_t<idx_t> column_index_map, vector<unique_ptr<Expression>> bound_defaults,
 	                    idx_t estimated_cardinality);
 	//! CREATE TABLE AS
@@ -28,7 +28,7 @@ public:
 	//! The map from insert column index to table column index
 	physical_index_vector_t<idx_t> column_index_map;
 	//! The table to insert into
-	TableCatalogEntry *insert_table;
+	optional_ptr<TableCatalogEntry> insert_table;
 	//! The insert types
 	vector<LogicalType> insert_types;
 	//! The default expressions of the columns for which no value is provided

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

@@ -59,7 +59,7 @@ public:
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 };
 
 } // namespace duckdb

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

@@ -25,7 +25,7 @@ public:
 
 public:
 	//! INSERT INTO
-	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry *table, physical_index_vector_t<idx_t> column_index_map,
+	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry &table, physical_index_vector_t<idx_t> column_index_map,
 	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<Expression>> set_expressions,
 	               vector<PhysicalIndex> set_columns, vector<LogicalType> set_types, idx_t estimated_cardinality,
 	               bool return_chunk, bool parallel, OnConflictAction action_type,
@@ -38,7 +38,7 @@ public:
 	//! The map from insert column index to table column index
 	physical_index_vector_t<idx_t> column_index_map;
 	//! The table to insert into
-	TableCatalogEntry *insert_table;
+	optional_ptr<TableCatalogEntry> insert_table;
 	//! The insert types
 	vector<LogicalType> insert_types;
 	//! The default expressions of the columns for which no value is provided

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp

@@ -19,12 +19,11 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::COLUMN_DATA_SCAN;
 
 public:
-	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality)
-	    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(nullptr) {
-	}
+	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
+	                       unique_ptr<ColumnDataCollection> owned_collection = nullptr);
 
 	// the column data collection to scan
-	ColumnDataCollection *collection;
+	optional_ptr<ColumnDataCollection> collection;
 	//! Owned column data collection, if any
 	unique_ptr<ColumnDataCollection> owned_collection;
 

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp

@@ -51,7 +51,7 @@ public:
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
 
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 
 private:
 	//! Probe Hash Table and eliminate duplicate rows

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp

@@ -22,7 +22,7 @@ public:
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const PhysicalOperator *> GetSources() const override;
+	vector<const_reference<PhysicalOperator>> GetSources() const override;
 };
 
 } // namespace duckdb

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

@@ -62,7 +62,7 @@ public:
 	}
 	virtual string ToString() const;
 	void Print() const;
-	virtual vector<PhysicalOperator *> GetChildren() const;
+	virtual vector<const_reference<PhysicalOperator>> GetChildren() const;
 
 	//! Return a vector of the types that will be returned by this operator
 	const vector<LogicalType> &GetTypes() const {
@@ -170,7 +170,7 @@ public:
 
 public:
 	// Pipeline construction
-	virtual vector<const PhysicalOperator *> GetSources() const;
+	virtual vector<const_reference<PhysicalOperator>> GetSources() const;
 	bool AllSourcesSupportBatchIndex() const;
 
 	virtual void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline);
@@ -199,7 +199,7 @@ public:
 	~CachingOperatorState() override {
 	}
 
-	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
+	virtual void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
 	}
 
 	unique_ptr<DataChunk> cached_chunk;

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

@@ -30,7 +30,7 @@ public:
 	virtual ~OperatorState() {
 	}
 
-	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) {
+	virtual void Finalize(const PhysicalOperator &op, ExecutionContext &context) {
 	}
 
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp

@@ -59,7 +59,7 @@ public:
 private:
 	vector<BindCastFunction> bind_functions;
 	//! If any custom cast functions have been defined using RegisterCastFunction, this holds the map
-	MapCastInfo *map_info;
+	optional_ptr<MapCastInfo> map_info;
 
 private:
 	void RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node);

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

@@ -215,9 +215,9 @@ public:
 	DUCKDB_API static idx_t ParseMemoryLimit(const string &arg);
 
 	//! Return the list of possible compression functions for the specific physical type
-	DUCKDB_API vector<CompressionFunction *> GetCompressionFunctions(PhysicalType data_type);
+	DUCKDB_API vector<reference<CompressionFunction>> GetCompressionFunctions(PhysicalType data_type);
 	//! Return the compression function for the specified compression type/physical type combo
-	DUCKDB_API CompressionFunction *GetCompressionFunction(CompressionType type, PhysicalType data_type);
+	DUCKDB_API optional_ptr<CompressionFunction> GetCompressionFunction(CompressionType type, PhysicalType data_type);
 
 	bool operator==(const DBConfig &other);
 	bool operator!=(const DBConfig &other);

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

@@ -17,6 +17,7 @@
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/execution/expression_executor_state.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include <stack>
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/deque.hpp"
@@ -100,25 +101,25 @@ class OperatorProfiler {
 public:
 	DUCKDB_API explicit OperatorProfiler(bool enabled);
 
-	DUCKDB_API void StartOperator(const PhysicalOperator *phys_op);
-	DUCKDB_API void EndOperator(DataChunk *chunk);
-	DUCKDB_API void Flush(const PhysicalOperator *phys_op, ExpressionExecutor *expression_executor, const string &name,
+	DUCKDB_API void StartOperator(optional_ptr<const PhysicalOperator> phys_op);
+	DUCKDB_API void EndOperator(optional_ptr<DataChunk> chunk);
+	DUCKDB_API void Flush(const PhysicalOperator &phys_op, ExpressionExecutor &expression_executor, const string &name,
 	                      int id);
 
 	~OperatorProfiler() {
 	}
 
 private:
-	void AddTiming(const PhysicalOperator *op, double time, idx_t elements);
+	void AddTiming(const PhysicalOperator &op, double time, idx_t elements);
 
 	//! Whether or not the profiler is enabled
 	bool enabled;
 	//! The timer used to time the execution time of the individual Physical Operators
 	Profiler op;
 	//! The stack of Physical Operators that are currently active
-	const PhysicalOperator *active_operator;
+	optional_ptr<const PhysicalOperator> active_operator;
 	//! A mapping of physical operators to recorded timings
-	unordered_map<const PhysicalOperator *, OperatorInformation> timings;
+	reference_map_t<const PhysicalOperator, OperatorInformation> timings;
 };
 
 //! The QueryProfiler can be used to measure timings of queries
@@ -139,10 +140,10 @@ public:
 	// Propagate save_location, enabled, detailed_enabled and automatic_print_format.
 	void Propagate(QueryProfiler &qp);
 
-	using TreeMap = unordered_map<const PhysicalOperator *, TreeNode *>;
+	using TreeMap = reference_map_t<const PhysicalOperator, reference<TreeNode>>;
 
 private:
-	unique_ptr<TreeNode> CreateTree(PhysicalOperator *root, idx_t depth = 0);
+	unique_ptr<TreeNode> CreateTree(const PhysicalOperator &root, idx_t depth = 0);
 	void Render(const TreeNode &node, std::ostream &str) const;
 
 public:
@@ -165,7 +166,7 @@ public:
 	DUCKDB_API void StartPhase(string phase);
 	DUCKDB_API void EndPhase();
 
-	DUCKDB_API void Initialize(PhysicalOperator *root);
+	DUCKDB_API void Initialize(const PhysicalOperator &root);
 
 	DUCKDB_API string QueryTreeToString() const;
 	DUCKDB_API void QueryTreeToStream(std::ostream &str) const;

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

@@ -35,7 +35,7 @@ public:
 	//! Get the PipelineBuildState for this MetaPipeline
 	PipelineBuildState &GetState() const;
 	//! Get the sink operator for this MetaPipeline
-	PhysicalOperator *GetSink() const;
+	optional_ptr<PhysicalOperator> GetSink() const;
 
 	//! Get the initial pipeline of this MetaPipeline
 	shared_ptr<Pipeline> &GetBasePipeline();
@@ -71,9 +71,9 @@ public:
 	Pipeline *CreateUnionPipeline(Pipeline &current, bool order_matters);
 	//! Create a child pipeline op 'current' starting at 'op',
 	//! where 'last_pipeline' is the last pipeline added before building out 'current'
-	void CreateChildPipeline(Pipeline &current, PhysicalOperator *op, Pipeline *last_pipeline);
+	void CreateChildPipeline(Pipeline &current, PhysicalOperator &op, Pipeline *last_pipeline);
 	//! Create a MetaPipeline child that 'current' depends on
-	MetaPipeline *CreateChildMetaPipeline(Pipeline &current, PhysicalOperator *op);
+	MetaPipeline &CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op);
 
 private:
 	//! The executor for all MetaPipelines in the query plan
@@ -81,7 +81,7 @@ private:
 	//! The PipelineBuildState for all MetaPipelines in the query plan
 	PipelineBuildState &state;
 	//! The sink of all pipelines within this MetaPipeline
-	PhysicalOperator *sink;
+	optional_ptr<PhysicalOperator> sink;
 	//! Whether this MetaPipeline is a the recursive pipeline of a recursive CTE
 	bool recursive_cte;
 	//! All pipelines with a different source, but the same sink