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

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

@@ -88,6 +88,7 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
+	unique_ptr<PhysicalOperator> CreatePlan(LogicalPivot &op);
 
 	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
 	                                                         vector<unique_ptr<Expression>> &expressions,

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

@@ -29,6 +29,17 @@ struct BoundCastData {
 	DUCKDB_API virtual ~BoundCastData();
 
 	DUCKDB_API virtual unique_ptr<BoundCastData> Copy() const = 0;
+
+	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;
+	}
 };
 
 struct CastParameters {

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

@@ -22,11 +22,33 @@ class ExecutionContext;
 struct LocalFunctionData {
 	virtual ~LocalFunctionData() {
 	}
+
+	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;
+	}
 };
 
 struct GlobalFunctionData {
 	virtual ~GlobalFunctionData() {
 	}
+
+	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;
+	}
 };
 
 typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);

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

@@ -45,6 +45,22 @@ struct FunctionData {
 	DUCKDB_API virtual unique_ptr<FunctionData> Copy() const = 0;
 	DUCKDB_API virtual bool Equals(const FunctionData &other) const = 0;
 	DUCKDB_API static bool Equals(const FunctionData *left, const FunctionData *right);
+
+	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;
+	}
+	// FIXME: this function should be removed in the future
+	template <class TARGET>
+	TARGET &CastNoConst() const {
+		return (TARGET &)*this;
+	}
 };
 
 struct TableFunctionData : public FunctionData {
@@ -107,7 +123,7 @@ public:
 	LogicalType varargs;
 
 public:
-	DUCKDB_API virtual string ToString();
+	DUCKDB_API virtual string ToString() const;
 
 	DUCKDB_API bool HasVarArgs() const;
 };
@@ -122,8 +138,8 @@ public:
 	named_parameter_type_map_t named_parameters;
 
 public:
-	DUCKDB_API string ToString() override;
-	DUCKDB_API bool HasNamedParameters();
+	DUCKDB_API string ToString() const override;
+	DUCKDB_API bool HasNamedParameters() const;
 };
 
 class BaseScalarFunction : public SimpleFunction {
@@ -145,7 +161,7 @@ public:
 public:
 	DUCKDB_API hash_t Hash() const;
 
-	DUCKDB_API string ToString() override;
+	DUCKDB_API string ToString() const override;
 };
 
 } // namespace duckdb

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

@@ -34,16 +34,16 @@ public:
 	virtual ~MacroFunction() {
 	}
 
-	void CopyProperties(MacroFunction &other);
+	void CopyProperties(MacroFunction &other) const;
 
-	virtual unique_ptr<MacroFunction> Copy() = 0;
+	virtual unique_ptr<MacroFunction> Copy() const = 0;
 
 	static string ValidateArguments(MacroFunction &macro_function, const string &name,
 	                                FunctionExpression &function_expr,
 	                                vector<unique_ptr<ParsedExpression>> &positionals,
 	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 
-	virtual string ToSQL(const string &schema, const string &name);
+	virtual string ToSQL(const string &schema, const string &name) const;
 };
 
 } // namespace duckdb

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

@@ -40,7 +40,7 @@ public:
 	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_query_t query);
 	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_function_t function);
 
-	DUCKDB_API string ToString() override;
+	DUCKDB_API string ToString() const override;
 
 public:
 	PragmaType type;

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -83,7 +83,7 @@ struct VariableReturnBindData : public FunctionData {
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto &info = (VariableReturnBindData &)*bind_data_p;
+		auto &info = bind_data_p->Cast<VariableReturnBindData>();
 		writer.WriteSerializable(info.stype);
 	}
 

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

@@ -20,6 +20,17 @@ namespace duckdb {
 
 struct FunctionLocalState {
 	DUCKDB_API virtual ~FunctionLocalState();
+
+	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 Binder;

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

@@ -27,9 +27,9 @@ public:
 	unique_ptr<ParsedExpression> expression;
 
 public:
-	unique_ptr<MacroFunction> Copy() override;
+	unique_ptr<MacroFunction> Copy() const override;
 
-	string ToSQL(const string &schema, const string &name) override;
+	string ToSQL(const string &schema, const string &name) const override;
 };
 
 } // namespace duckdb

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

@@ -39,10 +39,32 @@ public:
 	DUCKDB_API virtual idx_t MaxThreads() const {
 		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;
+	}
 };
 
 struct LocalTableFunctionState {
 	DUCKDB_API virtual ~LocalTableFunctionState();
+
+	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;
+	}
 };
 
 struct TableFunctionBindInput {

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

@@ -20,16 +20,16 @@ namespace duckdb {
 
 class TableMacroFunction : public MacroFunction {
 public:
-	TableMacroFunction(unique_ptr<QueryNode> query_node);
+	explicit TableMacroFunction(unique_ptr<QueryNode> query_node);
 	TableMacroFunction(void);
 
 	//! The main query node
 	unique_ptr<QueryNode> query_node;
 
 public:
-	unique_ptr<MacroFunction> Copy() override;
+	unique_ptr<MacroFunction> Copy() const override;
 
-	string ToSQL(const string &schema, const string &name) override;
+	string ToSQL(const string &schema, const string &name) const override;
 };
 
 } // namespace duckdb

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

@@ -87,6 +87,9 @@ struct ClientConfig {
 	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
 	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
 
+	//! The maximum amount of pivot columns
+	idx_t pivot_limit = 100000;
+
 	//! Generic options
 	case_insensitive_map_t<Value> set_variables;
 
@@ -98,8 +101,6 @@ public:
 	static ClientConfig &GetConfig(ClientContext &context);
 	static const ClientConfig &GetConfig(const ClientContext &context);
 
-	static string ExtractTimezoneFromConfig(ClientConfig &config);
-
 	string ExtractTimezone() const;
 
 	bool AnyVerification() {

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

@@ -328,6 +328,16 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PivotLimitSetting {
+	static constexpr const char *Name = "pivot_limit";
+	static constexpr const char *Description =
+	    "The maximum numer of pivot columns in a pivot statement (default: 100000)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct PreserveIdentifierCase {
 	static constexpr const char *Name = "preserve_identifier_case";
 	static constexpr const char *Description =

package/src/duckdb/src/include/duckdb/optimizer/rule/like_optimizations.hpp

@@ -21,7 +21,7 @@ public:
 	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
+	unique_ptr<Expression> ApplyRule(BoundFunctionExpression &expr, ScalarFunction function, string pattern,
 	                                 bool is_not_like);
 };
 

package/src/duckdb/src/include/duckdb/parser/base_expression.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/exception.hpp"
 
 namespace duckdb {
 
@@ -86,6 +87,23 @@ public:
 	}
 
 	virtual void Verify() const;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (expression_class != TARGET::TYPE) {
+			throw InternalException("Failed to cast expression to type - expression type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (expression_class != TARGET::TYPE) {
+			throw InternalException("Failed to cast expression to type - expression type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraint.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/exception.hpp"
 
 namespace duckdb {
 
@@ -66,5 +67,22 @@ public:
 	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a Constraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp

@@ -17,6 +17,9 @@ namespace duckdb {
 //! The CheckConstraint contains an expression that must evaluate to TRUE for
 //! every row in a table
 class CheckConstraint : public Constraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::CHECK;
+
 public:
 	DUCKDB_API explicit CheckConstraint(unique_ptr<ParsedExpression> expression);
 

package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class ForeignKeyConstraint : public Constraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::FOREIGN_KEY;
+
 public:
 	DUCKDB_API ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info);
 

package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class NotNullConstraint : public Constraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::NOT_NULL;
+
 public:
 	DUCKDB_API explicit NotNullConstraint(LogicalIndex index);
 	DUCKDB_API ~NotNullConstraint() override;

package/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class UniqueConstraint : public Constraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::UNIQUE;
+
 public:
 	DUCKDB_API UniqueConstraint(LogicalIndex index, bool is_primary_key);
 	DUCKDB_API UniqueConstraint(vector<string> columns, bool is_primary_key);

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BetweenExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BETWEEN;
+
 public:
 	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
 	                             unique_ptr<ParsedExpression> upper);

package/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp

@@ -19,6 +19,9 @@ namespace duckdb {
 //! It represents a successfully bound expression. It is used in the Binder to prevent re-binding of already bound parts
 //! when dealing with subqueries.
 class BoundExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_EXPRESSION;
+
 public:
 	BoundExpression(unique_ptr<Expression> expr);
 

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -23,6 +23,9 @@ struct CaseCheck {
 
 //! The CaseExpression represents a CASE expression in the query
 class CaseExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::CASE;
+
 public:
 	DUCKDB_API CaseExpression();
 

package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! CastExpression represents a type cast from one SQL type to another SQL type
 class CastExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::CAST;
+
 public:
 	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
 

package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! CollateExpression represents a COLLATE statement
 class CollateExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::COLLATE;
+
 public:
 	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
 

package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 //! Represents a reference to a column from either the FROM clause or from an
 //! alias
 class ColumnRefExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::COLUMN_REF;
+
 public:
 	//! Specify both the column and table name
 	ColumnRefExpression(string column_name, string table_name);

package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp

@@ -14,6 +14,9 @@ namespace duckdb {
 //! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
 //! and has two children.
 class ComparisonExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::COMPARISON;
+
 public:
 	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
 	                                unique_ptr<ParsedExpression> right);

package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Represents a conjunction (AND/OR)
 class ConjunctionExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::CONJUNCTION;
+
 public:
 	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
 	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);

package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! ConstantExpression represents a constant value in the query
 class ConstantExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::CONSTANT;
+
 public:
 	DUCKDB_API explicit ConstantExpression(Value val);
 

package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp

@@ -13,6 +13,9 @@
 namespace duckdb {
 //! Represents the default value of a column
 class DefaultExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::DEFAULT;
+
 public:
 	DefaultExpression();
 

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -15,6 +15,9 @@
 namespace duckdb {
 //! Represents a function call
 class FunctionExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::FUNCTION;
+
 public:
 	DUCKDB_API FunctionExpression(string catalog_name, string schema_name, const string &function_name,
 	                              vector<unique_ptr<ParsedExpression>> children,

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -18,6 +18,9 @@ namespace duckdb {
 //!  2. An OperatorExpression with the "->" operator
 //! Lambda expressions are written in the form of "params -> expr", e.g. "x -> x + 1"
 class LambdaExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::LAMBDA;
+
 public:
 	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr);
 

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -16,6 +16,9 @@
 namespace duckdb {
 //! Represents a built-in operator expression
 class OperatorExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::OPERATOR;
+
 public:
 	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
 	                                       unique_ptr<ParsedExpression> right = nullptr);

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -12,6 +12,9 @@
 
 namespace duckdb {
 class ParameterExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::PARAMETER;
+
 public:
 	ParameterExpression();
 

package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp

@@ -12,6 +12,9 @@
 
 namespace duckdb {
 class PositionalReferenceExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::POSITIONAL_REFERENCE;
+
 public:
 	DUCKDB_API PositionalReferenceExpression(idx_t index);
 

package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Represents a * expression in the SELECT clause
 class StarExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::STAR;
+
 public:
 	StarExpression(string relation_name = string());
 

package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! Represents a subquery
 class SubqueryExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::SUBQUERY;
+
 public:
 	SubqueryExpression();
 

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -30,6 +30,9 @@ const char *ToString(WindowBoundary value);
 //! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
 //! they inherit from them.
 class WindowExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::WINDOW;
+
 public:
 	WindowExpression(ExpressionType type, string catalog_name, string schema_name, const string &function_name);
 

package/src/duckdb/src/include/duckdb/parser/query_node/list.hpp

@@ -0,0 +1,3 @@
+#include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/set_operation_node.hpp"

package/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class RecursiveCTENode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::RECURSIVE_CTE_NODE;
+
 public:
 	RecursiveCTENode() : QueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
 	}

package/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp

@@ -20,6 +20,9 @@ namespace duckdb {
 
 //! SelectNode represents a standard SELECT statement
 class SelectNode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::SELECT_NODE;
+
 public:
 	DUCKDB_API SelectNode();
 

package/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp

@@ -16,6 +16,9 @@
 namespace duckdb {
 
 class SetOperationNode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::SET_OPERATION_NODE;
+
 public:
 	SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) {
 	}