duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

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

@@ -18,6 +18,9 @@ class MergeJoinGlobalState;
 //! PhysicalPiecewiseMergeJoin represents a piecewise merge loop join between
 //! two tables
 class PhysicalPiecewiseMergeJoin : public PhysicalRangeJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PIECEWISE_MERGE_JOIN;
+
 public:
 	PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
 	                           unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalPositionalJoin represents a cross product between two tables
 class PhysicalPositionalJoin : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::POSITIONAL_JOIN;
+
 public:
 	PhysicalPositionalJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
 	                       unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp

@@ -19,6 +19,9 @@ class OrderGlobalSinkState;
 
 //! Physically re-orders the input data
 class PhysicalOrder : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ORDER_BY;
+
 public:
 	PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode> orders, vector<idx_t> projections,
 	              idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp

@@ -17,6 +17,9 @@ namespace duckdb {
 //! Represents a physical ordering of the data. Note that this will not change
 //! the data but only add a selection vector.
 class PhysicalTopN : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TOP_N;
+
 public:
 	PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t limit, idx_t offset,
 	             idx_t estimated_cardinality);

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class PhysicalBatchInsert : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_INSERT;
+
 public:
 	//! INSERT INTO
 	PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry *table,

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

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! Copy the contents of a query into a table
 class PhysicalCopyToFile : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::COPY_TO_FILE;
+
 public:
 	PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
 	                   idx_t estimated_cardinality);

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

@@ -15,6 +15,9 @@ class DataTable;
 
 //! Physically delete data from a table
 class PhysicalDelete : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DELETE_OPERATOR;
+
 public:
 	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
 	               idx_t estimated_cardinality, bool return_chunk)

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

@@ -18,6 +18,9 @@
 namespace duckdb {
 //! Parse a file from disk using a specified copy function and return the set of chunks retrieved from the file
 class PhysicalExport : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPORT;
+
 public:
 	PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
 	               idx_t estimated_cardinality, BoundExportData exported_tables)

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

@@ -20,6 +20,9 @@ class InsertLocalState;
 
 //! Physically insert a set of data into a table
 class PhysicalInsert : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INSERT;
+
 public:
 	//! INSERT INTO
 	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry *table, physical_index_vector_t<idx_t> column_index_map,

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

@@ -16,6 +16,9 @@ class DataTable;
 
 //! Physically update data in a table
 class PhysicalUpdate : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UPDATE;
+
 public:
 	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
 	               vector<PhysicalIndex> columns, vector<unique_ptr<Expression>> expressions,

package/src/duckdb/src/include/duckdb/execution/operator/projection/physical_pivot.hpp

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/projection/physical_pivot.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/planner/expression.hpp"
+#include "duckdb/common/string_map_set.hpp"
+#include "duckdb/planner/tableref/bound_pivotref.hpp"
+
+namespace duckdb {
+
+//! PhysicalPivot implements the physical PIVOT operation
+class PhysicalPivot : public PhysicalOperator {
+public:
+	PhysicalPivot(vector<LogicalType> types, unique_ptr<PhysicalOperator> child, BoundPivotInfo bound_pivot);
+
+	BoundPivotInfo bound_pivot;
+	//! The map for pivot value -> column index
+	string_map_t<idx_t> pivot_map;
+	//! The empty aggregate values
+	vector<Value> empty_aggregates;
+
+public:
+	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                           GlobalOperatorState &gstate, OperatorState &state) const override;
+
+	bool ParallelOperator() const override {
+		return true;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/projection/physical_projection.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class PhysicalProjection : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PROJECTION;
+
 public:
 	PhysicalProjection(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
 	                   idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/operator/projection/physical_unnest.hpp
+// duckdb/execution/operator/projection/physical_tableinout_function.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -14,8 +14,10 @@
 
 namespace duckdb {
 
-//! PhysicalWindow implements window functions
 class PhysicalTableInOutFunction : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INOUT_FUNCTION;
+
 public:
 	PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
 	                           unique_ptr<FunctionData> bind_data_p, vector<column_t> column_ids_p,

package/src/duckdb/src/include/duckdb/execution/operator/projection/physical_unnest.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/planner/expression.hpp"
 
@@ -16,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalUnnest implements the physical UNNEST operation
 class PhysicalUnnest : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNNEST;
+
 public:
 	PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
 	               PhysicalOperatorType type = PhysicalOperatorType::UNNEST);

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! The PhysicalColumnDataScan scans a ColumnDataCollection
 class PhysicalColumnDataScan : public PhysicalOperator {
+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) {

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class PhysicalDummyScan : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DUMMY_SCAN;
+
 public:
 	explicit PhysicalDummyScan(vector<LogicalType> types, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::DUMMY_SCAN, std::move(types), estimated_cardinality) {

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class PhysicalEmptyResult : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EMPTY_RESULT;
+
 public:
 	explicit PhysicalEmptyResult(vector<LogicalType> types, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::EMPTY_RESULT, std::move(types), estimated_cardinality) {

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

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! The PhysicalExpressionScan scans a set of expressions
 class PhysicalExpressionScan : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPRESSION_SCAN;
+
 public:
 	PhysicalExpressionScan(vector<LogicalType> types, vector<vector<unique_ptr<Expression>>> expressions,
 	                       idx_t estimated_cardinality)

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

@@ -17,6 +17,9 @@ namespace duckdb {
 
 //! Represents a scan of a base table
 class PhysicalPositionalScan : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::POSITIONAL_SCAN;
+
 public:
 	//! Regular Table Scan
 	PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,

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

@@ -17,6 +17,9 @@ namespace duckdb {
 
 //! Represents a scan of a base table
 class PhysicalTableScan : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TABLE_SCAN;
+
 public:
 	//! Regular Table Scan
 	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_alter.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalAlter represents an ALTER TABLE command
 class PhysicalAlter : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ALTER;
+
 public:
 	explicit PhysicalAlter(unique_ptr<AlterInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::ALTER, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalLoad represents an extension LOAD operation
 class PhysicalAttach : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ATTACH;
+
 public:
 	explicit PhysicalAttach(unique_ptr<AttachInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::ATTACH, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_function.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCreateFunction represents a CREATE FUNCTION command
 class PhysicalCreateFunction : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_MACRO;
+
 public:
 	explicit PhysicalCreateFunction(unique_ptr<CreateMacroInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_MACRO, {LogicalType::BIGINT}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_index.hpp

@@ -21,6 +21,9 @@ class DuckTableEntry;
 
 //! Physical CREATE (UNIQUE) INDEX statement
 class PhysicalCreateIndex : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_INDEX;
+
 public:
 	PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table, const vector<column_t> &column_ids,
 	                    unique_ptr<CreateIndexInfo> info, vector<unique_ptr<Expression>> unbound_expressions,

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_schema.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCreateSchema represents a CREATE SCHEMA command
 class PhysicalCreateSchema : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SCHEMA;
+
 public:
 	explicit PhysicalCreateSchema(unique_ptr<CreateSchemaInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_SCHEMA, {LogicalType::BIGINT}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCreateSequence represents a CREATE SEQUENCE command
 class PhysicalCreateSequence : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SEQUENCE;
+
 public:
 	explicit PhysicalCreateSequence(unique_ptr<CreateSequenceInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Physically CREATE TABLE statement
 class PhysicalCreateTable : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TABLE;
+
 public:
 	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
 	                    idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCreateType represents a CREATE TYPE command
 class PhysicalCreateType : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TYPE;
+
 public:
 	explicit PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality);
 

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCreateView represents a CREATE VIEW command
 class PhysicalCreateView : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_VIEW;
+
 public:
 	explicit PhysicalCreateView(unique_ptr<CreateViewInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class PhysicalDetach : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DETACH;
+
 public:
 	explicit PhysicalDetach(unique_ptr<DetachInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::DETACH, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalDrop represents a DROP [...] command
 class PhysicalDrop : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DROP;
+
 public:
 	explicit PhysicalDrop(unique_ptr<DropInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),

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

@@ -16,6 +16,9 @@ namespace duckdb {
 class RecursiveCTEState;
 
 class PhysicalRecursiveCTE : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RECURSIVE_CTE;
+
 public:
 	PhysicalRecursiveCTE(vector<LogicalType> types, bool union_all, unique_ptr<PhysicalOperator> top,
 	                     unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality);

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

@@ -11,7 +11,11 @@
 #include "duckdb/execution/physical_operator.hpp"
 
 namespace duckdb {
+
 class PhysicalUnion : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNION;
+
 public:
 	PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
 	              idx_t estimated_cardinality);

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

@@ -15,6 +15,7 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/execution/physical_operator_states.hpp"
 
 namespace duckdb {
 class Event;
@@ -24,63 +25,6 @@ class Pipeline;
 class PipelineBuildState;
 class MetaPipeline;
 
-// LCOV_EXCL_START
-class OperatorState {
-public:
-	virtual ~OperatorState() {
-	}
-
-	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) {
-	}
-};
-
-class GlobalOperatorState {
-public:
-	virtual ~GlobalOperatorState() {
-	}
-};
-
-class GlobalSinkState {
-public:
-	GlobalSinkState() : state(SinkFinalizeType::READY) {
-	}
-	virtual ~GlobalSinkState() {
-	}
-
-	SinkFinalizeType state;
-};
-
-class LocalSinkState {
-public:
-	virtual ~LocalSinkState() {
-	}
-
-	//! The current batch index
-	//! This is only set in case RequiresBatchIndex() is true, and the source has support for it (SupportsBatchIndex())
-	//! Otherwise this is left on INVALID_INDEX
-	//! The batch index is a globally unique, increasing index that should be used to maintain insertion order
-	//! //! in conjunction with parallelism
-	idx_t batch_index = DConstants::INVALID_INDEX;
-};
-
-class GlobalSourceState {
-public:
-	virtual ~GlobalSourceState() {
-	}
-
-	virtual idx_t MaxThreads() {
-		return 1;
-	}
-};
-
-class LocalSourceState {
-public:
-	virtual ~LocalSourceState() {
-	}
-};
-
-// LCOV_EXCL_STOP
-
 //! PhysicalOperator is the base class of the physical operators present in the
 //! execution plan
 class PhysicalOperator {
@@ -224,6 +168,23 @@ public:
 	virtual bool AllOperatorsPreserveOrder() const;
 
 	virtual void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
+			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
+			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 
 //! Contains state for the CachingPhysicalOperator

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

@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/physical_operator_states.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/operator_result_type.hpp"
+#include "duckdb/common/enums/physical_operator_type.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/execution/execution_context.hpp"
+#include "duckdb/optimizer/join_order/join_node.hpp"
+
+namespace duckdb {
+class Event;
+class Executor;
+class PhysicalOperator;
+class Pipeline;
+class PipelineBuildState;
+class MetaPipeline;
+
+// LCOV_EXCL_START
+class OperatorState {
+public:
+	virtual ~OperatorState() {
+	}
+
+	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) {
+	}
+
+	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;
+	}
+};
+
+class GlobalOperatorState {
+public:
+	virtual ~GlobalOperatorState() {
+	}
+
+	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;
+	}
+};
+
+class GlobalSinkState {
+public:
+	GlobalSinkState() : state(SinkFinalizeType::READY) {
+	}
+	virtual ~GlobalSinkState() {
+	}
+
+	SinkFinalizeType state;
+
+	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;
+	}
+};
+
+class LocalSinkState {
+public:
+	virtual ~LocalSinkState() {
+	}
+
+	//! The current batch index
+	//! This is only set in case RequiresBatchIndex() is true, and the source has support for it (SupportsBatchIndex())
+	//! Otherwise this is left on INVALID_INDEX
+	//! The batch index is a globally unique, increasing index that should be used to maintain insertion order
+	//! //! in conjunction with parallelism
+	idx_t batch_index = DConstants::INVALID_INDEX;
+
+	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;
+	}
+};
+
+class GlobalSourceState {
+public:
+	virtual ~GlobalSourceState() {
+	}
+
+	virtual idx_t MaxThreads() {
+		return 1;
+	}
+
+	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;
+	}
+};
+
+class LocalSourceState {
+public:
+	virtual ~LocalSourceState() {
+	}
+
+	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;
+	}
+};
+
+// LCOV_EXCL_STOP
+
+} // namespace duckdb