duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

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

@@ -4,94 +4,18 @@
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/catalog/default/builtin_types/types.hpp"
 
 namespace duckdb {
 
-struct DefaultType {
-	const char *name;
-	LogicalTypeId type;
-};
-
-static DefaultType internal_types[] = {{"int", LogicalTypeId::INTEGER},
-                                       {"int4", LogicalTypeId::INTEGER},
-                                       {"signed", LogicalTypeId::INTEGER},
-                                       {"integer", LogicalTypeId::INTEGER},
-                                       {"integral", LogicalTypeId::INTEGER},
-                                       {"int32", LogicalTypeId::INTEGER},
-                                       {"varchar", LogicalTypeId::VARCHAR},
-                                       {"bpchar", LogicalTypeId::VARCHAR},
-                                       {"text", LogicalTypeId::VARCHAR},
-                                       {"string", LogicalTypeId::VARCHAR},
-                                       {"char", LogicalTypeId::VARCHAR},
-                                       {"nvarchar", LogicalTypeId::VARCHAR},
-                                       {"bytea", LogicalTypeId::BLOB},
-                                       {"blob", LogicalTypeId::BLOB},
-                                       {"varbinary", LogicalTypeId::BLOB},
-                                       {"binary", LogicalTypeId::BLOB},
-                                       {"bit", LogicalTypeId::BIT},
-                                       {"bitstring", LogicalTypeId::BIT},
-                                       {"int8", LogicalTypeId::BIGINT},
-                                       {"bigint", LogicalTypeId::BIGINT},
-                                       {"int64", LogicalTypeId::BIGINT},
-                                       {"long", LogicalTypeId::BIGINT},
-                                       {"oid", LogicalTypeId::BIGINT},
-                                       {"int2", LogicalTypeId::SMALLINT},
-                                       {"smallint", LogicalTypeId::SMALLINT},
-                                       {"short", LogicalTypeId::SMALLINT},
-                                       {"int16", LogicalTypeId::SMALLINT},
-                                       {"timestamp", LogicalTypeId::TIMESTAMP},
-                                       {"datetime", LogicalTypeId::TIMESTAMP},
-                                       {"timestamp_us", LogicalTypeId::TIMESTAMP},
-                                       {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
-                                       {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
-                                       {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
-                                       {"bool", LogicalTypeId::BOOLEAN},
-                                       {"boolean", LogicalTypeId::BOOLEAN},
-                                       {"logical", LogicalTypeId::BOOLEAN},
-                                       {"decimal", LogicalTypeId::DECIMAL},
-                                       {"dec", LogicalTypeId::DECIMAL},
-                                       {"numeric", LogicalTypeId::DECIMAL},
-                                       {"real", LogicalTypeId::FLOAT},
-                                       {"float4", LogicalTypeId::FLOAT},
-                                       {"float", LogicalTypeId::FLOAT},
-                                       {"double", LogicalTypeId::DOUBLE},
-                                       {"float8", LogicalTypeId::DOUBLE},
-                                       {"tinyint", LogicalTypeId::TINYINT},
-                                       {"int1", LogicalTypeId::TINYINT},
-                                       {"date", LogicalTypeId::DATE},
-                                       {"time", LogicalTypeId::TIME},
-                                       {"interval", LogicalTypeId::INTERVAL},
-                                       {"hugeint", LogicalTypeId::HUGEINT},
-                                       {"int128", LogicalTypeId::HUGEINT},
-                                       {"uuid", LogicalTypeId::UUID},
-                                       {"guid", LogicalTypeId::UUID},
-                                       {"struct", LogicalTypeId::STRUCT},
-                                       {"row", LogicalTypeId::STRUCT},
-                                       {"list", LogicalTypeId::LIST},
-                                       {"map", LogicalTypeId::MAP},
-                                       {"utinyint", LogicalTypeId::UTINYINT},
-                                       {"uint8", LogicalTypeId::UTINYINT},
-                                       {"usmallint", LogicalTypeId::USMALLINT},
-                                       {"uint16", LogicalTypeId::USMALLINT},
-                                       {"uinteger", LogicalTypeId::UINTEGER},
-                                       {"uint32", LogicalTypeId::UINTEGER},
-                                       {"ubigint", LogicalTypeId::UBIGINT},
-                                       {"uint64", LogicalTypeId::UBIGINT},
-                                       {"union", LogicalTypeId::UNION},
-                                       {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
-                                       {"timetz", LogicalTypeId::TIME_TZ},
-                                       {"enum", LogicalTypeId::ENUM},
-                                       {"null", LogicalTypeId::SQLNULL},
-                                       {nullptr, LogicalTypeId::INVALID}};
-
 LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) {
-	auto lower_str = StringUtil::Lower(name);
-	for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
-		if (internal_types[index].name == lower_str) {
-			return internal_types[index].type;
+	auto &internal_types = BUILTIN_TYPES;
+	for (auto &type : internal_types) {
+		if (StringUtil::CIEquals(name, type.name)) {
+			return type.type;
 		}
 	}
-	return LogicalTypeId::INVALID;
+	return LogicalType::INVALID;
 }
 
 DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
@@ -119,8 +43,9 @@ vector<string> DefaultTypeGenerator::GetDefaultEntries() {
 	if (schema.name != DEFAULT_SCHEMA) {
 		return result;
 	}
-	for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
-		result.emplace_back(internal_types[index].name);
+	auto &internal_types = BUILTIN_TYPES;
+	for (auto &type : internal_types) {
+		result.emplace_back(StringUtil::Lower(type.name));
 	}
 	return result;
 }

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

@@ -220,8 +220,8 @@ void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntr
 	// Emplace guarantees that the same object cannot be inserted twice in the unordered_set
 	// In the case AddOwnership is called twice, because of emplace, the object will not be repeated in the set.
 	// We use an automatic dependency because if the Owner gets deleted, then the owned objects are also deleted
-	dependents_map[owner].emplace(Dependency(entry, DependencyType::DEPENDENCY_OWNS));
-	dependents_map[entry].emplace(Dependency(owner, DependencyType::DEPENDENCY_OWNED_BY));
+	dependents_map[owner].emplace(entry, DependencyType::DEPENDENCY_OWNS);
+	dependents_map[entry].emplace(owner, DependencyType::DEPENDENCY_OWNED_BY);
 	dependencies_map[owner].emplace(entry);
 }
 

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

@@ -142,6 +142,7 @@ string DuckCatalog::GetDBPath() {
 
 void DuckCatalog::Verify() {
 #ifdef DEBUG
+	Catalog::Verify();
 	schemas->Verify(*this);
 #endif
 }