duckdb 0.7.2-dev2867.0 → 0.7.2-dev3117.0

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

@@ -17,6 +17,7 @@ namespace duckdb {
 
 class Binder;
 struct BoundStatement;
+class ColumnDataCollection;
 class ExecutionContext;
 
 struct LocalFunctionData {
@@ -51,6 +52,24 @@ struct GlobalFunctionData {
 	}
 };
 
+struct PreparedBatchData {
+	virtual ~PreparedBatchData() {
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
+};
+
+enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
+
 typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
 typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyInfo &info, vector<string> &names,
                                                    vector<LogicalType> &sql_types);
@@ -71,15 +90,21 @@ typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(ClientContext &context
 typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
                                                      vector<string> &expected_names,
                                                      vector<LogicalType> &expected_types);
-typedef bool (*copy_to_is_parallel_t)(ClientContext &context, FunctionData &bind_data);
+typedef CopyFunctionExecutionMode (*copy_to_execution_mode_t)(bool preserve_insertion_order, bool supports_batch_index);
+
+typedef unique_ptr<PreparedBatchData> (*copy_prepare_batch_t)(ClientContext &context, FunctionData &bind_data,
+                                                              GlobalFunctionData &gstate,
+                                                              unique_ptr<ColumnDataCollection> collection);
+typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
+                                   PreparedBatchData &batch);
 
 class CopyFunction : public Function {
 public:
 	explicit CopyFunction(string name)
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
 	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
-	      copy_to_finalize(nullptr), parallel(nullptr), serialize(nullptr), deserialize(nullptr),
-	      copy_from_bind(nullptr) {
+	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
+	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -91,7 +116,10 @@ public:
 	copy_to_sink_t copy_to_sink;
 	copy_to_combine_t copy_to_combine;
 	copy_to_finalize_t copy_to_finalize;
-	copy_to_is_parallel_t parallel;
+	copy_to_execution_mode_t execution_mode;
+
+	copy_prepare_batch_t prepare_batch;
+	copy_flush_batch_t flush_batch;
 
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;

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

@@ -54,6 +54,8 @@ struct WriteCSVData : public BaseCSVData {
 	bool is_simple;
 	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
 	idx_t flush_size = 4096 * 8;
+	//! For each byte whether or not the CSV file requires quotes when containing the byte
+	unique_ptr<bool[]> requires_quotes;
 };
 
 struct ColumnInfo {
@@ -97,8 +99,8 @@ 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;
+	//! If any file is a pipe
+	bool is_pipe = false;
 	vector<ColumnInfo> column_info;
 
 	void Initialize(unique_ptr<BufferedCSVReader> &reader) {

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

@@ -182,7 +182,6 @@ typedef unique_ptr<LocalTableFunctionState> (*table_function_init_local_t)(Execu
 typedef unique_ptr<BaseStatistics> (*table_statistics_t)(ClientContext &context, const FunctionData *bind_data,
                                                          column_t column_index);
 typedef void (*table_function_t)(ClientContext &context, TableFunctionInput &data, DataChunk &output);
-
 typedef OperatorResultType (*table_in_out_function_t)(ExecutionContext &context, TableFunctionInput &data,
                                                       DataChunk &input, DataChunk &output);
 typedef OperatorFinalizeResultType (*table_in_out_function_final_t)(ExecutionContext &context, TableFunctionInput &data,

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

@@ -63,6 +63,8 @@ struct ClientConfig {
 	bool verify_serializer = false;
 	//! Enable the running of optimizers
 	bool enable_optimizer = true;
+	//! Enable caching operators
+	bool enable_caching_operators = true;
 	//! Force parallelism of small tables, used for testing
 	bool verify_parallelism = false;
 	//! Force index join independent of table cardinality, used for testing

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

@@ -84,6 +84,8 @@ struct ExtensionOption {
 struct DBConfigOptions {
 	//! Database file path. May be empty for in-memory mode
 	string database_path;
+	//! Database type. If empty, automatically extracted from `database_path`, where a `type:path` syntax is expected
+	string database_type;
 	//! Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)
 	AccessMode access_mode = AccessMode::AUTOMATIC;
 	//! Checkpoint when WAL reaches this size (default: 16MB)
@@ -149,6 +151,8 @@ struct DBConfigOptions {
 	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
 	//! The set of unrecognized (other) options
 	unordered_map<string, Value> unrecognized_options;
+	//! Whether to print bindings when printing the plan (debug mode only)
+	static bool debug_print_bindings;
 
 	bool operator==(const DBConfigOptions &other) const;
 };

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

@@ -54,13 +54,11 @@ public:
 
 	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
 
-	//! Get the database extension type from a given path
-	string ExtractDatabaseType(string &path);
 	unique_ptr<AttachedDatabase> CreateAttachedDatabase(AttachInfo &info, const string &type, AccessMode access_mode);
 
 private:
 	void Initialize(const char *path, DBConfig *config);
-	void CreateDatabase(const string &database_type);
+	void CreateMainDatabase();
 
 	void Configure(DBConfig &config);
 

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

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/database_path_and_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <string>
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+struct DBPathAndType {
+
+	//! Parse database extension type and rest of path from combined form (type:path)
+	static DBPathAndType Parse(const string &combined_path, const DBConfig &config);
+
+	const string path;
+	const string type;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/relation/setop_relation.hpp

@@ -20,6 +20,7 @@ public:
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	SetOperationType setop_type;
+	vector<ColumnDefinition> columns;
 
 public:
 	unique_ptr<QueryNode> GetQueryNode() override;

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

@@ -41,7 +41,7 @@ public:
 
 	void CompleteDependency();
 
-	void SetTasks(vector<unique_ptr<Task>> tasks);
+	void SetTasks(vector<shared_ptr<Task>> tasks);
 
 	void InsertEvent(shared_ptr<Event> replacement_event);
 

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

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// src/include/duckdb/parallel/interrupt.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/parallel/task.hpp"
+#include <condition_variable>
+#include <memory>
+
+namespace duckdb {
+
+//! InterruptMode specifies how operators should block/unblock, note that this will happen transparently to the
+//! operator, as the operator only needs to return a BLOCKED result and call the callback using the InterruptState.
+//! NO_INTERRUPTS: No blocking mode is specified, an error will be thrown when the operator blocks. Should only be used
+//!                when manually calling operators of which is known they will never block.
+//! TASK:          A weak pointer to a task is provided. On the callback, this task will be signalled. If the Task has
+//!                been deleted, this callback becomes a NOP. This is the preferred way to await blocked pipelines.
+//! BLOCKING:	   The caller has blocked awaiting some synchronization primitive to wait for the callback.
+enum class InterruptMode : uint8_t { NO_INTERRUPTS, TASK, BLOCKING };
+
+//! Synchronization primitive used to await a callback in InterruptMode::BLOCKING.
+struct InterruptDoneSignalState {
+	//! Called by the callback to signal the interrupt is over
+	void Signal();
+	//! Await the callback signalling the interrupt is over
+	void Await();
+
+protected:
+	mutex lock;
+	std::condition_variable cv;
+	bool done = false;
+};
+
+//! State required to make the callback after some asynchronous operation within an operator source / sink.
+class InterruptState {
+public:
+	//! Default interrupt state will be set to InterruptMode::NO_INTERRUPTS and throw an error on use of Callback()
+	InterruptState();
+	//! Register the task to be interrupted and set mode to InterruptMode::TASK, the preferred way to handle interrupts
+	InterruptState(weak_ptr<Task> task);
+	//! Register signal state and set mode to InterruptMode::BLOCKING, used for code paths without Task.
+	InterruptState(weak_ptr<InterruptDoneSignalState> done_signal);
+
+	//! Perform the callback to indicate the Interrupt is over
+	DUCKDB_API void Callback() const;
+
+protected:
+	//! Current interrupt mode
+	InterruptMode mode;
+	//! Task ptr for InterruptMode::TASK
+	weak_ptr<Task> current_task;
+	//! Signal state for InterruptMode::BLOCKING
+	weak_ptr<InterruptDoneSignalState> signal_state;
+};
+
+} // namespace duckdb

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

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/set.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
@@ -64,9 +66,7 @@ public:
 	void Reset();
 	void ResetSink();
 	void ResetSource(bool force);
-	void ClearSource() {
-		source_state.reset();
-	}
+	void ClearSource();
 	void Schedule(shared_ptr<Event> &event);
 
 	//! Finalize this pipeline
@@ -94,6 +94,12 @@ public:
 	//! Returns whether any of the operators in the pipeline care about preserving order
 	bool IsOrderDependent() const;
 
+	//! Registers a new batch index for a pipeline executor - returns the current minimum batch index
+	idx_t RegisterNewBatchIndex();
+
+	//! Updates the batch index of a pipeline (and returns the new minimum batch index)
+	idx_t UpdateBatchIndex(idx_t old_index, idx_t new_index);
+
 private:
 	//! Whether or not the pipeline has been readied
 	bool ready;
@@ -116,6 +122,13 @@ private:
 
 	//! The base batch index of this pipeline
 	idx_t base_batch_index = 0;
+	//! Lock for accessing the set of batch indexes
+	mutex batch_lock;
+	//! The set of batch indexes that are currently being processed
+	//! Despite batch indexes being unique - this is a multiset
+	//! The reason is that when we start a new pipeline we insert the current minimum batch index as a placeholder
+	//! Which leads to duplicate entries in the set of active batch indexes
+	multiset<idx_t> batch_indexes;
 
 private:
 	void ScheduleSequentialTask(shared_ptr<Event> &event);

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/parallel/thread_context.hpp"
@@ -20,16 +21,27 @@
 namespace duckdb {
 class Executor;
 
+//! The result of executing a PipelineExecutor
+enum class PipelineExecuteResult {
+	//! PipelineExecutor is fully executed: the source is completely exhausted
+	FINISHED,
+	//! PipelineExecutor is not yet fully executed and can be called again immediately
+	NOT_FINISHED,
+	//! The PipelineExecutor was interrupted and should not be called again until the interrupt is handled as specified
+	//! in the InterruptMode
+	INTERRUPTED
+};
+
 //! The Pipeline class represents an execution pipeline
 class PipelineExecutor {
 public:
 	PipelineExecutor(ClientContext &context, Pipeline &pipeline);
 
 	//! Fully execute a pipeline with a source and a sink until the source is completely exhausted
-	void Execute();
-	//! Execute a pipeline with a source and a sink until finished, or until max_chunks have been processed
+	PipelineExecuteResult Execute();
+	//! Execute a pipeline with a source and a sink until finished, or until max_chunks were processed from the source
 	//! Returns true if execution is finished, false if Execute should be called again
-	bool Execute(idx_t max_chunks);
+	PipelineExecuteResult Execute(idx_t max_chunks);
 
 	//! Push a single input DataChunk into the pipeline.
 	//! Returns either OperatorResultType::NEED_MORE_INPUT or OperatorResultType::FINISHED
@@ -48,6 +60,9 @@ public:
 	//! This flushes profiler states
 	void PullFinalize();
 
+	//! Registers the task in the interrupt_state to allow Source/Sink operators to block the task
+	void SetTaskForInterrupts(weak_ptr<Task> current_task);
+
 private:
 	//! The pipeline to process
 	Pipeline &pipeline;
@@ -65,6 +80,8 @@ private:
 	unique_ptr<LocalSourceState> local_source_state;
 	//! The local sink state (if any)
 	unique_ptr<LocalSinkState> local_sink_state;
+	//! The interrupt state, holding required information for sink/source operators to block
+	InterruptState interrupt_state;
 
 	//! The final chunk used for moving data into the sink
 	DataChunk final_chunk;
@@ -79,28 +96,55 @@ private:
 	//! Whether or not this pipeline requires keeping track of the batch index of the source
 	bool requires_batch_index = false;
 
+	//! Source has indicated it is exhausted
+	bool exhausted_source = false;
+	//! Flushing of intermediate operators has started
+	bool started_flushing = false;
+	//! Flushing of caching operators is done
+	bool done_flushing = false;
+
+	//! This flag is set when the pipeline gets interrupted by the Sink -> the final_chunk should be re-sink-ed.
+	bool remaining_sink_chunk = false;
+
+	//! Current operator being flushed
+	idx_t flushing_idx;
+	//! Whether the current flushing_idx should be flushed: this needs to be stored to make flushing code re-entrant
+	bool should_flush_current_idx = true;
+
 private:
 	void StartOperator(PhysicalOperator &op);
 	void EndOperator(PhysicalOperator &op, optional_ptr<DataChunk> chunk);
 
 	//! Reset the operator index to the first operator
 	void GoToSource(idx_t &current_idx, idx_t initial_idx);
-	void FetchFromSource(DataChunk &result);
+	SourceResultType FetchFromSource(DataChunk &result);
 
 	void FinishProcessing(int32_t operator_idx = -1);
 	bool IsFinished();
 
+	//! Wrappers for sink/source calls to respective operators
+	SourceResultType GetData(DataChunk &chunk, OperatorSourceInput &input);
+	SinkResultType Sink(DataChunk &chunk, OperatorSinkInput &input);
+
 	OperatorResultType ExecutePushInternal(DataChunk &input, idx_t initial_idx = 0);
 	//! Pushes a chunk through the pipeline and returns a single result chunk
 	//! Returns whether or not a new input chunk is needed, or whether or not we are finished
 	OperatorResultType Execute(DataChunk &input, DataChunk &result, idx_t initial_index = 0);
 
-	//! FlushCachedOperators methods push/pull any remaining cached results through the pipeline
-	void FlushCachingOperatorsPull(DataChunk &result);
-	void FlushCachingOperatorsPush();
+	//! Tries to flush all state from intermediate operators. Will return true if all state is flushed, false in the
+	//! case of a blocked sink.
+	bool TryFlushCachingOperators();
 
 	static bool CanCacheType(const LogicalType &type);
 	void CacheChunk(DataChunk &input, idx_t operator_idx);
+
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+	//! Debugging state: number of times blocked
+	int debug_blocked_sink_count = 0;
+	int debug_blocked_source_count = 0;
+	//! Number of times the Sink/Source will block before actually returning data
+	int debug_blocked_target_count = 1;
+#endif
 };
 
 } // namespace duckdb

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

@@ -13,13 +13,16 @@
 namespace duckdb {
 class ClientContext;
 class Executor;
+class Task;
+class DatabaseInstance;
+struct ProducerToken;
 
 enum class TaskExecutionMode : uint8_t { PROCESS_ALL, PROCESS_PARTIAL };
 
-enum class TaskExecutionResult : uint8_t { TASK_FINISHED, TASK_NOT_FINISHED, TASK_ERROR };
+enum class TaskExecutionResult : uint8_t { TASK_FINISHED, TASK_NOT_FINISHED, TASK_ERROR, TASK_BLOCKED };
 
 //! Generic parallel task
-class Task {
+class Task : public std::enable_shared_from_this<Task> {
 public:
 	virtual ~Task() {
 	}
@@ -28,7 +31,20 @@ public:
 	//! If mode is PROCESS_ALL, Execute should always finish processing and return TASK_FINISHED
 	//! If mode is PROCESS_PARTIAL, Execute can return TASK_NOT_FINISHED, in which case Execute will be called again
 	//! In case of an error, TASK_ERROR is returned
+	//! In case the task has interrupted, BLOCKED is returned.
 	virtual TaskExecutionResult Execute(TaskExecutionMode mode) = 0;
+
+	//! Descheduling a task ensures the task is not executed, but remains available for rescheduling as long as
+	//! required, generally until some code in an operator calls the InterruptState::Callback() method of a state of the
+	//! InterruptMode::TASK mode.
+	virtual void Deschedule() {
+		throw InternalException("Cannot deschedule task of base Task class");
+	};
+
+	//! Ensures a task is rescheduled to the correct queue
+	virtual void Reschedule() {
+		throw InternalException("Cannot reschedule task of base Task class");
+	}
 };
 
 //! Execute a task within an executor, including exception handling
@@ -39,6 +55,9 @@ public:
 	ExecutorTask(ClientContext &context);
 	virtual ~ExecutorTask();
 
+	void Deschedule() override;
+	void Reschedule() override;
+
 	Executor &executor;
 
 public:

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

@@ -18,7 +18,7 @@ public:
 	    : scheduler(scheduler_p), token(scheduler_p.CreateProducer()), task_count(0), tasks_completed(0) {
 	}
 
-	virtual void AddTask(unique_ptr<Task> task) {
+	virtual void AddTask(shared_ptr<Task> task) {
 		++task_count;
 		scheduler.ScheduleTask(*token, std::move(task));
 	}
@@ -29,7 +29,7 @@ public:
 
 	virtual void Finish() {
 		while (tasks_completed < task_count) {
-			unique_ptr<Task> task;
+			shared_ptr<Task> task;
 			if (scheduler.GetTaskFromProducer(*token, task)) {
 				task->Execute();
 				task.reset();

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

@@ -47,9 +47,9 @@ public:
 
 	unique_ptr<ProducerToken> CreateProducer();
 	//! Schedule a task to be executed by the task scheduler
-	void ScheduleTask(ProducerToken &producer, unique_ptr<Task> task);
+	void ScheduleTask(ProducerToken &producer, shared_ptr<Task> task);
 	//! Fetches a task from a specific producer, returns true if successful or false if no tasks were available
-	bool GetTaskFromProducer(ProducerToken &token, unique_ptr<Task> &task);
+	bool GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task);
 	//! Run tasks forever until "marker" is set to false, "marker" must remain valid until the thread is joined
 	void ExecuteForever(atomic<bool> *marker);
 	//! Run tasks until `marker` is set to false, `max_tasks` have been completed, or until there are no more tasks

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

@@ -17,6 +17,7 @@ namespace duckdb {
 
 enum class SampleMethod : uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RESERVOIR_SAMPLE = 2 };
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 string SampleMethodToString(SampleMethod method);
 
 struct SampleOptions {

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

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/to_string.hpp"
+
 #include <functional>
 
 namespace duckdb {
@@ -23,6 +25,10 @@ struct ColumnBinding {
 	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
 	}
 
+	string ToString() const {
+		return "#[" + to_string(table_index) + "." + to_string(column_index) + "]";
+	}
+
 	bool operator==(const ColumnBinding &rhs) const {
 		return table_index == rhs.table_index && column_index == rhs.column_index;
 	}

package/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp

@@ -42,6 +42,7 @@ public:
 	}
 
 	string ToString() const override;
+	string GetName() const override;
 
 	bool Equals(const BaseExpression *other) const override;
 	hash_t Hash() const override;

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

@@ -59,6 +59,8 @@ protected:
 
 	idx_t TryBindGroup(ParsedExpression &expr, idx_t depth);
 	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
+
+	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
 };
 
 } // namespace duckdb

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

@@ -101,6 +101,8 @@ public:
 	static bool ContainsType(const LogicalType &type, LogicalTypeId target);
 	static LogicalType ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type);
 
+	virtual bool QualifyColumnAlias(const ColumnRefExpression &colref);
+
 	//! 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,

package/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp

@@ -35,7 +35,7 @@ public:
 	//! The set of grouping sets (optional).
 	vector<GroupingSet> grouping_sets;
 	//! The list of grouping function calls (optional)
-	vector<vector<idx_t>> grouping_functions;
+	vector<unsafe_vector<idx_t>> grouping_functions;
 	//! Group statistics (optional)
 	vector<unique_ptr<BaseStatistics>> group_stats;
 
@@ -47,6 +47,7 @@ public:
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp

@@ -34,6 +34,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp

@@ -41,6 +41,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp

@@ -29,6 +29,7 @@ public:
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp

@@ -36,6 +36,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp

@@ -35,6 +35,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp

@@ -41,6 +41,7 @@ public:
 		return expressions.size();
 	}
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp

@@ -69,5 +69,6 @@ protected:
 
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp

@@ -29,6 +29,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp

@@ -27,6 +27,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;