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

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -36,22 +36,22 @@
 
 namespace duckdb {
 
-void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk_type,
+void FindForeignKeyInformation(CatalogEntry &entry, AlterForeignKeyType alter_fk_type,
                                vector<unique_ptr<AlterForeignKeyInfo>> &fk_arrays) {
-	if (entry->type != CatalogType::TABLE_ENTRY) {
+	if (entry.type != CatalogType::TABLE_ENTRY) {
 		return;
 	}
-	auto *table_entry = (TableCatalogEntry *)entry;
-	auto &constraints = table_entry->GetConstraints();
+	auto &table_entry = entry.Cast<TableCatalogEntry>();
+	auto &constraints = table_entry.GetConstraints();
 	for (idx_t i = 0; i < constraints.size(); i++) {
 		auto &cond = constraints[i];
 		if (cond->type != ConstraintType::FOREIGN_KEY) {
 			continue;
 		}
-		auto &fk = (ForeignKeyConstraint &)*cond;
+		auto &fk = cond->Cast<ForeignKeyConstraint>();
 		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			AlterEntryData alter_data(entry->catalog->GetName(), fk.info.schema, fk.info.table, false);
-			fk_arrays.push_back(make_uniq<AlterForeignKeyInfo>(std::move(alter_data), entry->name, fk.pk_columns,
+			AlterEntryData alter_data(entry.catalog->GetName(), fk.info.schema, fk.info.table, false);
+			fk_arrays.push_back(make_uniq<AlterForeignKeyInfo>(std::move(alter_data), entry.name, fk.pk_columns,
 			                                                   fk.fk_columns, fk.info.pk_keys, fk.info.fk_keys,
 			                                                   alter_fk_type));
 		} else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
@@ -114,7 +114,7 @@ CatalogEntry *DuckSchemaEntry::CreateTable(CatalogTransaction transaction, Bound
 
 	// add a foreign key constraint in main key table if there is a foreign key constraint
 	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	FindForeignKeyInformation(entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
+	FindForeignKeyInformation(*entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
 	for (idx_t i = 0; i < fk_arrays.size(); i++) {
 		// alter primary key table
 		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
@@ -266,7 +266,7 @@ void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo *info) {
 
 	// if there is a foreign key constraint, get that information
 	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	FindForeignKeyInformation(existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
+	FindForeignKeyInformation(*existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
 
 	if (!set.DropEntry(transaction, info->name, info->cascade, info->allow_drop_internal)) {
 		throw InternalException("Could not drop element because of an internal error");

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -81,7 +81,7 @@ DuckTableEntry::DuckTableEntry(Catalog *catalog, SchemaCatalogEntry *schema, Bou
 			auto &constraint = bound_constraints[i];
 			if (constraint->type == ConstraintType::UNIQUE) {
 				// unique constraint: create a unique index
-				auto &unique = (BoundUniqueConstraint &)*constraint;
+				auto &unique = constraint->Cast<BoundUniqueConstraint>();
 				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
 				if (unique.is_primary_key) {
 					constraint_type = IndexConstraintType::PRIMARY;
@@ -94,7 +94,7 @@ DuckTableEntry::DuckTableEntry(Catalog *catalog, SchemaCatalogEntry *schema, Bou
 				}
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
 				// foreign key constraint: create a foreign key index
-				auto &bfk = (BoundForeignKeyConstraint &)*constraint;
+				auto &bfk = constraint->Cast<BoundForeignKeyConstraint>();
 				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
 					if (info->indexes.empty()) {
@@ -191,7 +191,7 @@ void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo *info) {
 
 static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (colref.column_names.back() == info.old_name) {
 			colref.column_names.back() = info.new_name;
 		}
@@ -225,13 +225,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 			break;
 		case ConstraintType::CHECK: {
 			// CHECK constraint: need to rename column references that refer to the renamed column
-			auto &check = (CheckConstraint &)*copy;
+			auto &check = copy->Cast<CheckConstraint>();
 			RenameExpression(*check.expression, info);
 			break;
 		}
 		case ConstraintType::UNIQUE: {
 			// UNIQUE constraint: possibly need to rename columns
-			auto &unique = (UniqueConstraint &)*copy;
+			auto &unique = copy->Cast<UniqueConstraint>();
 			for (idx_t i = 0; i < unique.columns.size(); i++) {
 				if (unique.columns[i] == info.old_name) {
 					unique.columns[i] = info.new_name;
@@ -241,7 +241,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 		}
 		case ConstraintType::FOREIGN_KEY: {
 			// FOREIGN KEY constraint: possibly need to rename columns
-			auto &fk = (ForeignKeyConstraint &)*copy;
+			auto &fk = copy->Cast<ForeignKeyConstraint>();
 			vector<string> columns = fk.pk_columns;
 			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				columns = fk.fk_columns;
@@ -312,7 +312,7 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
 		auto &bound_constraint = bound_constraints[constr_idx];
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null_constraint = (BoundNotNullConstraint &)*bound_constraint;
+			auto &not_null_constraint = bound_constraint->Cast<BoundNotNullConstraint>();
 			auto not_null_index = columns.PhysicalToLogical(not_null_constraint.index);
 			if (not_null_index != removed_index) {
 				// the constraint is not about this column: we need to copy it
@@ -325,7 +325,7 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
 		case ConstraintType::CHECK: {
 			// Generated columns can not be part of an index
 			// CHECK constraint
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraint;
+			auto &bound_check = bound_constraint->Cast<BoundCheckConstraint>();
 			// check if the removed column is part of the check constraint
 			if (is_generated) {
 				// generated columns can not be referenced by constraints, we can just add the constraint back
@@ -350,7 +350,7 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
 		}
 		case ConstraintType::UNIQUE: {
 			auto copy = constraint->Copy();
-			auto &unique = (UniqueConstraint &)*copy;
+			auto &unique = copy->Cast<UniqueConstraint>();
 			if (unique.index.index != DConstants::INVALID_INDEX) {
 				if (unique.index == removed_index) {
 					throw CatalogException(
@@ -364,7 +364,7 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
 		}
 		case ConstraintType::FOREIGN_KEY: {
 			auto copy = constraint->Copy();
-			auto &fk = (ForeignKeyConstraint &)*copy;
+			auto &fk = copy->Cast<ForeignKeyConstraint>();
 			vector<string> columns = fk.pk_columns;
 			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				columns = fk.fk_columns;
@@ -478,7 +478,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 	for (idx_t i = 0; i < constraints.size(); i++) {
 		auto constraint = constraints[i]->Copy();
 		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
+			auto &not_null = constraint->Cast<NotNullConstraint>();
 			if (not_null.index == not_null_idx) {
 				has_not_null = true;
 			}
@@ -511,7 +511,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 		auto constraint = constraints[i]->Copy();
 		// Skip/drop not_null
 		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
+			auto &not_null = constraint->Cast<NotNullConstraint>();
 			if (not_null.index == not_null_idx) {
 				continue;
 			}
@@ -555,7 +555,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		auto constraint = constraints[i]->Copy();
 		switch (constraint->type) {
 		case ConstraintType::CHECK: {
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraints[i];
+			auto &bound_check = bound_constraints[i]->Cast<BoundCheckConstraint>();
 			auto physical_index = columns.LogicalToPhysical(change_idx);
 			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
 				throw BinderException("Cannot change the type of a column that has a CHECK constraint specified");
@@ -565,7 +565,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		case ConstraintType::NOT_NULL:
 			break;
 		case ConstraintType::UNIQUE: {
-			auto &bound_unique = (BoundUniqueConstraint &)*bound_constraints[i];
+			auto &bound_unique = bound_constraints[i]->Cast<BoundUniqueConstraint>();
 			if (bound_unique.key_set.find(change_idx) != bound_unique.key_set.end()) {
 				throw BinderException(
 				    "Cannot change the type of a column that has a UNIQUE or PRIMARY KEY constraint specified");
@@ -573,7 +573,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = (BoundForeignKeyConstraint &)*bound_constraints[i];
+			auto &bfk = bound_constraints[i]->Cast<BoundForeignKeyConstraint>();
 			auto key_set = bfk.pk_key_set;
 			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				key_set = bfk.fk_key_set;
@@ -649,7 +649,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	for (idx_t i = 0; i < constraints.size(); i++) {
 		auto constraint = constraints[i]->Copy();
 		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			ForeignKeyConstraint &fk = (ForeignKeyConstraint &)*constraint;
+			ForeignKeyConstraint &fk = constraint->Cast<ForeignKeyConstraint>();
 			if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
 				continue;
 			}
@@ -663,7 +663,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
 }
 
-unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) {
+unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->columns = columns.Copy();
 

package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp

@@ -9,17 +9,17 @@ IndexCatalogEntry::IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schem
 	this->temporary = info->temporary;
 }
 
-string IndexCatalogEntry::ToSQL() {
+string IndexCatalogEntry::ToSQL() const {
 	if (sql.empty()) {
 		return sql;
 	}
 	if (sql[sql.size() - 1] != ';') {
-		sql += ";";
+		return sql + ";";
 	}
 	return sql;
 }
 
-void IndexCatalogEntry::Serialize(Serializer &serializer) {
+void IndexCatalogEntry::Serialize(Serializer &serializer) const {
 	// here we serialize the index metadata in the following order:
 	// schema name, table name, index name, sql, index type, index constraint type, expression list, parsed expressions,
 	// column IDs

package/src/duckdb/src/catalog/catalog_entry/scalar_macro_catalog_entry.cpp

@@ -19,7 +19,7 @@ ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalog
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
-void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) {
+void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	D_ASSERT(!internal);
 	auto &scalar_function = (ScalarMacroFunction &)*function;
 	FieldWriter writer(main_serializer);
@@ -62,7 +62,7 @@ TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEn
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
-void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) {
+void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(main_serializer);
 

package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp

@@ -33,7 +33,7 @@ SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction trans
 	return result;
 }
 
-void SchemaCatalogEntry::Serialize(Serializer &serializer) {
+void SchemaCatalogEntry::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
 	writer.Finalize();
@@ -49,7 +49,7 @@ unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &sourc
 	return info;
 }
 
-string SchemaCatalogEntry::ToSQL() {
+string SchemaCatalogEntry::ToSQL() const {
 	std::stringstream ss;
 	ss << "CREATE SCHEMA " << name << ";";
 	return ss.str();

package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp

@@ -18,7 +18,7 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry
 	this->temporary = info->temporary;
 }
 
-void SequenceCatalogEntry::Serialize(Serializer &serializer) {
+void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(schema->name);
 	writer.WriteString(name);
@@ -48,7 +48,7 @@ unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &s
 	return info;
 }
 
-string SequenceCatalogEntry::ToSQL() {
+string SequenceCatalogEntry::ToSQL() const {
 	std::stringstream ss;
 	ss << "CREATE SEQUENCE ";
 	ss << name;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -51,7 +51,7 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
-void TableCatalogEntry::Serialize(Serializer &serializer) {
+void TableCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 
 	FieldWriter writer(serializer);
@@ -88,10 +88,10 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 	vector<string> extra_constraints;
 	for (auto &constraint : constraints) {
 		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
+			auto &not_null = constraint->Cast<NotNullConstraint>();
 			not_null_columns.insert(not_null.index);
 		} else if (constraint->type == ConstraintType::UNIQUE) {
-			auto &pk = (UniqueConstraint &)*constraint;
+			auto &pk = constraint->Cast<UniqueConstraint>();
 			vector<string> constraint_columns = pk.columns;
 			if (pk.index.index != DConstants::INVALID_INDEX) {
 				// no columns specified: single column constraint
@@ -111,7 +111,7 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 				extra_constraints.push_back(constraint->ToString());
 			}
 		} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			auto &fk = (ForeignKeyConstraint &)*constraint;
+			auto &fk = constraint->Cast<ForeignKeyConstraint>();
 			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 			    fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
 				extra_constraints.push_back(constraint->ToString());
@@ -160,7 +160,7 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 	return ss.str();
 }
 
-string TableCatalogEntry::ToSQL() {
+string TableCatalogEntry::ToSQL() const {
 	std::stringstream ss;
 
 	ss << "CREATE TABLE ";

package/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp

@@ -18,7 +18,7 @@ TypeCatalogEntry::TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
 	this->internal = info->internal;
 }
 
-void TypeCatalogEntry::Serialize(Serializer &serializer) {
+void TypeCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(serializer);
 	writer.WriteString(schema->name);
@@ -45,7 +45,7 @@ unique_ptr<CreateTypeInfo> TypeCatalogEntry::Deserialize(Deserializer &source) {
 	return info;
 }
 
-string TypeCatalogEntry::ToSQL() {
+string TypeCatalogEntry::ToSQL() const {
 	std::stringstream ss;
 	switch (user_type.id()) {
 	case (LogicalTypeId::ENUM): {

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -43,7 +43,7 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 	}
 }
 
-void ViewCatalogEntry::Serialize(Serializer &serializer) {
+void ViewCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(serializer);
 	writer.WriteString(schema->name);
@@ -70,7 +70,7 @@ unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source, C
 	return info;
 }
 
-string ViewCatalogEntry::ToSQL() {
+string ViewCatalogEntry::ToSQL() const {
 	if (sql.empty()) {
 		//! Return empty sql with view name so pragma view_tables don't complain
 		return sql;
@@ -78,7 +78,7 @@ string ViewCatalogEntry::ToSQL() {
 	return sql + "\n;";
 }
 
-unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) {
+unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) const {
 	D_ASSERT(!internal);
 	auto create_info = make_uniq<CreateViewInfo>(schema, name);
 	create_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -23,11 +23,11 @@ unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterI
 void CatalogEntry::UndoAlter(ClientContext &context, AlterInfo *info) {
 }
 
-unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) {
+unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 	throw InternalException("Unsupported copy type for catalog entry!");
 }
 
-string CatalogEntry::ToSQL() {
+string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
 // LCOV_EXCL_STOP

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -541,30 +541,30 @@ CatalogEntry *CatalogSet::GetEntry(ClientContext &context, const string &name) {
 	return GetEntry(catalog.GetCatalogTransaction(context), name);
 }
 
-void CatalogSet::UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp) {
-	entry->timestamp = timestamp;
-	mapping[entry->name]->timestamp = timestamp;
+void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
+	entry.timestamp = timestamp;
+	mapping[entry.name]->timestamp = timestamp;
 }
 
-void CatalogSet::AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove) {
+void CatalogSet::AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove) {
 	CatalogEntry *user_type_catalog = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
 	if (user_type_catalog) {
 		auto &dependency_manager = catalog.GetDependencyManager();
 		if (remove) {
-			dependency_manager.dependents_map[user_type_catalog].erase(entry->parent);
-			dependency_manager.dependencies_map[entry->parent].erase(user_type_catalog);
+			dependency_manager.dependents_map[user_type_catalog].erase(entry.parent);
+			dependency_manager.dependencies_map[entry.parent].erase(user_type_catalog);
 		} else {
-			dependency_manager.dependents_map[user_type_catalog].insert(entry);
-			dependency_manager.dependencies_map[entry].insert(user_type_catalog);
+			dependency_manager.dependents_map[user_type_catalog].insert(&entry);
+			dependency_manager.dependencies_map[&entry].insert(user_type_catalog);
 		}
 	}
 }
 
-void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table, ColumnDefinition &column,
+void CatalogSet::AdjustDependency(CatalogEntry &entry, TableCatalogEntry &table, ColumnDefinition &column,
                                   bool remove) {
 	bool found = false;
 	if (column.Type().id() == LogicalTypeId::ENUM) {
-		for (auto &old_column : table->GetColumns().Logical()) {
+		for (auto &old_column : table.GetColumns().Logical()) {
 			if (old_column.Name() == column.Name() && old_column.Type().id() != LogicalTypeId::ENUM) {
 				AdjustUserDependency(entry, column, remove);
 				found = true;
@@ -575,7 +575,7 @@ void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table,
 		}
 	} else if (!(column.Type().GetAlias().empty())) {
 		auto alias = column.Type().GetAlias();
-		for (auto &old_column : table->GetColumns().Logical()) {
+		for (auto &old_column : table.GetColumns().Logical()) {
 			auto old_alias = old_column.Type().GetAlias();
 			if (old_column.Name() == column.Name() && old_alias != alias) {
 				AdjustUserDependency(entry, column, remove);
@@ -588,24 +588,24 @@ void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table,
 	}
 }
 
-void CatalogSet::AdjustTableDependencies(CatalogEntry *entry) {
-	if (entry->type == CatalogType::TABLE_ENTRY && entry->parent->type == CatalogType::TABLE_ENTRY) {
+void CatalogSet::AdjustTableDependencies(CatalogEntry &entry) {
+	if (entry.type == CatalogType::TABLE_ENTRY && entry.parent->type == CatalogType::TABLE_ENTRY) {
 		// If it's a table entry we have to check for possibly removing or adding user type dependencies
-		auto old_table = (TableCatalogEntry *)entry->parent;
-		auto new_table = (TableCatalogEntry *)entry;
+		auto &old_table = entry.parent->Cast<TableCatalogEntry>();
+		auto &new_table = entry.Cast<TableCatalogEntry>();
 
-		for (idx_t i = 0; i < new_table->GetColumns().LogicalColumnCount(); i++) {
-			auto &new_column = new_table->GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
+		for (idx_t i = 0; i < new_table.GetColumns().LogicalColumnCount(); i++) {
+			auto &new_column = new_table.GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
 			AdjustDependency(entry, old_table, new_column, false);
 		}
-		for (idx_t i = 0; i < old_table->GetColumns().LogicalColumnCount(); i++) {
-			auto &old_column = old_table->GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
+		for (idx_t i = 0; i < old_table.GetColumns().LogicalColumnCount(); i++) {
+			auto &old_column = old_table.GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
 			AdjustDependency(entry, new_table, old_column, true);
 		}
 	}
 }
 
-void CatalogSet::Undo(CatalogEntry *entry) {
+void CatalogSet::Undo(CatalogEntry &entry) {
 	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	lock_guard<mutex> lock(catalog_lock);
 
@@ -613,7 +613,7 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 	// and entry->parent has to be removed ("rolled back")
 
 	// i.e. we have to place (entry) as (entry->parent) again
-	auto &to_be_removed_node = entry->parent;
+	auto &to_be_removed_node = entry.parent;
 
 	AdjustTableDependencies(entry);
 
@@ -622,7 +622,7 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 		auto &dependency_manager = catalog.GetDependencyManager();
 		dependency_manager.EraseObject(to_be_removed_node);
 	}
-	if (entry->name != to_be_removed_node->name) {
+	if (entry.name != to_be_removed_node->name) {
 		// rename: clean up the new name when the rename is rolled back
 		auto removed_entry = mapping.find(to_be_removed_node->name);
 		if (removed_entry->second->child) {
@@ -636,21 +636,21 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 		// if the to be removed node has a parent, set the child pointer to the
 		// to be restored node
 		to_be_removed_node->parent->child = std::move(to_be_removed_node->child);
-		entry->parent = to_be_removed_node->parent;
+		entry.parent = to_be_removed_node->parent;
 	} else {
 		// otherwise we need to update the base entry tables
-		auto &name = entry->name;
+		auto &name = entry.name;
 		to_be_removed_node->child->SetAsRoot();
 		mapping[name]->index.GetEntry() = std::move(to_be_removed_node->child);
-		entry->parent = nullptr;
+		entry.parent = nullptr;
 	}
 
 	// restore the name if it was deleted
-	auto restored_entry = mapping.find(entry->name);
-	if (restored_entry->second->deleted || entry->type == CatalogType::INVALID) {
+	auto restored_entry = mapping.find(entry.name);
+	if (restored_entry->second->deleted || entry.type == CatalogType::INVALID) {
 		if (restored_entry->second->child) {
 			restored_entry->second->child->parent = nullptr;
-			mapping[entry->name] = std::move(restored_entry->second->child);
+			mapping[entry.name] = std::move(restored_entry->second->child);
 		} else {
 			mapping.erase(restored_entry);
 		}

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -10,6 +10,7 @@
 namespace duckdb {
 
 static DefaultMacro internal_macros[] = {
+	{DEFAULT_SCHEMA, "current_role", {nullptr}, "'duckdb'"},                       // user name of current execution context
 	{DEFAULT_SCHEMA, "current_user", {nullptr}, "'duckdb'"},                       // user name of current execution context
 	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, "current_database()"},          // name of current database (called "catalog" in the SQL standard)
 	{DEFAULT_SCHEMA, "user", {nullptr}, "current_user"},                           // equivalent to current_user
@@ -169,7 +170,7 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 	D_ASSERT(parser.statements.size() == 1);
 	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
 
-	auto &select = (SelectStatement &) *parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	auto result = make_uniq<TableMacroFunction>(std::move(select.node));
 	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -106,11 +106,11 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 	vector<CatalogEntry *> to_delete;
 	for (auto &dependency : old_dependencies) {
 		if (dependency->type == CatalogType::TYPE_ENTRY) {
-			auto user_type = (TypeCatalogEntry *)dependency;
-			auto table = (TableCatalogEntry *)new_obj;
+			auto &user_type = dependency->Cast<TypeCatalogEntry>();
+			auto &table = new_obj->Cast<TableCatalogEntry>();
 			bool deleted_dependency = true;
-			for (auto &column : table->GetColumns().Logical()) {
-				if (column.Type() == user_type->user_type) {
+			for (auto &column : table.GetColumns().Logical()) {
+				if (column.Type() == user_type.user_type) {
 					deleted_dependency = false;
 					break;
 				}

package/src/duckdb/src/common/enums/logical_operator_type.cpp

@@ -122,6 +122,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		return "CUSTOM_OP";
+	case LogicalOperatorType::LOGICAL_PIVOT:
+		return "PIVOT";
 	}
 	return "INVALID";
 }

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -139,6 +139,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "RESULT_COLLECTOR";
 	case PhysicalOperatorType::EXTENSION:
 		return "EXTENSION";
+	case PhysicalOperatorType::PIVOT:
+		return "PIVOT";
 	case PhysicalOperatorType::INVALID:
 		break;
 	}

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -40,7 +40,7 @@ static unordered_map<column_t, string> GetKnownColumnValues(string &filename,
 static void ConvertKnownColRefToConstants(unique_ptr<Expression> &expr,
                                           unordered_map<column_t, string> &known_column_values, idx_t table_index) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)*expr;
+		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 
 		// This bound column ref is for another table
 		if (table_index != bound_colref.binding.table_index) {

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -342,7 +342,7 @@ HivePartitioningIndex HivePartitioningIndex::Deserialize(Deserializer &source) {
 	return HivePartitioningIndex(std::move(value), index);
 }
 
-void MultiFileReaderOptions::AddBatchInfo(BindInfo &bind_info) {
+void MultiFileReaderOptions::AddBatchInfo(BindInfo &bind_info) const {
 	bind_info.InsertOption("filename", Value::BOOLEAN(filename));
 	bind_info.InsertOption("hive_partitioning", Value::BOOLEAN(hive_partitioning));
 	bind_info.InsertOption("union_by_name", Value::BOOLEAN(union_by_name));

package/src/duckdb/src/common/row_operations/row_aggregate.cpp

@@ -57,6 +57,9 @@ void RowOperations::UpdateStates(AggregateObject &aggr, Vector &addresses, DataC
 void RowOperations::UpdateFilteredStates(AggregateFilterData &filter_data, AggregateObject &aggr, Vector &addresses,
                                          DataChunk &payload, idx_t arg_idx) {
 	idx_t count = filter_data.ApplyFilter(payload);
+	if (count == 0) {
+		return;
+	}
 
 	Vector filtered_addresses(addresses, filter_data.true_sel, count);
 	filtered_addresses.Flatten(count);

package/src/duckdb/src/common/string_util.cpp

@@ -184,12 +184,34 @@ string StringUtil::Upper(const string &str) {
 
 string StringUtil::Lower(const string &str) {
 	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return std::tolower(c); });
+	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return StringUtil::CharacterToLower(c); });
 	return (copy);
 }
 
+// Jenkins hash function: https://en.wikipedia.org/wiki/Jenkins_hash_function
+uint64_t StringUtil::CIHash(const string &str) {
+	uint32_t hash = 0;
+	for (auto c : str) {
+		hash += StringUtil::CharacterToLower(c);
+		hash += hash << 10;
+		hash ^= hash >> 6;
+	}
+	hash += hash << 3;
+	hash ^= hash >> 11;
+	hash += hash << 15;
+	return hash;
+}
+
 bool StringUtil::CIEquals(const string &l1, const string &l2) {
-	return StringUtil::Lower(l1) == StringUtil::Lower(l2);
+	if (l1.size() != l2.size()) {
+		return false;
+	}
+	for (idx_t c = 0; c < l1.size(); c++) {
+		if (StringUtil::CharacterToLower(l1[c]) != StringUtil::CharacterToLower(l2[c])) {
+			return false;
+		}
+	}
+	return true;
 }
 
 vector<string> StringUtil::Split(const string &input, const string &split) {