duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

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

@@ -5,7 +5,6 @@
 #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 +17,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

@@ -25,6 +25,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 +54,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,24 @@ 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 &source) {
+	return CreateInfo::Deserialize(source);
+}
+
+void CatalogEntry::FormatSerialize(FormatSerializer &serializer) const {
+	const auto info = GetInfo();
+	info->FormatSerialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::FormatDeserialize(FormatDeserializer &deserializer) {
+	return CreateInfo::FormatDeserialize(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

@@ -543,67 +543,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 +553,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')"},
@@ -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));