npm - duckdb - Versions diffs - 0.7.2-dev1457.0 → 0.7.2-dev1533.0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (593) hide show

package/src/duckdb/src/include/duckdb/parser/query_node.hpp CHANGED Viewed

@@ -14,6 +14,7 @@
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/common_table_expression_info.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/exception.hpp"
 namespace duckdb {
@@ -87,6 +88,23 @@ protected:
 	//! Copy base QueryNode properties from another expression to this one,
 	//! used in Copy method
 	void CopyProperties(QueryNode &other) const;
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast query node to type - query node type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast query node to type - query node type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp CHANGED Viewed

@@ -47,5 +47,23 @@ public:
 	}
 	//! Create a copy of this SelectStatement
 	DUCKDB_API virtual unique_ptr<SQLStatement> Copy() const = 0;
+public:
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast statement to type - statement type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast statement to type - statement type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/statement/alter_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class AlterStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::ALTER_STATEMENT;
 public:
 	AlterStatement();

package/src/duckdb/src/include/duckdb/parser/statement/attach_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class AttachStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::ATTACH_STATEMENT;
 public:
 	AttachStatement();

package/src/duckdb/src/include/duckdb/parser/statement/call_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class CallStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::CALL_STATEMENT;
 public:
 	CallStatement();

package/src/duckdb/src/include/duckdb/parser/statement/copy_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class CopyStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::COPY_STATEMENT;
 public:
 	CopyStatement();

package/src/duckdb/src/include/duckdb/parser/statement/create_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class CreateStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::CREATE_STATEMENT;
 public:
 	CreateStatement();

package/src/duckdb/src/include/duckdb/parser/statement/delete_statement.hpp CHANGED Viewed

@@ -16,6 +16,9 @@
 namespace duckdb {
 class DeleteStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::DELETE_STATEMENT;
 public:
 	DeleteStatement();

package/src/duckdb/src/include/duckdb/parser/statement/detach_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class DetachStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::DETACH_STATEMENT;
 public:
 	DetachStatement();

package/src/duckdb/src/include/duckdb/parser/statement/drop_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class DropStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::DROP_STATEMENT;
 public:
 	DropStatement();

package/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class ExecuteStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::EXECUTE_STATEMENT;
 public:
 	ExecuteStatement();

package/src/duckdb/src/include/duckdb/parser/statement/explain_statement.hpp CHANGED Viewed

@@ -16,6 +16,9 @@ namespace duckdb {
 enum class ExplainType : uint8_t { EXPLAIN_STANDARD, EXPLAIN_ANALYZE };
 class ExplainStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::EXPLAIN_STATEMENT;
 public:
 	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD);

package/src/duckdb/src/include/duckdb/parser/statement/export_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class ExportStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::EXPORT_STATEMENT;
 public:
 	explicit ExportStatement(unique_ptr<CopyInfo> info);

package/src/duckdb/src/include/duckdb/parser/statement/extension_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class ExtensionStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::EXTENSION_STATEMENT;
 public:
 	ExtensionStatement(ParserExtension extension, unique_ptr<ParserExtensionParseData> parse_data);

package/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp CHANGED Viewed

@@ -45,6 +45,9 @@ protected:
 };
 class InsertStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::INSERT_STATEMENT;
 public:
 	InsertStatement();

package/src/duckdb/src/include/duckdb/parser/statement/list.hpp CHANGED Viewed

@@ -8,6 +8,7 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/statement/execute_statement.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
+#include "duckdb/parser/statement/extension_statement.hpp"
 #include "duckdb/parser/statement/export_statement.hpp"
 #include "duckdb/parser/statement/insert_statement.hpp"
 #include "duckdb/parser/statement/load_statement.hpp"

package/src/duckdb/src/include/duckdb/parser/statement/load_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class LoadStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::LOAD_STATEMENT;
 public:
 	LoadStatement();

package/src/duckdb/src/include/duckdb/parser/statement/logical_plan_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class LogicalPlanStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::LOGICAL_PLAN_STATEMENT;
 public:
 	explicit LogicalPlanStatement(unique_ptr<LogicalOperator> plan_p)
 	    : SQLStatement(StatementType::LOGICAL_PLAN_STATEMENT), plan(std::move(plan_p)) {};

package/src/duckdb/src/include/duckdb/parser/statement/multi_statement.hpp CHANGED Viewed

@@ -13,6 +13,9 @@
 namespace duckdb {
 class MultiStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::MULTI_STATEMENT;
 public:
 	MultiStatement();

package/src/duckdb/src/include/duckdb/parser/statement/pragma_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class PragmaStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::PRAGMA_STATEMENT;
 public:
 	PragmaStatement();

package/src/duckdb/src/include/duckdb/parser/statement/prepare_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class PrepareStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::PREPARE_STATEMENT;
 public:
 	PrepareStatement();

package/src/duckdb/src/include/duckdb/parser/statement/relation_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class RelationStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::RELATION_STATEMENT;
 public:
 	explicit RelationStatement(shared_ptr<Relation> relation);

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp CHANGED Viewed

@@ -22,6 +22,9 @@ class FormatDeserializer;
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::SELECT_STATEMENT;
 public:
 	DUCKDB_API SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
 	}

package/src/duckdb/src/include/duckdb/parser/statement/set_statement.hpp CHANGED Viewed

@@ -16,6 +16,9 @@
 namespace duckdb {
 class SetStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::SET_STATEMENT;
 protected:
 	SetStatement(std::string name_p, SetScope scope_p, SetType type_p);
 	SetStatement(const SetStatement &other) = default;

package/src/duckdb/src/include/duckdb/parser/statement/show_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class ShowStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::SHOW_STATEMENT;
 public:
 	ShowStatement();

package/src/duckdb/src/include/duckdb/parser/statement/transaction_statement.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 class TransactionStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::TRANSACTION_STATEMENT;
 public:
 	explicit TransactionStatement(TransactionType type);

package/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp CHANGED Viewed

@@ -36,6 +36,9 @@ protected:
 };
 class UpdateStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::UPDATE_STATEMENT;
 public:
 	UpdateStatement();

package/src/duckdb/src/include/duckdb/parser/statement/vacuum_statement.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class VacuumStatement : public SQLStatement {
+public:
+	static constexpr const StatementType TYPE = StatementType::VACUUM_STATEMENT;
 public:
 	explicit VacuumStatement(const VacuumOptions &options);

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 //! Represents a TableReference to a base table in the schema
 class BaseTableRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
 public:
 	BaseTableRef()
 	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(INVALID_CATALOG), schema_name(INVALID_SCHEMA) {

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp CHANGED Viewed

@@ -13,6 +13,9 @@
 namespace duckdb {
 //! Represents a cross product
 class EmptyTableRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY;
 public:
 	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
 	}

package/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp CHANGED Viewed

@@ -16,6 +16,9 @@
 namespace duckdb {
 //! Represents an expression list as generated by a VALUES statement
 class ExpressionListRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::EXPRESSION_LIST;
 public:
 	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
 	}

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp CHANGED Viewed

@@ -19,6 +19,9 @@ namespace duckdb {
 //! Represents a JOIN between two expressions
 class JoinRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::JOIN;
 public:
 	explicit JoinRef(JoinRefType ref_type)
 	    : TableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type) {

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp CHANGED Viewed

@@ -29,6 +29,11 @@ struct PivotColumnEntry {
 	static PivotColumnEntry FormatDeserialize(FormatDeserializer &source);
 };
+struct PivotValueElement {
+	vector<Value> values;
+	string name;
+};
 struct PivotColumn {
 	//! The set of expressions to pivot on
 	vector<unique_ptr<ParsedExpression>> pivot_expressions;
@@ -51,6 +56,9 @@ struct PivotColumn {
 //! Represents a PIVOT or UNPIVOT expression
 class PivotRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::PIVOT;
 public:
 	explicit PivotRef() : TableRef(TableReferenceType::PIVOT), include_nulls(false) {
 	}
@@ -69,6 +77,12 @@ public:
 	vector<string> column_name_alias;
 	//! Whether or not to include nulls in the result (UNPIVOT only)
 	bool include_nulls;
+	//! The set of values to pivot on (bound pivot only)
+	vector<PivotValueElement> bound_pivot_values;
+	//! The set of bound group names (bound pivot only)
+	vector<string> bound_group_names;
+	//! The set of bound aggregate names (bound pivot only)
+	vector<string> bound_aggregate_names;
 public:
 	string ToString() const override;

package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp CHANGED Viewed

@@ -14,6 +14,9 @@
 namespace duckdb {
 //! Represents a subquery
 class SubqueryRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
 public:
 	DUCKDB_API explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp CHANGED Viewed

@@ -17,6 +17,9 @@
 namespace duckdb {
 //! Represents a Table producing function
 class TableFunctionRef : public TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::TABLE_FUNCTION;
 public:
 	DUCKDB_API TableFunctionRef();

package/src/duckdb/src/include/duckdb/parser/tableref.hpp CHANGED Viewed

@@ -53,5 +53,22 @@ public:
 	virtual void FormatSerialize(FormatSerializer &serializer) const;
 	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &deserializer);
+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/planner/bind_context.hpp CHANGED Viewed

@@ -81,6 +81,8 @@ public:
 		return bindings_list;
 	}
+	void GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types);
 	//! Adds a base table with the given alias to the BindContext.
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
 	                  vector<column_t> &bound_column_ids, StandardEntry *entry, bool add_row_id = true);

package/src/duckdb/src/include/duckdb/planner/binder.hpp CHANGED Viewed

@@ -283,6 +283,7 @@ private:
 	unique_ptr<SelectNode> BindUnpivot(Binder &child_binder, PivotRef &expr,
 	                                   vector<unique_ptr<ParsedExpression>> all_columns,
 	                                   unique_ptr<ParsedExpression> &where_clause);
+	unique_ptr<BoundTableRef> BindBoundPivot(PivotRef &expr);
 	bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
 	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
@@ -304,6 +305,7 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundEmptyTableRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundExpressionListRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundCTERef &ref);
+	unique_ptr<LogicalOperator> CreatePlan(BoundPivotRef &ref);
 	BoundStatement BindCopyTo(CopyStatement &stmt);
 	BoundStatement BindCopyFrom(CopyStatement &stmt);

package/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp CHANGED Viewed

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/parser/constraint.hpp"
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/exception.hpp"
 namespace duckdb {
 //! Bound equivalent of Constraint
@@ -29,5 +30,22 @@ public:
 	}
 	ConstraintType type;
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast constraint to type - bound 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 - bound constraint type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/bound_query_node.hpp CHANGED Viewed

@@ -34,6 +34,23 @@ public:
 public:
 	virtual idx_t GetRootIndex() = 0;
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast bound query node to type - query node type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast bound query node to type - query node type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp CHANGED Viewed

@@ -70,11 +70,15 @@ public:
 	static bool Equals(const BoundOrderModifier *left, const BoundOrderModifier *right);
 };
+enum class DistinctType : uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };
 class BoundDistinctModifier : public BoundResultModifier {
 public:
 	BoundDistinctModifier();
-	//! list of distinct on targets (if any)
+	//! Whether or not this is a DISTINCT or DISTINCT ON
+	DistinctType distinct_type;
+	//! list of distinct on targets
 	vector<unique_ptr<Expression>> target_distincts;
 };

package/src/duckdb/src/include/duckdb/planner/bound_tableref.hpp CHANGED Viewed

@@ -25,5 +25,22 @@ public:
 	TableReferenceType type;
 	//! The sample options (if any)
 	unique_ptr<SampleOptions> sample;
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast bound table ref to type - table ref type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast bound table ref to type - table ref type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/bound_tokens.hpp CHANGED Viewed

@@ -52,5 +52,6 @@ class BoundTableFunction;
 class BoundEmptyTableRef;
 class BoundExpressionListRef;
 class BoundCTERef;
+class BoundPivotRef;
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/constraints/bound_check_constraint.hpp CHANGED Viewed

@@ -18,6 +18,9 @@ namespace duckdb {
 //! The CheckConstraint contains an expression that must evaluate to TRUE for
 //! every row in a table
 class BoundCheckConstraint : public BoundConstraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::CHECK;
 public:
 	BoundCheckConstraint() : BoundConstraint(ConstraintType::CHECK) {
 	}

package/src/duckdb/src/include/duckdb/planner/constraints/bound_foreign_key_constraint.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class BoundForeignKeyConstraint : public BoundConstraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::FOREIGN_KEY;
 public:
 	BoundForeignKeyConstraint(ForeignKeyInfo info_p, physical_index_set_t pk_key_set_p,
 	                          physical_index_set_t fk_key_set_p)

package/src/duckdb/src/include/duckdb/planner/constraints/bound_not_null_constraint.hpp CHANGED Viewed

@@ -13,6 +13,9 @@
 namespace duckdb {
 class BoundNotNullConstraint : public BoundConstraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::NOT_NULL;
 public:
 	explicit BoundNotNullConstraint(PhysicalIndex index) : BoundConstraint(ConstraintType::NOT_NULL), index(index) {
 	}

package/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp CHANGED Viewed

@@ -15,6 +15,9 @@
 namespace duckdb {
 class BoundUniqueConstraint : public BoundConstraint {
+public:
+	static constexpr const ConstraintType TYPE = ConstraintType::UNIQUE;
 public:
 	BoundUniqueConstraint(vector<LogicalIndex> keys, logical_index_set_t key_set, bool is_primary_key)
 	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys)), key_set(std::move(key_set)),

package/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp CHANGED Viewed

@@ -13,7 +13,11 @@
 #include <memory>
 namespace duckdb {
 class BoundAggregateExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_AGGREGATE;
 public:
 	BoundAggregateExpression(AggregateFunction function, vector<unique_ptr<Expression>> children,
 	                         unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info,