duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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);
@@ -38,12 +38,12 @@ void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) {
 }
 
 unique_ptr<CreateMacroInfo> ScalarMacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
-	auto info = make_unique<CreateMacroInfo>(CatalogType::MACRO_ENTRY);
+	auto info = make_uniq<CreateMacroInfo>(CatalogType::MACRO_ENTRY);
 	FieldReader reader(main_source);
 	info->schema = reader.ReadRequired<string>();
 	info->name = reader.ReadRequired<string>();
 	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto func = make_unique<ScalarMacroFunction>(std::move(expression));
+	auto func = make_uniq<ScalarMacroFunction>(std::move(expression));
 	info->function = std::move(func);
 	info->function->parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
 	auto default_param_count = reader.ReadRequired<uint32_t>();
@@ -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);
 
@@ -81,12 +81,12 @@ void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) {
 }
 
 unique_ptr<CreateMacroInfo> TableMacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
-	auto info = make_unique<CreateMacroInfo>(CatalogType::TABLE_MACRO_ENTRY);
+	auto info = make_uniq<CreateMacroInfo>(CatalogType::TABLE_MACRO_ENTRY);
 	FieldReader reader(main_source);
 	info->schema = reader.ReadRequired<string>();
 	info->name = reader.ReadRequired<string>();
 	auto query_node = reader.ReadRequiredSerializable<QueryNode>();
-	auto table_function = make_unique<TableMacroFunction>(std::move(query_node));
+	auto table_function = make_uniq<TableMacroFunction>(std::move(query_node));
 	info->function = std::move(table_function);
 	info->function->parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
 	auto default_param_count = reader.ReadRequired<uint32_t>();

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

@@ -33,14 +33,14 @@ 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();
 }
 
 unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateSchemaInfo>();
+	auto info = make_uniq<CreateSchemaInfo>();
 
 	FieldReader reader(source);
 	info->schema = reader.ReadRequired<string>();
@@ -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);
@@ -32,7 +32,7 @@ void SequenceCatalogEntry::Serialize(Serializer &serializer) {
 }
 
 unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateSequenceInfo>();
+	auto info = make_uniq<CreateSequenceInfo>();
 
 	FieldReader reader(source);
 	info->schema = reader.ReadRequired<string>();
@@ -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);
@@ -63,7 +63,7 @@ void TableCatalogEntry::Serialize(Serializer &serializer) {
 }
 
 unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_unique<CreateTableInfo>();
+	auto info = make_uniq<CreateTableInfo>();
 
 	FieldReader reader(source);
 	info->schema = reader.ReadRequired<string>();
@@ -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 ";
@@ -193,14 +193,10 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 }
 
 DataTable &TableCatalogEntry::GetStorage() {
-	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DTableCatalogEntry");
-}
-
-DataTable *TableCatalogEntry::GetStoragePtr() {
-	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
-	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
 } // namespace duckdb

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

@@ -26,7 +26,7 @@ unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &co
 		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
 	}
 	CreateTableFunctionInfo new_info(std::move(new_set));
-	return make_unique<TableFunctionCatalogEntry>(catalog, schema, &new_info);
+	return make_uniq<TableFunctionCatalogEntry>(catalog, schema, &new_info);
 }
 
 } // namespace duckdb

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

@@ -18,17 +18,23 @@ 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);
 	writer.WriteString(name);
-	writer.WriteSerializable(user_type);
+	if (user_type.id() == LogicalTypeId::ENUM) {
+		// We have to serialize Enum Values
+		writer.AddField();
+		user_type.SerializeEnumType(writer.GetSerializer());
+	} else {
+		writer.WriteSerializable(user_type);
+	}
 	writer.Finalize();
 }
 
 unique_ptr<CreateTypeInfo> TypeCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateTypeInfo>();
+	auto info = make_uniq<CreateTypeInfo>();
 
 	FieldReader reader(source);
 	info->schema = reader.ReadRequired<string>();
@@ -39,11 +45,11 @@ 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): {
-		Vector values_insert_order(EnumType::GetValuesInsertOrder(user_type));
+		auto &values_insert_order = EnumType::GetValuesInsertOrder(user_type);
 		idx_t size = EnumType::GetSize(user_type);
 		ss << "CREATE TYPE ";
 		ss << KeywordHelper::WriteOptionallyQuoted(name);

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);
@@ -56,7 +56,7 @@ void ViewCatalogEntry::Serialize(Serializer &serializer) {
 }
 
 unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_unique<CreateViewInfo>();
+	auto info = make_uniq<CreateViewInfo>();
 
 	FieldReader reader(source);
 	info->schema = reader.ReadRequired<string>();
@@ -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,9 +78,9 @@ 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_unique<CreateViewInfo>(schema, name);
+	auto create_info = make_uniq<CreateViewInfo>(schema, name);
 	create_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 	for (idx_t i = 0; i < aliases.size(); i++) {
 		create_info->aliases.push_back(aliases[i]);
@@ -91,7 +91,7 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) {
 	create_info->temporary = temporary;
 	create_info->sql = sql;
 
-	return make_unique<ViewCatalogEntry>(catalog, schema, create_info.get());
+	return make_uniq<ViewCatalogEntry>(catalog, schema, create_info.get());
 }
 
 } // namespace duckdb

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

@@ -106,7 +106,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 		// first create a dummy deleted entry for this entry
 		// so transactions started before the commit of this transaction don't
 		// see it yet
-		auto dummy_node = make_unique<CatalogEntry>(CatalogType::INVALID, value->catalog, name);
+		auto dummy_node = make_uniq<CatalogEntry>(CatalogType::INVALID, value->catalog, name);
 		dummy_node->timestamp = 0;
 		dummy_node->deleted = true;
 		dummy_node->set = this;
@@ -136,7 +136,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 	value->set = this;
 
 	// now add the dependency set of this object to the dependency manager
-	catalog.GetDependencyManager().AddObject(transaction, value.get(), dependencies);
+	catalog.GetDependencyManager().AddObject(transaction, *value, dependencies);
 
 	auto value_ptr = value.get();
 	EntryIndex entry_index(*this, index);
@@ -144,7 +144,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
-		dtransaction.PushCatalogEntry(value_ptr->child.get());
+		dtransaction.PushCatalogEntry(*value_ptr->child);
 	}
 	return true;
 }
@@ -196,7 +196,7 @@ bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipI
 		return false;
 	}
 
-	catalog.GetDependencyManager().AddOwnership(transaction, owner_entry, entry);
+	catalog.GetDependencyManager().AddOwnership(transaction, *owner_entry, *entry);
 
 	return true;
 }
@@ -258,20 +258,21 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 
 	// serialize the AlterInfo into a temporary buffer
 	BufferedSerializer serializer;
+	serializer.WriteString(alter_info->GetColumnName());
 	alter_info->Serialize(serializer);
 	BinaryData serialized_alter = serializer.GetData();
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
-		dtransaction.PushCatalogEntry(new_entry->child.get(), serialized_alter.data.get(), serialized_alter.size);
+		dtransaction.PushCatalogEntry(*new_entry->child, serialized_alter.data.get(), serialized_alter.size);
 	}
 
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
 	// Note that we do this AFTER the new entry has been entirely set up in the catalog set
 	// that is because in case the alter fails because of a dependency conflict, we need to be able to cleanly roll back
 	// to the old entry.
-	catalog.GetDependencyManager().AlterObject(transaction, entry, new_entry);
+	catalog.GetDependencyManager().AlterObject(transaction, *entry, *new_entry);
 
 	return true;
 }
@@ -286,7 +287,7 @@ void CatalogSet::DropEntryDependencies(CatalogTransaction transaction, EntryInde
 
 	// check any dependencies of this object
 	D_ASSERT(entry.catalog->IsDuckCatalog());
-	((DuckCatalog &)*entry.catalog).GetDependencyManager().DropObject(transaction, &entry, cascade);
+	((DuckCatalog &)*entry.catalog).GetDependencyManager().DropObject(transaction, entry, cascade);
 
 	// dropper destructor is called here
 	// the destructor makes sure to return the value to the previous state
@@ -300,7 +301,7 @@ void CatalogSet::DropEntryInternal(CatalogTransaction transaction, EntryIndex en
 	// create a new entry and replace the currently stored one
 	// set the timestamp to the timestamp of the current transaction
 	// and point it at the dummy node
-	auto value = make_unique<CatalogEntry>(CatalogType::DELETED_ENTRY, entry.catalog, entry.name);
+	auto value = make_uniq<CatalogEntry>(CatalogType::DELETED_ENTRY, entry.catalog, entry.name);
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
 	value->deleted = true;
@@ -310,7 +311,7 @@ void CatalogSet::DropEntryInternal(CatalogTransaction transaction, EntryIndex en
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
-		dtransaction.PushCatalogEntry(value_ptr->child.get());
+		dtransaction.PushCatalogEntry(*value_ptr->child);
 	}
 }
 
@@ -349,7 +350,7 @@ void CatalogSet::CleanupEntry(CatalogEntry *catalog_entry) {
 		if (!catalog_entry->deleted) {
 			// delete the entry from the dependency manager, if it is not deleted yet
 			D_ASSERT(catalog_entry->catalog->IsDuckCatalog());
-			((DuckCatalog &)*catalog_entry->catalog).GetDependencyManager().EraseObject(catalog_entry);
+			((DuckCatalog &)*catalog_entry->catalog).GetDependencyManager().EraseObject(*catalog_entry);
 		}
 		auto parent = catalog_entry->parent;
 		parent->child = std::move(catalog_entry->child);
@@ -394,7 +395,7 @@ MappingValue *CatalogSet::GetMapping(CatalogTransaction transaction, const strin
 
 void CatalogSet::PutMapping(CatalogTransaction transaction, const string &name, EntryIndex entry_index) {
 	auto entry = mapping.find(name);
-	auto new_value = make_unique<MappingValue>(std::move(entry_index));
+	auto new_value = make_uniq<MappingValue>(std::move(entry_index));
 	new_value->timestamp = transaction.transaction_id;
 	if (entry != mapping.end()) {
 		if (HasConflict(transaction, entry->second->timestamp)) {
@@ -409,7 +410,7 @@ void CatalogSet::PutMapping(CatalogTransaction transaction, const string &name,
 void CatalogSet::DeleteMapping(CatalogTransaction transaction, const string &name) {
 	auto entry = mapping.find(name);
 	D_ASSERT(entry != mapping.end());
-	auto delete_marker = make_unique<MappingValue>(entry->second->index.Copy());
+	auto delete_marker = make_uniq<MappingValue>(entry->second->index.Copy());
 	delete_marker->deleted = true;
 	delete_marker->timestamp = transaction.transaction_id;
 	delete_marker->child = std::move(entry->second);
@@ -540,30 +541,32 @@ 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) {
-	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);
-		} else {
-			dependency_manager.dependents_map[user_type_catalog].insert(entry);
-			dependency_manager.dependencies_map[entry].insert(user_type_catalog);
-		}
+void CatalogSet::AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove) {
+	CatalogEntry *user_type_catalog_p = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
+	if (!user_type_catalog_p) {
+		return;
+	}
+	auto &user_type_catalog = *user_type_catalog_p;
+	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);
+	} else {
+		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;
@@ -574,7 +577,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);
@@ -587,24 +590,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);
 
@@ -612,44 +615,44 @@ 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);
 
-	if (!to_be_removed_node->deleted) {
+	if (!to_be_removed_node.deleted) {
 		// delete the entry from the dependency manager as well
 		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);
+		auto removed_entry = mapping.find(to_be_removed_node.name);
 		if (removed_entry->second->child) {
 			removed_entry->second->child->parent = nullptr;
-			mapping[to_be_removed_node->name] = std::move(removed_entry->second->child);
+			mapping[to_be_removed_node.name] = std::move(removed_entry->second->child);
 		} else {
 			mapping.erase(removed_entry);
 		}
 	}
-	if (to_be_removed_node->parent) {
+	if (to_be_removed_node.parent) {
 		// 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;
+		to_be_removed_node.parent->child = std::move(to_be_removed_node.child);
+		entry.parent = to_be_removed_node.parent;
 	} else {
 		// otherwise we need to update the base entry tables
-		auto &name = entry->name;
-		to_be_removed_node->child->SetAsRoot();
-		mapping[name]->index.GetEntry() = std::move(to_be_removed_node->child);
-		entry->parent = nullptr;
+		auto &name = entry.name;
+		to_be_removed_node.child->SetAsRoot();
+		mapping[name]->index.GetEntry() = std::move(to_be_removed_node.child);
+		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
@@ -52,10 +53,10 @@ static DefaultMacro internal_macros[] = {
 
 	// various postgres system functions
 	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
-	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid/1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
+	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
 	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
 	{"pg_catalog", "format_pg_type", {"type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='ENUM' then lower(type_name) when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
-	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod/1000, ',', typemod%1000, ')') else '' end"},
+	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
 
 	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
 	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for role
@@ -131,16 +132,19 @@ static DefaultMacro internal_macros[] = {
 	// nested list aggregates
 	{DEFAULT_SCHEMA, "list_histogram", {"l", nullptr}, "list_aggr(l, 'histogram')"},
 
+	// date functions
+	{DEFAULT_SCHEMA, "date_add", {"date", "interval", nullptr}, "date + interval"},
+
 	{nullptr, nullptr, {nullptr}, nullptr}
 	};
 
 unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro, unique_ptr<MacroFunction> function) {
 	for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
 		function->parameters.push_back(
-		    make_unique<ColumnRefExpression>(default_macro.parameters[param_idx]));
+		    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
 	}
 
-	auto bind_info = make_unique<CreateMacroInfo>();
+	auto bind_info = make_uniq<CreateMacroInfo>();
 	bind_info->schema = default_macro.schema;
 	bind_info->name = default_macro.name;
 	bind_info->temporary = true;
@@ -156,7 +160,7 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(De
 	auto expressions = Parser::ParseExpressionList(default_macro.macro);
 	D_ASSERT(expressions.size() == 1);
 
-	auto result = make_unique<ScalarMacroFunction>(std::move(expressions[0]));
+	auto result = make_uniq<ScalarMacroFunction>(std::move(expressions[0]));
 	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }
 
@@ -166,8 +170,8 @@ 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 result = make_unique<TableMacroFunction>(std::move(select.node));
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
+	auto result = make_uniq<TableMacroFunction>(std::move(select.node));
 	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }
 
@@ -182,15 +186,15 @@ static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_sch
 	return nullptr;
 }
 
-DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
+DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
     : DefaultGenerator(catalog), schema(schema) {
 }
 
 unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientContext &context,
                                                                       const string &entry_name) {
-	auto info = GetDefaultFunction(schema->name, entry_name);
+	auto info = GetDefaultFunction(schema.name, entry_name);
 	if (info) {
-		return make_unique_base<CatalogEntry, ScalarMacroCatalogEntry>(&catalog, schema, (CreateMacroInfo *)info.get());
+		return make_uniq_base<CatalogEntry, ScalarMacroCatalogEntry>(&catalog, &schema, (CreateMacroInfo *)info.get());
 	}
 	return nullptr;
 }
@@ -198,7 +202,7 @@ unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientCont
 vector<string> DefaultFunctionGenerator::GetDefaultEntries() {
 	vector<string> result;
 	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (internal_macros[index].schema == schema->name) {
+		if (internal_macros[index].schema == schema.name) {
 			result.emplace_back(internal_macros[index].name);
 		}
 	}

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

@@ -25,7 +25,7 @@ DefaultSchemaGenerator::DefaultSchemaGenerator(Catalog &catalog) : DefaultGenera
 
 unique_ptr<CatalogEntry> DefaultSchemaGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
 	if (GetDefaultSchema(entry_name)) {
-		return make_unique_base<CatalogEntry, DuckSchemaEntry>(&catalog, StringUtil::Lower(entry_name), true);
+		return make_uniq_base<CatalogEntry, DuckSchemaEntry>(&catalog, StringUtil::Lower(entry_name), true);
 	}
 	return nullptr;
 }