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

package/src/duckdb/src/function/table/glob.cpp

@@ -32,7 +32,7 @@ static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &cont
 }
 
 static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (GlobFunctionBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<GlobFunctionBindData>();
 	auto &state = (GlobFunctionState &)*data_p.global_state;
 
 	idx_t count = 0;

package/src/duckdb/src/function/table/pragma_detailed_profiling_output.cpp

@@ -108,7 +108,7 @@ static void ExtractFunctions(ColumnDataCollection &collection, ExpressionInfo &i
 
 static void PragmaDetailedProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p,
                                                   DataChunk &output) {
-	auto &state = (PragmaDetailedProfilingOutputOperatorData &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<PragmaDetailedProfilingOutputOperatorData>();
 	auto &data = (PragmaDetailedProfilingOutputData &)*data_p.bind_data;
 
 	if (!state.initialized) {

package/src/duckdb/src/function/table/pragma_last_profiling_output.cpp

@@ -61,7 +61,7 @@ unique_ptr<GlobalTableFunctionState> PragmaLastProfilingOutputInit(ClientContext
 }
 
 static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &state = (PragmaLastProfilingOutputOperatorData &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<PragmaLastProfilingOutputOperatorData>();
 	auto &data = (PragmaLastProfilingOutputData &)*data_p.bind_data;
 	if (!state.initialized) {
 		// create a ColumnDataCollection

package/src/duckdb/src/function/table/range.cpp

@@ -91,7 +91,7 @@ static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &con
 }
 
 static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (RangeFunctionBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RangeFunctionBindData>();
 	auto &state = (RangeFunctionState &)*data_p.global_state;
 
 	auto increment = bind_data.increment;
@@ -112,7 +112,7 @@ static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, Da
 }
 
 unique_ptr<NodeStatistics> RangeCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (RangeFunctionBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<RangeFunctionBindData>();
 	idx_t cardinality = Hugeint::Cast<idx_t>((bind_data.end - bind_data.start) / bind_data.increment);
 	return make_uniq<NodeStatistics>(cardinality, cardinality);
 }
@@ -134,7 +134,7 @@ public:
 		       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check;
 	}
 
-	bool Finished(timestamp_t current_value) {
+	bool Finished(timestamp_t current_value) const {
 		if (greater_than_check) {
 			if (inclusive_bound) {
 				return current_value > end;
@@ -207,12 +207,12 @@ struct RangeDateTimeState : public GlobalTableFunctionState {
 };
 
 static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (RangeDateTimeBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<RangeDateTimeBindData>();
 	return make_uniq<RangeDateTimeState>(bind_data.start);
 }
 
 static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (RangeDateTimeBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RangeDateTimeBindData>();
 	auto &state = (RangeDateTimeState &)*data_p.global_state;
 	if (state.finished) {
 		return;

package/src/duckdb/src/function/table/read_csv.cpp

@@ -277,7 +277,7 @@ public:
 public:
 	idx_t MaxThreads() const override;
 	//! Updates the CSV reader with the next buffer to read. Returns false if no more buffers are available.
-	bool Next(ClientContext &context, ReadCSVData &bind_data, unique_ptr<ParallelCSVReader> &reader);
+	bool Next(ClientContext &context, const ReadCSVData &bind_data, unique_ptr<ParallelCSVReader> &reader);
 	//! Verify if the CSV File was read correctly
 	void Verify();
 
@@ -402,7 +402,7 @@ void ParallelCSVGlobalState::Verify() {
 	}
 }
 
-bool ParallelCSVGlobalState::Next(ClientContext &context, ReadCSVData &bind_data,
+bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bind_data,
                                   unique_ptr<ParallelCSVReader> &reader) {
 	lock_guard<mutex> parallel_lock(main_mutex);
 	if (!current_buffer) {
@@ -506,8 +506,8 @@ public:
 
 unique_ptr<LocalTableFunctionState> ParallelReadCSVInitLocal(ExecutionContext &context, TableFunctionInitInput &input,
                                                              GlobalTableFunctionState *global_state_p) {
-	auto &csv_data = (ReadCSVData &)*input.bind_data;
-	auto &global_state = (ParallelCSVGlobalState &)*global_state_p;
+	auto &csv_data = input.bind_data->Cast<ReadCSVData>();
+	auto &global_state = global_state_p->Cast<ParallelCSVGlobalState>();
 	unique_ptr<ParallelCSVReader> csv_reader;
 	auto has_next = global_state.Next(context.client, csv_data, csv_reader);
 	if (!has_next) {
@@ -518,9 +518,9 @@ unique_ptr<LocalTableFunctionState> ParallelReadCSVInitLocal(ExecutionContext &c
 }
 
 static void ParallelReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
-	auto &csv_global_state = (ParallelCSVGlobalState &)*data_p.global_state;
-	auto &csv_local_state = (ParallelCSVLocalState &)*data_p.local_state;
+	auto &bind_data = data_p.bind_data->Cast<ReadCSVData>();
+	auto &csv_global_state = data_p.global_state->Cast<ParallelCSVGlobalState>();
+	auto &csv_local_state = data_p.local_state->Cast<ParallelCSVLocalState>();
 
 	if (!csv_local_state.csv_reader) {
 		// no csv_reader was set, this can happen when a filename-based filter has filtered out all possible files
@@ -694,7 +694,7 @@ unique_ptr<LocalTableFunctionState> SingleThreadedReadCSVInitLocal(ExecutionCont
 static void SingleThreadedCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
 	auto &data = (SingleThreadedCSVState &)*data_p.global_state;
-	auto &lstate = (SingleThreadedCSVLocalState &)*data_p.local_state;
+	auto &lstate = data_p.local_state->Cast<SingleThreadedCSVLocalState>();
 	if (!lstate.csv_reader) {
 		// no csv_reader was set, this can happen when a filename-based filter has filtered out all possible files
 		return;
@@ -771,10 +771,10 @@ static idx_t CSVReaderGetBatchIndex(ClientContext &context, const FunctionData *
                                     LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
 	auto &bind_data = (ReadCSVData &)*bind_data_p;
 	if (bind_data.single_threaded) {
-		auto &data = (SingleThreadedCSVLocalState &)*local_state;
+		auto &data = local_state->Cast<SingleThreadedCSVLocalState>();
 		return data.file_index;
 	}
-	auto &data = (ParallelCSVLocalState &)*local_state;
+	auto &data = local_state->Cast<ParallelCSVLocalState>();
 	return data.csv_reader->buffer->batch_index;
 }
 

package/src/duckdb/src/function/table/repeat.cpp

@@ -32,7 +32,7 @@ static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, T
 
 static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
-	auto &state = (RepeatOperatorData &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RepeatOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
 	output.data[0].Reference(bind_data.value);

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -137,7 +137,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 		auto &entry = data.entries[data.offset];
 		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
 
-		auto &table = (TableCatalogEntry &)*entry;
+		auto &table = entry->Cast<TableCatalogEntry>();
 		auto &constraints = table.GetConstraints();
 		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {
@@ -151,7 +151,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				constraint_type = "CHECK";
 				break;
 			case ConstraintType::UNIQUE: {
-				auto &unique = (UniqueConstraint &)*constraint;
+				auto &unique = constraint->Cast<UniqueConstraint>();
 				constraint_type = unique.is_primary_key ? "PRIMARY KEY" : "UNIQUE";
 				break;
 			}
@@ -163,7 +163,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					continue;
 				}
 				auto &bound_constraints = table.GetBoundConstraints();
-				auto &bound_foreign_key = (const BoundForeignKeyConstraint &)*bound_constraints[data.constraint_offset];
+				auto &bound_foreign_key = bound_constraints[data.constraint_offset]->Cast<BoundForeignKeyConstraint>();
 				if (bound_foreign_key.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
 					// Those are already covered by PRIMARY KEY and UNIQUE entries
 					continue;
@@ -193,15 +193,15 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			UniqueKeyInfo uk_info;
 
 			if (is_duck_table) {
-				auto &bound_constraint = (BoundConstraint &)*table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::UNIQUE: {
-					auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
+					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
 					uk_info = {table.schema->name, table.name, bound_unique.keys};
 					break;
 				}
 				case ConstraintType::FOREIGN_KEY: {
-					const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
+					const auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
 					const auto &info = bound_foreign_key.info;
 					// find the other table
 					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, table.catalog->GetName(),
@@ -242,36 +242,36 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			// expression, VARCHAR
 			Value expression_text;
 			if (constraint->type == ConstraintType::CHECK) {
-				auto &check = (CheckConstraint &)*constraint;
+				auto &check = constraint->Cast<CheckConstraint>();
 				expression_text = Value(check.expression->ToString());
 			}
 			output.SetValue(col++, count, expression_text);
 
 			vector<LogicalIndex> column_index_list;
 			if (is_duck_table) {
-				auto &bound_constraint = (BoundConstraint &)*table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::CHECK: {
-					auto &bound_check = (BoundCheckConstraint &)bound_constraint;
+					auto &bound_check = bound_constraint.Cast<BoundCheckConstraint>();
 					for (auto &col_idx : bound_check.bound_columns) {
 						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
 					}
 					break;
 				}
 				case ConstraintType::UNIQUE: {
-					auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
+					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
 					for (auto &col_idx : bound_unique.keys) {
 						column_index_list.push_back(col_idx);
 					}
 					break;
 				}
 				case ConstraintType::NOT_NULL: {
-					auto &bound_not_null = (BoundNotNullConstraint &)bound_constraint;
+					auto &bound_not_null = bound_constraint.Cast<BoundNotNullConstraint>();
 					column_index_list.push_back(table.GetColumns().PhysicalToLogical(bound_not_null.index));
 					break;
 				}
 				case ConstraintType::FOREIGN_KEY: {
-					auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
+					auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
 					for (auto &col_idx : bound_foreign_key.info.fk_keys) {
 						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
 					}

package/src/duckdb/src/function/table/system/duckdb_databases.cpp

@@ -53,7 +53,7 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset++];
 
-		auto &attached = (AttachedDatabase &)*entry;
+		auto &attached = entry->Cast<AttachedDatabase>();
 		// return values:
 
 		idx_t col = 0;

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -213,7 +213,7 @@ struct MacroExtractor {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
-			auto &colref = (ColumnRefExpression &)*param;
+			auto &colref = param->Cast<ColumnRefExpression>();
 			results.emplace_back(colref.GetColumnName());
 		}
 		for (auto &param_entry : entry.function->default_parameters) {
@@ -269,7 +269,7 @@ struct TableMacroExtractor {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
-			auto &colref = (ColumnRefExpression &)*param;
+			auto &colref = param->Cast<ColumnRefExpression>();
 			results.emplace_back(colref.GetColumnName());
 		}
 		for (auto &param_entry : entry.function->default_parameters) {

package/src/duckdb/src/function/table/system/duckdb_indexes.cpp

@@ -83,7 +83,7 @@ void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, D
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset++];
 
-		auto &index = (IndexCatalogEntry &)*entry;
+		auto &index = entry->Cast<IndexCatalogEntry>();
 		// return values:
 
 		idx_t col = 0;

package/src/duckdb/src/function/table/system/duckdb_sequences.cpp

@@ -88,7 +88,7 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset++];
 
-		auto &seq = (SequenceCatalogEntry &)*entry;
+		auto &seq = entry->Cast<SequenceCatalogEntry>();
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR

package/src/duckdb/src/function/table/system/duckdb_tables.cpp

@@ -82,7 +82,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, Ta
 static bool TableHasPrimaryKey(TableCatalogEntry &table) {
 	for (auto &constraint : table.GetConstraints()) {
 		if (constraint->type == ConstraintType::UNIQUE) {
-			auto &unique = (UniqueConstraint &)*constraint;
+			auto &unique = constraint->Cast<UniqueConstraint>();
 			if (unique.is_primary_key) {
 				return true;
 			}
@@ -116,7 +116,7 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		if (entry->type != CatalogType::TABLE_ENTRY) {
 			continue;
 		}
-		auto &table = (TableCatalogEntry &)*entry;
+		auto &table = entry->Cast<TableCatalogEntry>();
 		auto storage_info = table.GetStorageInfo(context);
 		// return values:
 		idx_t col = 0;

package/src/duckdb/src/function/table/system/duckdb_views.cpp

@@ -78,7 +78,7 @@ void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		if (entry->type != CatalogType::VIEW_ENTRY) {
 			continue;
 		}
-		auto &view = (ViewCatalogEntry &)*entry;
+		auto &view = entry->Cast<ViewCatalogEntry>();
 
 		// return values:
 		idx_t col = 0;

package/src/duckdb/src/function/table/system/pragma_storage_info.cpp

@@ -92,7 +92,7 @@ unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &contex
 
 static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
-	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<PragmaStorageOperatorData>();
 	idx_t count = 0;
 	auto &columns = bind_data.table_entry->GetColumns();
 	while (data.offset < bind_data.storage_info.column_segments.size() && count < STANDARD_VECTOR_SIZE) {

package/src/duckdb/src/function/table/system/pragma_table_info.cpp

@@ -71,14 +71,14 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 	for (auto &constraint : table->GetConstraints()) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = (NotNullConstraint &)*constraint;
+			auto &not_null = constraint->Cast<NotNullConstraint>();
 			if (not_null.index == column.Logical()) {
 				out_not_null = true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = (UniqueConstraint &)*constraint;
+			auto &unique = constraint->Cast<UniqueConstraint>();
 
 			if (unique.is_primary_key) {
 				if (unique.index == column.Logical()) {
@@ -165,7 +165,7 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 
 static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (PragmaTableFunctionData &)*data_p.bind_data;
-	auto &state = (PragmaTableOperatorData &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<PragmaTableOperatorData>();
 	switch (bind_data.entry->type) {
 	case CatalogType::TABLE_ENTRY:
 		PragmaTableInfoTable(state, (TableCatalogEntry *)bind_data.entry, output);

package/src/duckdb/src/function/table/system/test_vector_types.cpp

@@ -204,7 +204,7 @@ static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, Tabl
 }
 
 unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (TestVectorBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<TestVectorBindData>();
 
 	auto result = make_uniq<TestVectorTypesData>();
 

package/src/duckdb/src/function/table/table_scan.cpp

@@ -42,7 +42,7 @@ static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
 struct TableScanGlobalState : public GlobalTableFunctionState {
 	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
 		D_ASSERT(bind_data_p);
-		auto &bind_data = (const TableScanBindData &)*bind_data_p;
+		auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 		max_threads = bind_data.table->GetStorage().MaxThreads(context);
 	}
 
@@ -64,7 +64,7 @@ struct TableScanGlobalState : public GlobalTableFunctionState {
 static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input,
                                                               GlobalTableFunctionState *gstate) {
 	auto result = make_uniq<TableScanLocalState>();
-	auto &bind_data = (TableScanBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	vector<column_t> column_ids = input.column_ids;
 	for (auto &col : column_ids) {
 		auto storage_idx = GetStorageIndex(*bind_data.table, col);
@@ -73,7 +73,7 @@ static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &
 	result->scan_state.Initialize(std::move(column_ids), input.filters);
 	TableScanParallelStateNext(context.client, input.bind_data, result.get(), gstate);
 	if (input.CanRemoveFilterColumns()) {
-		auto &tsgs = (TableScanGlobalState &)*gstate;
+		auto &tsgs = gstate->Cast<TableScanGlobalState>();
 		result->all_columns.Initialize(context.client, tsgs.scanned_types);
 	}
 	return std::move(result);
@@ -82,7 +82,7 @@ static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &
 unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
 
 	D_ASSERT(input.bind_data);
-	auto &bind_data = (const TableScanBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	auto result = make_uniq<TableScanGlobalState>(context, input.bind_data);
 	bind_data.table->GetStorage().InitializeParallelScan(context, result->state);
 	if (input.CanRemoveFilterColumns()) {
@@ -101,7 +101,7 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 
 static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
                                                       column_t column_id) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	if (local_storage.Find(bind_data.table->GetStoragePtr())) {
 		// we don't emit any statistics for tables that have outstanding transaction-local data
@@ -111,9 +111,9 @@ static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, co
 }
 
 static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (TableScanBindData &)*data_p.bind_data;
-	auto &gstate = (TableScanGlobalState &)*data_p.global_state;
-	auto &state = (TableScanLocalState &)*data_p.local_state;
+	auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
+	auto &gstate = data_p.global_state->Cast<TableScanGlobalState>();
+	auto &state = data_p.local_state->Cast<TableScanLocalState>();
 	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
 	auto &storage = bind_data.table->GetStorage();
 	do {
@@ -138,9 +138,9 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 
 bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
                                 LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &parallel_state = (TableScanGlobalState &)*global_state;
-	auto &state = (TableScanLocalState &)*local_state;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
+	auto &parallel_state = global_state->Cast<TableScanGlobalState>();
+	auto &state = local_state->Cast<TableScanLocalState>();
 	auto &storage = bind_data.table->GetStorage();
 
 	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
@@ -148,8 +148,8 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 
 double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p,
                          const GlobalTableFunctionState *gstate_p) {
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
-	auto &gstate = (TableScanGlobalState &)*gstate_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
+	auto &gstate = gstate_p->Cast<TableScanGlobalState>();
 	auto &storage = bind_data.table->GetStorage();
 	idx_t total_rows = storage.GetTotalRows();
 	if (total_rows == 0) {
@@ -169,7 +169,7 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 
 idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
                              LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate_p) {
-	auto &state = (TableScanLocalState &)*local_state;
+	auto &state = local_state->Cast<TableScanLocalState>();
 	if (state.scan_state.table_state.row_group) {
 		return state.scan_state.table_state.batch_index;
 	}
@@ -184,12 +184,12 @@ BindInfo TableScanGetBindInfo(const FunctionData *bind_data) {
 }
 
 void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	entries.AddDependency(bind_data.table);
 }
 
 unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	auto &storage = bind_data.table->GetStorage();
 	idx_t estimated_cardinality = storage.info->cardinality + local_storage.AddedRows(bind_data.table->GetStoragePtr());
@@ -211,7 +211,7 @@ struct IndexScanGlobalState : public GlobalTableFunctionState {
 };
 
 static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (const TableScanBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	data_ptr_t row_id_data = nullptr;
 	if (!bind_data.result_ids.empty()) {
 		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
@@ -228,8 +228,8 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 }
 
 static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const TableScanBindData &)*data_p.bind_data;
-	auto &state = (IndexScanGlobalState &)*data_p.global_state;
+	auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
+	auto &state = data_p.global_state->Cast<IndexScanGlobalState>();
 	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
 
@@ -245,7 +245,7 @@ static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p
 
 static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &expr, bool &rewrite_possible) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)expr;
+		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
 		// bound column ref: rewrite to fit in the current set of bound column ids
 		bound_colref.binding.table_index = get.table_index;
 		column_t referenced_column = index.column_ids[bound_colref.binding.column_index];
@@ -265,7 +265,7 @@ static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &ex
 
 void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
                                     vector<unique_ptr<Expression>> &filters) {
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto table = bind_data.table;
 	auto &storage = table->GetStorage();
 
@@ -321,13 +321,13 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 				// bindings[0] = the expression
 				// bindings[1] = the index expression
 				// bindings[2] = the constant
-				auto comparison = (BoundComparisonExpression *)bindings[0];
+				auto &comparison = bindings[0]->Cast<BoundComparisonExpression>();
 				D_ASSERT(bindings[0]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
 				D_ASSERT(bindings[2]->type == ExpressionType::VALUE_CONSTANT);
 
-				auto constant_value = ((BoundConstantExpression *)bindings[2])->value;
-				auto comparison_type = comparison->type;
-				if (comparison->left->type == ExpressionType::VALUE_CONSTANT) {
+				auto constant_value = bindings[2]->Cast<BoundConstantExpression>().value;
+				auto comparison_type = comparison.type;
+				if (comparison.left->type == ExpressionType::VALUE_CONSTANT) {
 					// the expression is on the right side, we flip them around
 					comparison_type = FlipComparisonExpression(comparison_type);
 				}
@@ -348,7 +348,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 				}
 			} else if (expr->type == ExpressionType::COMPARE_BETWEEN) {
 				// BETWEEN expression
-				auto &between = (BoundBetweenExpression &)*expr;
+				auto &between = expr->Cast<BoundBetweenExpression>();
 				if (!between.input->Equals(index_expression.get())) {
 					// expression doesn't match the current index expression
 					continue;
@@ -358,10 +358,10 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 					// not a constant comparison
 					continue;
 				}
-				low_value = ((BoundConstantExpression &)*between.lower).value;
+				low_value = (between.lower->Cast<BoundConstantExpression>()).value;
 				low_comparison_type = between.lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
 				                                              : ExpressionType::COMPARE_GREATERTHAN;
-				high_value = ((BoundConstantExpression &)*between.upper).value;
+				high_value = (between.upper->Cast<BoundConstantExpression>()).value;
 				high_comparison_type = between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
 				                                               : ExpressionType::COMPARE_LESSTHAN;
 				break;
@@ -400,13 +400,13 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 }
 
 string TableScanToString(const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	string result = bind_data.table->name;
 	return result;
 }
 
 static void TableScanSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 
 	writer.WriteString(bind_data.table->schema->name);
 	writer.WriteString(bind_data.table->name);
@@ -479,7 +479,7 @@ TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &functio
 	if (function.function != TableScanFunc || !bind_data_p) {
 		return nullptr;
 	}
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	return bind_data.table;
 }
 

package/src/duckdb/src/function/table/unnest.cpp

@@ -53,7 +53,7 @@ static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunction
 
 static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &context, TableFunctionInitInput &input,
                                                            GlobalTableFunctionState *global_state) {
-	auto &gstate = (UnnestGlobalState &)*global_state;
+	auto &gstate = global_state->Cast<UnnestGlobalState>();
 
 	auto result = make_uniq<UnnestLocalState>();
 	result->operator_state = PhysicalUnnest::GetState(context, gstate.select_list);
@@ -61,7 +61,7 @@ static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &con
 }
 
 static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (UnnestBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<UnnestBindData>();
 	auto result = make_uniq<UnnestGlobalState>();
 	auto ref = make_uniq<BoundReferenceExpression>(bind_data.input_type, 0);
 	auto bound_unnest = make_uniq<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
@@ -72,8 +72,8 @@ static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, T
 
 static OperatorResultType UnnestFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
                                          DataChunk &output) {
-	auto &state = (UnnestGlobalState &)*data_p.global_state;
-	auto &lstate = (UnnestLocalState &)*data_p.local_state;
+	auto &state = data_p.global_state->Cast<UnnestGlobalState>();
+	auto &lstate = data_p.local_state->Cast<UnnestLocalState>();
 	return PhysicalUnnest::ExecuteInternal(context, input, output, *lstate.operator_state, state.select_list, false);
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1457"
+#define DUCKDB_VERSION "0.7.2-dev1533"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "5b9bcdfbd9"
+#define DUCKDB_SOURCE_ID "ff7a0b41a9"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_macro_function.cpp

@@ -20,14 +20,14 @@ TableMacroFunction::TableMacroFunction(unique_ptr<QueryNode> query_node)
 TableMacroFunction::TableMacroFunction(void) : MacroFunction(MacroType::TABLE_MACRO) {
 }
 
-unique_ptr<MacroFunction> TableMacroFunction::Copy() {
+unique_ptr<MacroFunction> TableMacroFunction::Copy() const {
 	auto result = make_uniq<TableMacroFunction>();
 	result->query_node = query_node->Copy();
 	this->CopyProperties(*result);
 	return std::move(result);
 }
 
-string TableMacroFunction::ToSQL(const string &schema, const string &name) {
+string TableMacroFunction::ToSQL(const string &schema, const string &name) const {
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
 }