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

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

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

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

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! LogicalSimple represents a simple logical operator that only passes on the parse info
 class LogicalPragma : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PRAGMA;
+
 public:
 	LogicalPragma(PragmaFunction function_p, PragmaInfo info_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), function(std::move(function_p)),

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

@@ -18,6 +18,9 @@ namespace duckdb {
 class TableCatalogEntry;
 
 class LogicalPrepare : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PREPARE;
+
 public:
 	LogicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(name), prepared(std::move(prepared)) {

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalProjection represents the projection list in a SELECT clause
 class LogicalProjection : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PROJECTION;
+
 public:
 	LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list);
 

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

@@ -13,15 +13,19 @@
 namespace duckdb {
 
 class LogicalRecursiveCTE : public LogicalOperator {
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all, LogicalOperatorType type)
-	    : LogicalOperator(type), union_all(union_all), table_index(table_index), column_count(column_count) {
+	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
+	      column_count(column_count) {
 	}
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RECURSIVE_CTE;
+
 public:
 	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all, unique_ptr<LogicalOperator> top,
-	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type)
-	    : LogicalOperator(type), union_all(union_all), table_index(table_index), column_count(column_count) {
-		D_ASSERT(type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
+	                    unique_ptr<LogicalOperator> bottom)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
+	      column_count(column_count) {
 		children.push_back(std::move(top));
 		children.push_back(std::move(bottom));
 	}

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

@@ -16,6 +16,9 @@
 namespace duckdb {
 
 class LogicalReset : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RESET;
+
 public:
 	LogicalReset(std::string name_p, SetScope scope_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_RESET), name(name_p), scope(scope_p) {

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalSample represents a SAMPLE clause
 class LogicalSample : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_SAMPLE;
+
 public:
 	LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child);
 

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

@@ -16,6 +16,9 @@
 namespace duckdb {
 
 class LogicalSet : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_SET;
+
 public:
 	LogicalSet(std::string name_p, Value value_p, SetScope scope_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_SET), name(name_p), value(value_p), scope(scope_p) {

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

@@ -17,6 +17,9 @@ class LogicalSetOperation : public LogicalOperator {
 	    : LogicalOperator(type), table_index(table_index), column_count(column_count) {
 	}
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	LogicalSetOperation(idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> top,
 	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type)

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

@@ -15,6 +15,9 @@ namespace duckdb {
 class LogicalShow : public LogicalOperator {
 	LogicalShow() : LogicalOperator(LogicalOperatorType::LOGICAL_SHOW) {};
 
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_SHOW;
+
 public:
 	explicit LogicalShow(unique_ptr<LogicalOperator> plan) : LogicalOperator(LogicalOperatorType::LOGICAL_SHOW) {
 		children.push_back(std::move(plan));

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

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! LogicalSimple represents a simple logical operator that only passes on the parse info
 class LogicalSimple : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	LogicalSimple(LogicalOperatorType type, unique_ptr<ParseInfo> info) : LogicalOperator(type), info(std::move(info)) {
 	}

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

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! LogicalTopN represents a comibination of ORDER BY and LIMIT clause, using Min/Max Heap
 class LogicalTopN : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_TOP_N;
+
 public:
 	LogicalTopN(vector<BoundOrderByNode> orders, int64_t limit, int64_t offset)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_TOP_N), orders(std::move(orders)), limit(limit), offset(offset) {

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

@@ -15,6 +15,9 @@ namespace duckdb {
 //! LogicalUnconditionalJoin represents a join between two relations
 //! where the join condition is implicit (cross product, position, etc.)
 class LogicalUnconditionalJoin : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
+
 public:
 	explicit LogicalUnconditionalJoin(LogicalOperatorType logical_type) : LogicalOperator(logical_type) {};
 

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

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! LogicalUnnest represents the logical UNNEST operator.
 class LogicalUnnest : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_UNNEST;
+
 public:
 	explicit LogicalUnnest(idx_t unnest_index)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_UNNEST), unnest_index(unnest_index) {

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

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

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

@@ -15,6 +15,9 @@ namespace duckdb {
 //! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
 //! operator.
 class LogicalWindow : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_WINDOW;
+
 public:
 	explicit LogicalWindow(idx_t window_index)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_WINDOW), window_index(window_index) {

package/src/duckdb/src/include/duckdb/planner/query_node/bound_recursive_cte_node.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Bound equivalent of SetOperationNode
 class BoundRecursiveCTENode : public BoundQueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::RECURSIVE_CTE_NODE;
+
 public:
 	BoundRecursiveCTENode() : BoundQueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
 	}

package/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp

@@ -34,6 +34,9 @@ struct BoundUnnestNode {
 
 //! Bound equivalent of SelectNode
 class BoundSelectNode : public BoundQueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::SELECT_NODE;
+
 public:
 	BoundSelectNode() : BoundQueryNode(QueryNodeType::SELECT_NODE) {
 	}

package/src/duckdb/src/include/duckdb/planner/query_node/bound_set_operation_node.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! Bound equivalent of SetOperationNode
 class BoundSetOperationNode : public BoundQueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::SET_OPERATION_NODE;
+
 public:
 	BoundSetOperationNode() : BoundQueryNode(QueryNodeType::SET_OPERATION_NODE) {
 	}

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

@@ -0,0 +1,3 @@
+#include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/planner/query_node/bound_set_operation_node.hpp"

package/src/duckdb/src/include/duckdb/planner/tableref/bound_basetableref.hpp

@@ -16,6 +16,9 @@ class TableCatalogEntry;
 
 //! Represents a TableReference to a base table in the schema
 class BoundBaseTableRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
+
 public:
 	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
 	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(std::move(get)) {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_cteref.hpp

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class BoundCTERef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::CTE;
+
 public:
 	BoundCTERef(idx_t bind_index, idx_t cte_index)
 	    : BoundTableRef(TableReferenceType::CTE), bind_index(bind_index), cte_index(cte_index) {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_dummytableref.hpp

@@ -14,6 +14,9 @@ namespace duckdb {
 
 //! Represents a cross product
 class BoundEmptyTableRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY;
+
 public:
 	explicit BoundEmptyTableRef(idx_t bind_index) : BoundTableRef(TableReferenceType::EMPTY), bind_index(bind_index) {
 	}

package/src/duckdb/src/include/duckdb/planner/tableref/bound_expressionlistref.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 //! Represents a TableReference to a base table in the schema
 class BoundExpressionListRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::EXPRESSION_LIST;
+
 public:
 	BoundExpressionListRef() : BoundTableRef(TableReferenceType::EXPRESSION_LIST) {
 	}

package/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp

@@ -18,6 +18,9 @@ namespace duckdb {
 
 //! Represents a join
 class BoundJoinRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::JOIN;
+
 public:
 	explicit BoundJoinRef(JoinRefType ref_type)
 	    : BoundTableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type), lateral(false) {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/tableref/bound_pivotref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
+#include "duckdb/planner/expression.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/function/aggregate_function.hpp"
+
+namespace duckdb {
+
+struct BoundPivotInfo {
+	//! The number of group columns
+	idx_t group_count;
+	//! The set of types
+	vector<LogicalType> types;
+	//! The set of values to pivot on
+	vector<string> pivot_values;
+	//! The set of aggregate functions that is being executed
+	vector<unique_ptr<Expression>> aggregates;
+};
+
+class BoundPivotRef : public BoundTableRef {
+public:
+	explicit BoundPivotRef() : BoundTableRef(TableReferenceType::PIVOT) {
+	}
+
+	idx_t bind_index;
+	//! The binder used to bind the child of the pivot
+	shared_ptr<Binder> child_binder;
+	//! The child node of the pivot
+	unique_ptr<BoundTableRef> child;
+	//! The bound pivot info
+	BoundPivotInfo bound_pivot;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pos_join_ref.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Represents a positional join
 class BoundPositionalJoinRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::POSITIONAL_JOIN;
+
 public:
 	BoundPositionalJoinRef() : BoundTableRef(TableReferenceType::POSITIONAL_JOIN), lateral(false) {
 	}

package/src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! Represents a cross product
 class BoundSubqueryRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
+
 public:
 	BoundSubqueryRef(shared_ptr<Binder> binder_p, unique_ptr<BoundQueryNode> subquery)
 	    : BoundTableRef(TableReferenceType::SUBQUERY), binder(std::move(binder_p)), subquery(std::move(subquery)) {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_table_function.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! Represents a reference to a table-producing function call
 class BoundTableFunction : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::TABLE_FUNCTION;
+
 public:
 	explicit BoundTableFunction(unique_ptr<LogicalOperator> get)
 	    : BoundTableRef(TableReferenceType::TABLE_FUNCTION), get(std::move(get)) {

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

@@ -5,3 +5,4 @@
 #include "duckdb/planner/tableref/bound_joinref.hpp"
 #include "duckdb/planner/tableref/bound_subqueryref.hpp"
 #include "duckdb/planner/tableref/bound_table_function.hpp"
+#include "duckdb/planner/tableref/bound_pivotref.hpp"

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -100,9 +100,9 @@ public:
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
-	virtual bool MergeIndexes(IndexLock &state, Index *other_index) = 0;
+	virtual bool MergeIndexes(IndexLock &state, Index &other_index) = 0;
 	//! Obtains a lock and calls MergeIndexes while holding that lock
-	bool MergeIndexes(Index *other_index);
+	bool MergeIndexes(Index &other_index);
 
 	//! Returns the string representation of an index
 	virtual string ToString() = 0;
@@ -163,6 +163,19 @@ private:
 
 	//! Bind the unbound expressions of the index
 	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
+
+public:
+	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;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp

@@ -110,30 +110,30 @@ public:
 	//! Gets the total bytes written to the WAL since startup
 	idx_t GetTotalWritten();
 
-	virtual void WriteCreateTable(TableCatalogEntry *entry);
-	void WriteDropTable(TableCatalogEntry *entry);
+	virtual void WriteCreateTable(const TableCatalogEntry &entry);
+	void WriteDropTable(const TableCatalogEntry &entry);
 
-	void WriteCreateSchema(SchemaCatalogEntry *entry);
-	void WriteDropSchema(SchemaCatalogEntry *entry);
+	void WriteCreateSchema(const SchemaCatalogEntry &entry);
+	void WriteDropSchema(const SchemaCatalogEntry &entry);
 
-	void WriteCreateView(ViewCatalogEntry *entry);
-	void WriteDropView(ViewCatalogEntry *entry);
+	void WriteCreateView(const ViewCatalogEntry &entry);
+	void WriteDropView(const ViewCatalogEntry &entry);
 
-	void WriteCreateSequence(SequenceCatalogEntry *entry);
-	void WriteDropSequence(SequenceCatalogEntry *entry);
-	void WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValue val);
+	void WriteCreateSequence(const SequenceCatalogEntry &entry);
+	void WriteDropSequence(const SequenceCatalogEntry &entry);
+	void WriteSequenceValue(const SequenceCatalogEntry &entry, SequenceValue val);
 
-	void WriteCreateMacro(ScalarMacroCatalogEntry *entry);
-	void WriteDropMacro(ScalarMacroCatalogEntry *entry);
+	void WriteCreateMacro(const ScalarMacroCatalogEntry &entry);
+	void WriteDropMacro(const ScalarMacroCatalogEntry &entry);
 
-	void WriteCreateTableMacro(TableMacroCatalogEntry *entry);
-	void WriteDropTableMacro(TableMacroCatalogEntry *entry);
+	void WriteCreateTableMacro(const TableMacroCatalogEntry &entry);
+	void WriteDropTableMacro(const TableMacroCatalogEntry &entry);
 
-	void WriteCreateIndex(IndexCatalogEntry *entry);
-	void WriteDropIndex(IndexCatalogEntry *entry);
+	void WriteCreateIndex(const IndexCatalogEntry &entry);
+	void WriteDropIndex(const IndexCatalogEntry &entry);
 
-	void WriteCreateType(TypeCatalogEntry *entry);
-	void WriteDropType(TypeCatalogEntry *entry);
+	void WriteCreateType(const TypeCatalogEntry &entry);
+	void WriteDropType(const TypeCatalogEntry &entry);
 	//! Sets the table used for subsequent insert/delete/update commands
 	void WriteSetTable(string &schema, string &table);
 

package/src/duckdb/src/include/duckdb/transaction/commit_state.hpp

@@ -46,7 +46,7 @@ public:
 private:
 	void SwitchTable(DataTableInfo *table, UndoFlags new_op);
 
-	void WriteCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data);
+	void WriteCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data);
 	void WriteDelete(DeleteInfo *info);
 	void WriteUpdate(UpdateInfo *info);
 

package/src/duckdb/src/main/capi/table_function-c.cpp

@@ -83,12 +83,12 @@ struct CTableLocalInitData : public LocalTableFunctionState {
 };
 
 struct CTableInternalInitInfo {
-	CTableInternalInitInfo(CTableBindData &bind_data, CTableInitData &init_data, const vector<column_t> &column_ids,
-	                       TableFilterSet *filters)
+	CTableInternalInitInfo(const CTableBindData &bind_data, CTableInitData &init_data,
+	                       const vector<column_t> &column_ids, TableFilterSet *filters)
 	    : bind_data(bind_data), init_data(init_data), column_ids(column_ids), filters(filters), success(true) {
 	}
 
-	CTableBindData &bind_data;
+	const CTableBindData &bind_data;
 	CTableInitData &init_data;
 	const vector<column_t> &column_ids;
 	TableFilterSet *filters;
@@ -97,11 +97,11 @@ struct CTableInternalInitInfo {
 };
 
 struct CTableInternalFunctionInfo {
-	CTableInternalFunctionInfo(CTableBindData &bind_data, CTableInitData &init_data, CTableInitData &local_data)
+	CTableInternalFunctionInfo(const CTableBindData &bind_data, CTableInitData &init_data, CTableInitData &local_data)
 	    : bind_data(bind_data), init_data(init_data), local_data(local_data), success(true) {
 	}
 
-	CTableBindData &bind_data;
+	const CTableBindData &bind_data;
 	CTableInitData &init_data;
 	CTableInitData &local_data;
 	bool success;
@@ -124,7 +124,7 @@ unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctio
 }
 
 unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context, TableFunctionInitInput &data_p) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
 	auto result = make_uniq<CTableGlobalInitData>();
 
 	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
@@ -137,7 +137,7 @@ unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context,
 
 unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &context, TableFunctionInitInput &data_p,
                                                             GlobalTableFunctionState *gstate) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
 	auto result = make_uniq<CTableLocalInitData>();
 	if (!bind_data.info->local_init) {
 		return std::move(result);
@@ -152,7 +152,7 @@ unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &co
 }
 
 unique_ptr<NodeStatistics> CTableFunctionCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const CTableBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<CTableBindData>();
 	if (!bind_data.stats) {
 		return nullptr;
 	}
@@ -160,7 +160,7 @@ unique_ptr<NodeStatistics> CTableFunctionCardinality(ClientContext &context, con
 }
 
 void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
 	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
 	auto &local_data = (CTableLocalInitData &)*data_p.local_state;
 	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);

package/src/duckdb/src/main/client_context.cpp

@@ -304,7 +304,7 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 	if (statement->type != StatementType::EXPLAIN_STATEMENT) {
 		return false;
 	}
-	auto &explain = (ExplainStatement &)*statement;
+	auto &explain = statement->Cast<ExplainStatement>();
 	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
 }
 

package/src/duckdb/src/main/config.cpp

@@ -84,6 +84,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
                                                  DUCKDB_GLOBAL(PasswordSetting),
                                                  DUCKDB_LOCAL(PerfectHashThresholdSetting),
+                                                 DUCKDB_LOCAL(PivotLimitSetting),
                                                  DUCKDB_LOCAL(PreserveIdentifierCase),
                                                  DUCKDB_GLOBAL(PreserveInsertionOrder),
                                                  DUCKDB_LOCAL(ProfilerHistorySize),

package/src/duckdb/src/main/query_profiler.cpp

@@ -669,7 +669,7 @@ void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &st
 		auto expr_info = make_uniq<ExpressionInfo>();
 		if (child->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
 			expr_info->hasfunction = true;
-			expr_info->function_name = ((BoundFunctionExpression &)child->expr).function.ToString();
+			expr_info->function_name = child->expr.Cast<BoundFunctionExpression>().function.ToString();
 			expr_info->function_time = child->profiler.time;
 			expr_info->sample_tuples_count = child->profiler.sample_tuples_count;
 			expr_info->tuples_count = child->profiler.tuples_count;
@@ -697,7 +697,7 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
 	// Maybe root has a function
 	if (state.root_state->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
 		expression_info_p->hasfunction = true;
-		expression_info_p->function_name = ((BoundFunctionExpression &)state.root_state->expr).function.name;
+		expression_info_p->function_name = (state.root_state->expr.Cast<BoundFunctionExpression>()).function.name;
 		expression_info_p->function_time = state.root_state->profiler.time;
 		expression_info_p->sample_tuples_count = state.root_state->profiler.sample_tuples_count;
 		expression_info_p->tuples_count = state.root_state->profiler.tuples_count;

package/src/duckdb/src/main/relation/aggregate_relation.cpp

@@ -38,7 +38,7 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
+	auto &select_node = result->Cast<SelectNode>();
 	if (!groups.empty()) {
 		// explicit groups provided: use standard handling
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;

package/src/duckdb/src/main/relation/filter_relation.cpp

@@ -24,7 +24,7 @@ unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
 		// child node is a join: push filter into WHERE clause of select node
 		auto child_node = child->GetQueryNode();
 		D_ASSERT(child_node->type == QueryNodeType::SELECT_NODE);
-		auto &select_node = (SelectNode &)*child_node;
+		auto &select_node = child_node->Cast<SelectNode>();
 		if (!select_node.where_clause) {
 			select_node.where_clause = condition->Copy();
 		} else {

package/src/duckdb/src/main/relation/projection_relation.cpp

@@ -37,7 +37,7 @@ unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
 		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
+	auto &select_node = result->Cast<SelectNode>();
 	select_node.aggregate_handling = AggregateHandling::NO_AGGREGATES_ALLOWED;
 	select_node.select_list.clear();
 	for (auto &expr : expressions) {

package/src/duckdb/src/main/relation.cpp

@@ -124,7 +124,7 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const str
 			if (expr->type != ExpressionType::COLUMN_REF) {
 				throw ParserException("Expected a single expression as join condition");
 			}
-			auto &colref = (ColumnRefExpression &)*expr;
+			auto &colref = expr->Cast<ColumnRefExpression>();
 			if (colref.IsQualified()) {
 				throw ParserException("Expected unqualified column for column in USING clause");
 			}

package/src/duckdb/src/main/settings/settings.cpp

@@ -763,7 +763,7 @@ void PerfectHashThresholdSetting::ResetLocal(ClientContext &context) {
 }
 
 void PerfectHashThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto bits = input.GetValue<int32_t>();
+	auto bits = input.GetValue<int64_t>();
 	if (bits < 0 || bits > 32) {
 		throw ParserException("Perfect HT threshold out of range: should be within range 0 - 32");
 	}
@@ -774,6 +774,22 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
 }
 
+//===--------------------------------------------------------------------===//
+// Pivot Limit
+//===--------------------------------------------------------------------===//
+
+void PivotLimitSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).pivot_limit = ClientConfig().pivot_limit;
+}
+
+void PivotLimitSetting::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).pivot_limit = input.GetValue<uint64_t>();
+}
+
+Value PivotLimitSetting::GetSetting(ClientContext &context) {
+	return Value::BIGINT(ClientConfig::GetConfig(context).pivot_limit);
+}
+
 //===--------------------------------------------------------------------===//
 // PreserveIdentifierCase
 //===--------------------------------------------------------------------===//