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

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundBetweenExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_BETWEEN;
+
 public:
 	BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower, unique_ptr<Expression> upper,
 	                       bool lower_inclusive, bool upper_inclusive);

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

@@ -21,6 +21,9 @@ struct BoundCaseCheck {
 };
 
 class BoundCaseExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CASE;
+
 public:
 	BoundCaseExpression(LogicalType type);
 	BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class BoundCastExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CAST;
+
 public:
 	BoundCastExpression(unique_ptr<Expression> child, LogicalType target_type, BoundCastInfo bound_cast,
 	                    bool try_cast = false);

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

@@ -20,6 +20,9 @@ class FieldWriter;
 //! is not yet executable, however. The ColumnBindingResolver transforms the BoundColumnRefExpressions into
 //! BoundExpressions, which refer to indexes into the physical chunks that pass through the executor.
 class BoundColumnRefExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_COLUMN_REF;
+
 public:
 	BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth = 0);
 	BoundColumnRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t depth = 0);

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundComparisonExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_COMPARISON;
+
 public:
 	BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);
 

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundConjunctionExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CONJUNCTION;
+
 public:
 	explicit BoundConjunctionExpression(ExpressionType type);
 	BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class BoundConstantExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CONSTANT;
+
 public:
 	explicit BoundConstantExpression(Value value);
 

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundDefaultExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_DEFAULT;
+
 public:
 	explicit BoundDefaultExpression(LogicalType type = LogicalType())
 	    : Expression(ExpressionType::VALUE_DEFAULT, ExpressionClass::BOUND_DEFAULT, type) {

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

@@ -16,6 +16,9 @@ class ScalarFunctionCatalogEntry;
 
 //! Represents a function call that has been bound to a base function
 class BoundFunctionExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_FUNCTION;
+
 public:
 	BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
 	                        vector<unique_ptr<Expression>> arguments, unique_ptr<FunctionData> bind_info,

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class BoundLambdaExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_LAMBDA;
+
 public:
 	BoundLambdaExpression(ExpressionType type_p, LogicalType return_type_p, unique_ptr<Expression> lambda_expr_p,
 	                      idx_t parameter_count_p);

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

@@ -21,6 +21,9 @@ class FieldWriter;
 //! BoundReferenceExpresssion, indexing the corresponding lambda parameter in the lambda bindings vector,
 //! which refers to the physical chunk of the lambda parameter during execution.
 class BoundLambdaRefExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_LAMBDA_REF;
+
 public:
 	BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index, idx_t depth = 0);
 	BoundLambdaRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t lambda_index,

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundOperatorExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_OPERATOR;
+
 public:
 	BoundOperatorExpression(ExpressionType type, LogicalType return_type);
 

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class BoundParameterExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_PARAMETER;
+
 public:
 	explicit BoundParameterExpression(idx_t parameter_nr);
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! A BoundReferenceExpression represents a physical index into a DataChunk
 class BoundReferenceExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_REF;
+
 public:
 	BoundReferenceExpression(string alias, LogicalType type, idx_t index);
 	BoundReferenceExpression(LogicalType type, storage_t index);

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

@@ -16,6 +16,9 @@
 namespace duckdb {
 
 class BoundSubqueryExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_SUBQUERY;
+
 public:
 	explicit BoundSubqueryExpression(LogicalType return_type);
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! Represents a function call that has been bound to a base function
 class BoundUnnestExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_UNNEST;
+
 public:
 	explicit BoundUnnestExpression(LogicalType return_type);
 

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

@@ -17,6 +17,9 @@ namespace duckdb {
 class AggregateFunction;
 
 class BoundWindowExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_WINDOW;
+
 public:
 	BoundWindowExpression(ExpressionType type, LogicalType return_type, unique_ptr<AggregateFunction> aggregate,
 	                      unique_ptr<FunctionData> bind_info);
@@ -57,7 +60,7 @@ public:
 
 	string ToString() const override;
 
-	bool KeysAreCompatible(const BoundWindowExpression *other) const;
+	bool KeysAreCompatible(const BoundWindowExpression &other) const;
 	bool Equals(const BaseExpression *other) const override;
 
 	unique_ptr<Expression> Copy() override;

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

@@ -18,7 +18,7 @@ public:
 	TableFunctionBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth);
+	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression);
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -130,6 +130,8 @@ protected:
 	void CaptureLambdaColumns(vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
 	                          unique_ptr<Expression> &expr);
 
+	static unique_ptr<ParsedExpression> GetSQLValueFunction(const string &column_name);
+
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
 	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);

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

@@ -89,5 +89,22 @@ public:
 protected:
 	//! Resolve types for this specific operator
 	virtual void ResolveTypes() = 0;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
+			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
+			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

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

@@ -40,6 +40,7 @@ class LogicalInsert;
 class LogicalJoin;
 class LogicalLimit;
 class LogicalOrder;
+class LogicalPivot;
 class LogicalPositionalJoin;
 class LogicalPragma;
 class LogicalPrepare;

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

@@ -26,6 +26,7 @@
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/operator/logical_pivot.hpp"
 #include "duckdb/planner/operator/logical_positional_join.hpp"
 #include "duckdb/planner/operator/logical_pragma.hpp"
 #include "duckdb/planner/operator/logical_prepare.hpp"

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

@@ -18,6 +18,9 @@ namespace duckdb {
 //! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
 //! operator.
 class LogicalAggregate : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY;
+
 public:
 	LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list);
 

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalAnyJoin represents a join with an arbitrary expression as JoinCondition
 class LogicalAnyJoin : public LogicalJoin {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ANY_JOIN;
+
 public:
 	explicit LogicalAnyJoin(JoinType type);
 

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

@@ -15,6 +15,9 @@ namespace duckdb {
 //! LogicalAsOfJoin represents a temporal-style join with one less-than inequality.
 //! This inequality matches the greatest value on the right that satisfies the condition.
 class LogicalAsOfJoin : public LogicalComparisonJoin {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ASOF_JOIN;
+
 public:
 	explicit LogicalAsOfJoin(JoinType type);
 };

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalColumnDataGet represents a scan operation from a ColumnDataCollection
 class LogicalColumnDataGet : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CHUNK_GET;
+
 public:
 	LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types, unique_ptr<ColumnDataCollection> collection);
 

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

@@ -18,6 +18,9 @@ namespace duckdb {
 
 //! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
 class LogicalComparisonJoin : public LogicalJoin {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	explicit LogicalComparisonJoin(JoinType type,
 	                               LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN);

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

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class LogicalCopyToFile : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_COPY_TO_FILE;
+
 public:
 	LogicalCopyToFile(CopyFunction function, unique_ptr<FunctionData> bind_data)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_TO_FILE), function(function),

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalCreate represents a CREATE operator
 class LogicalCreate : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema = nullptr)
 	    : LogicalOperator(type), schema(schema), info(std::move(info)) {

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

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class LogicalCreateIndex : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_INDEX;
+
 public:
 	LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
 	                   vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class LogicalCreateTable : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_TABLE;
+
 public:
 	LogicalCreateTable(SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {

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

@@ -16,6 +16,9 @@ namespace duckdb {
 class LogicalCrossProduct : public LogicalUnconditionalJoin {
 	LogicalCrossProduct() : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {};
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CROSS_PRODUCT;
+
 public:
 	LogicalCrossProduct(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
 

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalCTERef represents a reference to a recursive CTE
 class LogicalCTERef : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CTE_REF;
+
 public:
 	LogicalCTERef(idx_t table_index, idx_t cte_index, vector<LogicalType> types, vector<string> colnames)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index) {

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

@@ -14,6 +14,9 @@ namespace duckdb {
 class TableCatalogEntry;
 
 class LogicalDelete : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELETE;
+
 public:
 	explicit LogicalDelete(TableCatalogEntry *table, idx_t table_index);
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalDelimGet represents a duplicate eliminated scan belonging to a DelimJoin
 class LogicalDelimGet : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_GET;
+
 public:
 	LogicalDelimGet(idx_t table_index, vector<LogicalType> types)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELIM_GET), table_index(table_index) {

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

@@ -15,6 +15,9 @@ namespace duckdb {
 //! LogicalDelimJoin represents a special "duplicate eliminated" join. This join type is only used for subquery
 //! flattening, and involves performing duplicate elimination on the LEFT side which is then pushed into the RIGHT side.
 class LogicalDelimJoin : public LogicalComparisonJoin {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_JOIN;
+
 public:
 	explicit LogicalDelimJoin(JoinType type);
 

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

@@ -16,12 +16,20 @@ namespace duckdb {
 //! LogicalDistinct filters duplicate entries from its child operator
 class LogicalDistinct : public LogicalOperator {
 public:
-	LogicalDistinct() : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT) {
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DISTINCT;
+
+public:
+	explicit LogicalDistinct(DistinctType distinct_type)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
 	}
-	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_targets(std::move(targets)) {
+	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
+	      distinct_targets(std::move(targets)) {
 	}
-	//! The set of distinct targets (optional).
+
+	//! Whether or not this is a DISTINCT or DISTINCT ON
+	DistinctType distinct_type;
+	//! The set of distinct targets
 	vector<unique_ptr<Expression>> distinct_targets;
 	//! The order by modifier (optional, only for distinct on)
 	unique_ptr<BoundOrderModifier> order_by;

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalDummyScan represents a dummy scan returning a single row
 class LogicalDummyScan : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DUMMY_SCAN;
+
 public:
 	explicit LogicalDummyScan(idx_t table_index)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_DUMMY_SCAN), table_index(table_index) {

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

@@ -17,6 +17,9 @@ namespace duckdb {
 class LogicalEmptyResult : public LogicalOperator {
 	LogicalEmptyResult();
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EMPTY_RESULT;
+
 public:
 	explicit LogicalEmptyResult(unique_ptr<LogicalOperator> op);
 

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

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class LogicalExecute : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXECUTE;
+
 public:
 	explicit LogicalExecute(shared_ptr<PreparedStatementData> prepared_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXECUTE), prepared(std::move(prepared_p)) {

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

@@ -17,6 +17,9 @@ class LogicalExplain : public LogicalOperator {
 	LogicalExplain(ExplainType explain_type)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {};
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPLAIN;
+
 public:
 	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {

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

@@ -16,6 +16,9 @@
 namespace duckdb {
 
 class LogicalExport : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPORT;
+
 public:
 	LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info, BoundExportData exported_tables)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(function), copy_info(std::move(copy_info)),

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalExpressionGet represents a scan operation over a set of to-be-executed expressions
 class LogicalExpressionGet : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPRESSION_GET;
+
 public:
 	LogicalExpressionGet(idx_t table_index, vector<LogicalType> types,
 	                     vector<vector<unique_ptr<Expression>>> expressions)

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

@@ -14,6 +14,10 @@
 namespace duckdb {
 
 struct LogicalExtensionOperator : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR;
+
+public:
 	LogicalExtensionOperator() : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR) {
 	}
 	LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalFilter represents a filter operation (e.g. WHERE or HAVING clause)
 class LogicalFilter : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_FILTER;
+
 public:
 	explicit LogicalFilter(unique_ptr<Expression> expression);
 	LogicalFilter();

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

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! LogicalGet represents a scan operation from a data source
 class LogicalGet : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_GET;
+
 public:
 	LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
 	           vector<LogicalType> returned_types, vector<string> returned_names);

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

@@ -19,6 +19,9 @@ class Index;
 
 //! LogicalInsert represents an insertion of data into a base table
 class LogicalInsert : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INSERT;
+
 public:
 	LogicalInsert(TableCatalogEntry *table, idx_t table_index);
 

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

@@ -17,6 +17,9 @@ namespace duckdb {
 
 //! LogicalJoin represents a join between two relations
 class LogicalJoin : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	explicit LogicalJoin(JoinType type, LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_JOIN);
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalLimit represents a LIMIT clause
 class LogicalLimit : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_LIMIT;
+
 public:
 	LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit, unique_ptr<Expression> offset);
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalLimitPercent represents a LIMIT PERCENT clause
 class LogicalLimitPercent : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_LIMIT_PERCENT;
+
 public:
 	LogicalLimitPercent(double limit_percent, int64_t offset_val, unique_ptr<Expression> limit,
 	                    unique_ptr<Expression> offset)

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

@@ -17,6 +17,9 @@ namespace duckdb {
 
 //! LogicalOrder represents an ORDER BY clause, sorting the data
 class LogicalOrder : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ORDER_BY;
+
 public:
 	explicit LogicalOrder(vector<BoundOrderByNode> orders)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {

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

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_pivot.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/planner/tableref/bound_pivotref.hpp"
+
+namespace duckdb {
+
+class LogicalPivot : public LogicalOperator {
+public:
+	LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info);
+
+	idx_t pivot_index;
+	//! The bound pivot info
+	BoundPivotInfo bound_pivot;
+
+public:
+	vector<ColumnBinding> GetColumnBindings() override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	vector<idx_t> GetTableIndex() const override;
+
+protected:
+	void ResolveTypes() override;
+};
+} // namespace duckdb