duckdb 0.8.2-dev87.0 → 0.9.0

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

@@ -2,7 +2,6 @@
 
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
 #include "duckdb/catalog/dependency_manager.hpp"
 
@@ -18,34 +17,17 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry
 	this->temporary = info.temporary;
 }
 
-void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteField<uint64_t>(usage_count);
-	writer.WriteField<int64_t>(increment);
-	writer.WriteField<int64_t>(min_value);
-	writer.WriteField<int64_t>(max_value);
-	writer.WriteField<int64_t>(counter);
-	writer.WriteField<bool>(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSequenceInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->usage_count = reader.ReadRequired<uint64_t>();
-	info->increment = reader.ReadRequired<int64_t>();
-	info->min_value = reader.ReadRequired<int64_t>();
-	info->max_value = reader.ReadRequired<int64_t>();
-	info->start_value = reader.ReadRequired<int64_t>();
-	info->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSequenceInfo>();
+	result->schema = schema.name;
+	result->name = name;
+	result->usage_count = usage_count;
+	result->increment = increment;
+	result->min_value = min_value;
+	result->max_value = max_value;
+	result->start_value = counter;
+	result->cycle = cycle;
+	return std::move(result);
 }
 
 string SequenceCatalogEntry::ToSQL() const {

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

@@ -4,8 +4,6 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/constraints/list.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
@@ -56,42 +54,16 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
-CreateTableInfo TableCatalogEntry::GetTableInfoForSerialization() const {
-	CreateTableInfo result;
-	result.catalog = catalog.GetName();
-	result.schema = schema.name;
-	result.table = name;
-	result.columns = columns.Copy();
-	result.constraints.reserve(constraints.size());
+unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTableInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->table = name;
+	result->columns = columns.Copy();
+	result->constraints.reserve(constraints.size());
 	std::for_each(constraints.begin(), constraints.end(),
-	              [&result](const unique_ptr<Constraint> &c) { result.constraints.emplace_back(c->Copy()); });
-	return result;
-}
-
-void TableCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	const auto info = GetTableInfoForSerialization();
-	FieldWriter writer(serializer);
-	writer.WriteString(info.catalog);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	info.columns.Serialize(writer);
-	writer.WriteSerializableList(info.constraints);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateTableInfo>();
-
-	FieldReader reader(source);
-	info->catalog = reader.ReadRequired<string>();
-	info->schema = reader.ReadRequired<string>();
-	info->table = reader.ReadRequired<string>();
-	info->columns = ColumnList::Deserialize(reader);
-	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	reader.Finalize();
-
-	return info;
+	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
+	return std::move(result);
 }
 
 string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
@@ -162,11 +134,10 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			// single column unique: insert constraint here
 			ss << " UNIQUE";
 		}
-		if (column.DefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
-		}
 		if (column.Generated()) {
 			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
+		} else if (column.DefaultValue()) {
+			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
 		}
 	}
 	// print any extra constraints that still need to be printed
@@ -199,10 +170,6 @@ const ColumnList &TableCatalogEntry::GetColumns() const {
 	return columns;
 }
 
-ColumnList &TableCatalogEntry::GetColumnsMutable() {
-	return columns;
-}
-
 const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
 	return columns.GetColumn(idx);
 }

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

@@ -1,12 +1,9 @@
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/common/types/vector.hpp"
 #include <algorithm>
 #include <sstream>
 
@@ -18,31 +15,13 @@ TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
 	this->internal = info.internal;
 }
 
-void TypeCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	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_uniq<CreateTypeInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTypeInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->name = name;
+	result->type = user_type;
+	return std::move(result);
 }
 
 string TypeCatalogEntry::ToSQL() const {

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

@@ -2,7 +2,6 @@
 
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/common/limits.hpp"
@@ -25,6 +24,17 @@ ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
 	Initialize(info);
 }
 
+unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateViewInfo>();
+	result->schema = schema.name;
+	result->view_name = name;
+	result->sql = sql;
+	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->aliases = aliases;
+	result->types = types;
+	return std::move(result);
+}
+
 unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
 	if (info.type != AlterType::ALTER_VIEW) {
@@ -43,33 +53,6 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 	}
 }
 
-void ViewCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteSerializable(*query);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList<LogicalType>(types);
-	writer.Finalize();
-}
-
-unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateViewInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->view_name = reader.ReadRequired<string>();
-	info->sql = reader.ReadRequired<string>();
-	info->query = reader.ReadRequiredSerializable<SelectStatement>();
-	info->aliases = reader.ReadRequiredList<string>();
-	info->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
-}
-
 string ViewCatalogEntry::ToSQL() const {
 	if (sql.empty()) {
 		//! Return empty sql with view name so pragma view_tables don't complain

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

@@ -1,6 +1,8 @@
 #include "duckdb/catalog/catalog_entry.hpp"
-
+#include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -31,6 +33,10 @@ unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 	throw InternalException("Unsupported copy type for catalog entry!");
 }
 
+unique_ptr<CreateInfo> CatalogEntry::GetInfo() const {
+	throw InternalException("Unsupported type for CatalogEntry::GetInfo!");
+}
+
 string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
@@ -44,6 +50,15 @@ SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 }
 // LCOV_EXCL_STOP
 
+void CatalogEntry::Serialize(Serializer &serializer) const {
+	const auto info = GetInfo();
+	info->Serialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &deserializer) {
+	return CreateInfo::Deserialize(deserializer);
+}
+
 void CatalogEntry::Verify(Catalog &catalog_p) {
 }
 

package/src/duckdb/src/catalog/catalog_search_path.cpp

@@ -1,10 +1,10 @@
 #include "duckdb/catalog/catalog_search_path.hpp"
 
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/client_context.hpp"
-#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
@@ -249,13 +249,14 @@ void CatalogSearchPath::SetPaths(vector<CatalogSearchEntry> new_paths) {
 bool CatalogSearchPath::SchemaInSearchPath(ClientContext &context, const string &catalog_name,
                                            const string &schema_name) {
 	for (auto &path : paths) {
-		if (path.schema != schema_name) {
+		if (!StringUtil::CIEquals(path.schema, schema_name)) {
 			continue;
 		}
-		if (path.catalog == catalog_name) {
+		if (StringUtil::CIEquals(path.catalog, catalog_name)) {
 			return true;
 		}
-		if (IsInvalidCatalog(path.catalog) && catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
+		if (IsInvalidCatalog(path.catalog) &&
+		    StringUtil::CIEquals(catalog_name, DatabaseManager::GetDefaultDatabase(context))) {
 			return true;
 		}
 	}

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

@@ -1,18 +1,18 @@
 #include "duckdb/catalog/catalog_set.hpp"
 
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/catalog/mapping_value.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/catalog/mapping_value.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {
 
@@ -252,15 +252,17 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	PutEntry(std::move(entry_index), std::move(value));
 
 	// serialize the AlterInfo into a temporary buffer
-	BufferedSerializer serializer;
-	serializer.WriteString(alter_info.GetColumnName());
-	alter_info.Serialize(serializer);
-	BinaryData serialized_alter = serializer.GetData();
+	MemoryStream stream;
+	BinarySerializer serializer(stream);
+	serializer.Begin();
+	serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());
+	serializer.WriteProperty(101, "alter_info", &alter_info);
+	serializer.End();
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-		dtransaction.PushCatalogEntry(*new_entry->child, serialized_alter.data.get(), serialized_alter.size);
+		dtransaction.PushCatalogEntry(*new_entry->child, stream.GetData(), stream.GetPosition());
 	}
 
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
@@ -543,67 +545,6 @@ void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
 	mapping[entry.name]->timestamp = timestamp;
 }
 
-void CatalogSet::AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove) {
-	auto user_type_catalog_p = EnumType::GetCatalog(column.Type());
-	if (!user_type_catalog_p) {
-		return;
-	}
-	auto &user_type_catalog = user_type_catalog_p->Cast<CatalogEntry>();
-	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,
-                                  bool remove) {
-	bool found = false;
-	if (column.Type().id() == LogicalTypeId::ENUM) {
-		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;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	} else if (!(column.Type().GetAlias().empty())) {
-		auto alias = column.Type().GetAlias();
-		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);
-				found = true;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	}
-}
-
-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 = 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));
-			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));
-			AdjustDependency(entry, new_table, old_column, true);
-		}
-	}
-}
-
 void CatalogSet::Undo(CatalogEntry &entry) {
 	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	lock_guard<mutex> lock(catalog_lock);
@@ -614,8 +555,6 @@ void CatalogSet::Undo(CatalogEntry &entry) {
 	// i.e. we have to place (entry) as (entry->parent) again
 	auto &to_be_removed_node = *entry.parent;
 
-	AdjustTableDependencies(entry);
-
 	if (!to_be_removed_node.deleted) {
 		// delete the entry from the dependency manager as well
 		auto &dependency_manager = catalog.GetDependencyManager();

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

@@ -98,6 +98,24 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
 	{DEFAULT_SCHEMA, "count_if", {"l", nullptr}, "sum(if(l, 1, 0))"},
 	{DEFAULT_SCHEMA, "split_part", {"string", "delimiter", "position", nullptr}, "coalesce(string_split(string, delimiter)[position],'')"},
+	{DEFAULT_SCHEMA, "geomean", {"x", nullptr}, "exp(avg(ln(x)))"},
+	{DEFAULT_SCHEMA, "geometric_mean", {"x", nullptr}, "geomean(x)"},
+
+    {DEFAULT_SCHEMA, "list_reverse", {"l", nullptr}, "l[:-:-1]"},
+    {DEFAULT_SCHEMA, "array_reverse", {"l", nullptr}, "list_reverse(l)"},
+
+    // FIXME implement as actual function if we encounter a lot of performance issues. Complexity now: n * m, with hashing possibly n + m
+    {DEFAULT_SCHEMA, "list_intersect", {"l1", "l2", nullptr}, "list_filter(l1, (x) -> list_contains(l2, x))"},
+    {DEFAULT_SCHEMA, "array_intersect", {"l1", "l2", nullptr}, "list_intersect(l1, l2)"},
+
+    {DEFAULT_SCHEMA, "list_has_any", {"l1", "l2", nullptr}, "CASE WHEN l1 IS NULL THEN NULL WHEN l2 IS NULL THEN NULL WHEN len(list_intersect(l1, l2)) > 0 THEN true ELSE false END"},
+    {DEFAULT_SCHEMA, "array_has_any", {"l1", "l2", nullptr}, "list_has_any(l1, l2)" },
+    {DEFAULT_SCHEMA, "&&", {"l1", "l2", nullptr}, "list_has_any(l1, l2)" }, // "&&" is the operator for "list_has_any
+
+    {DEFAULT_SCHEMA, "list_has_all", {"l1", "l2", nullptr}, "CASE WHEN l1 IS NULL THEN NULL WHEN l2 IS NULL THEN NULL WHEN len(list_intersect(l2, l1)) = len(list_filter(l2, x -> x IS NOT NULL)) THEN true ELSE false END"},
+    {DEFAULT_SCHEMA, "array_has_all", {"l1", "l2", nullptr}, "list_has_all(l1, l2)" },
+    {DEFAULT_SCHEMA, "@>", {"l1", "l2", nullptr}, "list_has_all(l1, l2)" }, // "@>" is the operator for "list_has_all
+    {DEFAULT_SCHEMA, "<@", {"l1", "l2", nullptr}, "list_has_all(l2, l1)" }, // "<@" is the operator for "list_has_all
 
 	// algebraic list aggregates
 	{DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, "list_aggr(l, 'avg')"},
@@ -147,12 +165,12 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 		    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
 	}
 
-	auto bind_info = make_uniq<CreateMacroInfo>();
+	auto type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
+	auto bind_info = make_uniq<CreateMacroInfo>(type);
 	bind_info->schema = default_macro.schema;
 	bind_info->name = default_macro.name;
 	bind_info->temporary = true;
 	bind_info->internal = true;
-	bind_info->type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
 	bind_info->function = std::move(function);
 	return bind_info;
 
@@ -205,6 +223,9 @@ 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 (StringUtil::Lower(internal_macros[index].name) != internal_macros[index].name) {
+			throw InternalException("Default macro name %s should be lowercase", internal_macros[index].name);
+		}
 		if (internal_macros[index].schema == schema.name) {
 			result.emplace_back(internal_macros[index].name);
 		}

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

@@ -106,52 +106,16 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 	}
 	// add the new object to the dependents_map of each object that it depends on
 	auto &old_dependencies = dependencies_map[old_obj];
-	catalog_entry_vector_t to_delete;
 	for (auto &dep : old_dependencies) {
 		auto &dependency = dep.get();
-		if (dependency.type == CatalogType::TYPE_ENTRY) {
-			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) {
-					deleted_dependency = false;
-					break;
-				}
-			}
-			if (deleted_dependency) {
-				to_delete.push_back(dependency);
-				continue;
-			}
-		}
 		dependents_map[dependency].insert(new_obj);
 	}
-	for (auto &dep : to_delete) {
-		auto &dependency = dep.get();
-		old_dependencies.erase(dependency);
-		dependents_map[dependency].erase(old_obj);
-	}
 
 	// We might have to add a type dependency
-	catalog_entry_vector_t to_add;
-	if (new_obj.type == CatalogType::TABLE_ENTRY) {
-		auto &table = new_obj.Cast<TableCatalogEntry>();
-		for (auto &column : table.GetColumns().Logical()) {
-			auto user_type_catalog = EnumType::GetCatalog(column.Type());
-			if (user_type_catalog) {
-				to_add.push_back(*user_type_catalog);
-			}
-		}
-	}
 	// add the new object to the dependency manager
 	dependents_map[new_obj] = dependency_set_t();
 	dependencies_map[new_obj] = old_dependencies;
 
-	for (auto &dependency : to_add) {
-		dependencies_map[new_obj].insert(dependency);
-		dependents_map[dependency].insert(new_obj);
-	}
-
 	for (auto &dependency : owned_objects_to_add) {
 		dependents_map[new_obj].insert(Dependency(dependency, DependencyType::DEPENDENCY_OWNS));
 		dependents_map[dependency].insert(Dependency(new_obj, DependencyType::DEPENDENCY_OWNED_BY));

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -132,6 +132,10 @@ DatabaseSize DuckCatalog::GetDatabaseSize(ClientContext &context) {
 	return db.GetStorageManager().GetDatabaseSize();
 }
 
+vector<MetadataBlockInfo> DuckCatalog::GetMetadataInfo(ClientContext &context) {
+	return db.GetStorageManager().GetMetadataInfo();
+}
+
 bool DuckCatalog::InMemory() {
 	return db.GetStorageManager().InMemory();
 }