duckdb 0.3.5-dev525.0 → 0.3.5-dev534.0

package/src/duckdb.cpp

@@ -463,6 +463,42 @@ private:
 };
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/type_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class Serializer;
+class Deserializer;
+
+//! A type catalog entry
+class TypeCatalogEntry : public StandardEntry {
+public:
+	//! Create a TypeCatalogEntry and initialize storage for it
+	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);
+
+	LogicalType user_type;
+
+public:
+	//! Serialize the meta information of the TypeCatalogEntry a serializer
+	virtual void Serialize(Serializer &serializer);
+	//! Deserializes to a TypeCatalogEntry
+	static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &source);
+
+	string ToSQL() override;
+};
+} // namespace duckdb
+
 
 
 //===----------------------------------------------------------------------===//
@@ -539,6 +575,37 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/default/default_types.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+class SchemaCatalogEntry;
+
+class DefaultTypeGenerator : public DefaultGenerator {
+public:
+	DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
+
+	SchemaCatalogEntry *schema;
+
+public:
+	DUCKDB_API static LogicalTypeId GetDefaultType(const string &name);
+
+	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
+	vector<string> GetDefaultEntries() override;
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 
@@ -883,6 +950,19 @@ CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &sch
 	                                       error_context);
 }
 
+template <>
+TypeCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                    bool if_exists, QueryErrorContext error_context) {
+	return (TypeCatalogEntry *)GetEntry(context, CatalogType::TYPE_ENTRY, schema_name, name, if_exists, error_context);
+}
+
+LogicalType Catalog::GetType(ClientContext &context, const string &schema, const string &name) {
+	auto user_type_catalog = GetEntry<TypeCatalogEntry>(context, schema, name);
+	auto result_type = user_type_catalog->user_type;
+	EnumType::SetCatalog(result_type, user_type_catalog);
+	return result_type;
+}
+
 void Catalog::Alter(ClientContext &context, AlterInfo *info) {
 	ModifyCatalog();
 	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name);
@@ -1441,41 +1521,6 @@ unique_ptr<CreateMacroInfo> TableMacroCatalogEntry::Deserialize(Deserializer &ma
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/type_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-
-//! A type catalog entry
-class TypeCatalogEntry : public StandardEntry {
-public:
-	//! Create a TypeCatalogEntry and initialize storage for it
-	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);
-
-	LogicalType user_type;
-
-public:
-	//! Serialize the meta information of the TypeCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a TypeCatalogEntry
-	static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &source);
-
-	string ToSQL() override;
-};
-} // namespace duckdb
 
 
 //===----------------------------------------------------------------------===//
@@ -1648,6 +1693,7 @@ public:
 
 
 
+
 #include <algorithm>
 #include <sstream>
 
@@ -1682,7 +1728,7 @@ SchemaCatalogEntry::SchemaCatalogEntry(Catalog *catalog, string name_p, bool int
       tables(*catalog, make_unique<DefaultViewGenerator>(*catalog, this)), indexes(*catalog), table_functions(*catalog),
       copy_functions(*catalog), pragma_functions(*catalog),
       functions(*catalog, make_unique<DefaultFunctionGenerator>(*catalog, this)), sequences(*catalog),
-      collations(*catalog), types(*catalog) {
+      collations(*catalog), types(*catalog, make_unique<DefaultTypeGenerator>(*catalog, this)) {
 	this->internal = internal;
 }
 
@@ -1735,8 +1781,8 @@ CatalogEntry *SchemaCatalogEntry::CreateSequence(ClientContext &context, CreateS
 }
 
 CatalogEntry *SchemaCatalogEntry::CreateType(ClientContext &context, CreateTypeInfo *info) {
-	auto sequence = make_unique<TypeCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(sequence), info->on_conflict);
+	auto type_entry = make_unique<TypeCatalogEntry>(catalog, this, info);
+	return AddEntry(context, move(type_entry), info->on_conflict);
 }
 
 CatalogEntry *SchemaCatalogEntry::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
@@ -3568,13 +3614,8 @@ unique_ptr<CatalogEntry> TableCatalogEntry::SetDefault(ClientContext &context, S
 
 unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
 	if (info.target_type.id() == LogicalTypeId::USER) {
-		auto &user_type_name = UserType::GetTypeName(info.target_type);
-		auto user_type_catalog = (TypeCatalogEntry *)context.db->GetCatalog().GetEntry(
-		    context, CatalogType::TYPE_ENTRY, schema->name, user_type_name, true);
-		if (!user_type_catalog) {
-			throw NotImplementedException("DataType %s not supported yet...\n", user_type_name);
-		}
-		info.target_type = user_type_catalog->user_type;
+		auto &catalog = Catalog::GetCatalog(context);
+		info.target_type = catalog.GetType(context, schema->name, UserType::GetTypeName(info.target_type));
 	}
 	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
 	idx_t change_idx = GetColumnIndex(info.column_name);
@@ -3892,9 +3933,12 @@ namespace duckdb {
 
 TypeCatalogEntry::TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info)
     : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info->name), user_type(info->type) {
+	this->temporary = info->temporary;
+	this->internal = info->internal;
 }
 
 void TypeCatalogEntry::Serialize(Serializer &serializer) {
+	D_ASSERT(!internal);
 	FieldWriter writer(serializer);
 	writer.WriteString(schema->name);
 	writer.WriteString(name);
@@ -4279,7 +4323,7 @@ bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_
 	// lock the catalog for writing
 	lock_guard<mutex> write_lock(catalog.write_lock);
 	// lock this catalog set to disallow reading
-	lock_guard<mutex> read_lock(catalog_lock);
+	unique_lock<mutex> read_lock(catalog_lock);
 
 	// first check if the entry exists in the unordered set
 	idx_t entry_index;
@@ -4287,6 +4331,12 @@ bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_
 	if (mapping_value == nullptr || mapping_value->deleted) {
 		// if it does not: entry has never been created
 
+		// check if there is a default entry
+		auto entry = CreateDefaultEntry(context, name, read_lock);
+		if (entry) {
+			return false;
+		}
+
 		// first create a dummy deleted entry for this entry
 		// so transactions started before the commit of this transaction don't
 		// see it yet
@@ -4527,6 +4577,7 @@ MappingValue *CatalogSet::GetMapping(ClientContext &context, const string &name,
 	if (entry != mapping.end()) {
 		mapping_value = entry->second.get();
 	} else {
+
 		return nullptr;
 	}
 	if (get_latest) {
@@ -4604,7 +4655,8 @@ CatalogEntry *CatalogSet::GetCommittedEntry(CatalogEntry *current) {
 }
 
 pair<string, idx_t> CatalogSet::SimilarEntry(ClientContext &context, const string &name) {
-	lock_guard<mutex> lock(catalog_lock);
+	unique_lock<mutex> lock(catalog_lock);
+	CreateDefaultEntries(context, lock);
 
 	string result;
 	idx_t current_score = (idx_t)-1;
@@ -4637,20 +4689,7 @@ CatalogEntry *CatalogSet::CreateEntryInternal(ClientContext &context, unique_ptr
 	return catalog_entry;
 }
 
-CatalogEntry *CatalogSet::GetEntry(ClientContext &context, const string &name) {
-	unique_lock<mutex> lock(catalog_lock);
-	auto mapping_value = GetMapping(context, name);
-	if (mapping_value != nullptr && !mapping_value->deleted) {
-		// we found an entry for this name
-		// check the version numbers
-
-		auto catalog_entry = entries[mapping_value->index].get();
-		CatalogEntry *current = GetEntryForTransaction(context, catalog_entry);
-		if (current->deleted || (current->name != name && !UseTimestamp(context, mapping_value->timestamp))) {
-			return nullptr;
-		}
-		return current;
-	}
+CatalogEntry *CatalogSet::CreateDefaultEntry(ClientContext &context, const string &name, unique_lock<mutex> &lock) {
 	// no entry found with this name, check for defaults
 	if (!defaults || defaults->created_all_entries) {
 		// no defaults either: return null
@@ -4678,6 +4717,23 @@ CatalogEntry *CatalogSet::GetEntry(ClientContext &context, const string &name) {
 	return GetEntry(context, name);
 }
 
+CatalogEntry *CatalogSet::GetEntry(ClientContext &context, const string &name) {
+	unique_lock<mutex> lock(catalog_lock);
+	auto mapping_value = GetMapping(context, name);
+	if (mapping_value != nullptr && !mapping_value->deleted) {
+		// we found an entry for this name
+		// check the version numbers
+
+		auto catalog_entry = entries[mapping_value->index].get();
+		CatalogEntry *current = GetEntryForTransaction(context, catalog_entry);
+		if (current->deleted || (current->name != name && !UseTimestamp(context, mapping_value->timestamp))) {
+			return nullptr;
+		}
+		return current;
+	}
+	return CreateDefaultEntry(context, name, lock);
+}
+
 void CatalogSet::UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp) {
 	entry->timestamp = timestamp;
 	mapping[entry->name]->timestamp = timestamp;
@@ -4781,26 +4837,35 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 	entry->catalog->ModifyCatalog();
 }
 
+void CatalogSet::CreateDefaultEntries(ClientContext &context, unique_lock<mutex> &lock) {
+	if (!defaults || defaults->created_all_entries) {
+		return;
+	}
+	// this catalog set has a default set defined:
+	auto default_entries = defaults->GetDefaultEntries();
+	for (auto &default_entry : default_entries) {
+		auto map_entry = mapping.find(default_entry);
+		if (map_entry == mapping.end()) {
+			// we unlock during the CreateEntry, since it might reference other catalog sets...
+			// specifically for views this can happen since the view will be bound
+			lock.unlock();
+			auto entry = defaults->CreateDefaultEntry(context, default_entry);
+			if (!entry) {
+				throw InternalException("Failed to create default entry for %s", default_entry);
+			}
+
+			lock.lock();
+			CreateEntryInternal(context, move(entry));
+		}
+	}
+	defaults->created_all_entries = true;
+}
+
 void CatalogSet::Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback) {
 	// lock the catalog set
 	unique_lock<mutex> lock(catalog_lock);
-	if (defaults && !defaults->created_all_entries) {
-		// this catalog set has a default set defined:
-		auto default_entries = defaults->GetDefaultEntries();
-		for (auto &default_entry : default_entries) {
-			auto map_entry = mapping.find(default_entry);
-			if (map_entry == mapping.end()) {
-				// we unlock during the CreateEntry, since it might reference other catalog sets...
-				// specifically for views this can happen since the view will be bound
-				lock.unlock();
-				auto entry = defaults->CreateDefaultEntry(context, default_entry);
+	CreateDefaultEntries(context, lock);
 
-				lock.lock();
-				CreateEntryInternal(context, move(entry));
-			}
-		}
-		defaults->created_all_entries = true;
-	}
 	for (auto &kv : entries) {
 		auto entry = kv.second.get();
 		entry = GetEntryForTransaction(context, entry);
@@ -4879,7 +4944,7 @@ static DefaultMacro internal_macros[] = {
 	{"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_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
-	{"pg_catalog", "format_pg_type", {"type_name", nullptr}, "case when type_name='FLOAT' then 'real' when type_name='DOUBLE' then 'double precision' when type_name='DECIMAL' then 'numeric' when type_name='VARCHAR' then 'character varying' when type_name='BLOB' then 'bytea' when type_name='TIMESTAMP' then 'timestamp without time zone' when type_name='TIME' then 'time without time zone' else lower(type_name) end"},
+	{"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='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", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
@@ -5075,6 +5140,129 @@ vector<string> DefaultSchemaGenerator::GetDefaultEntries() {
 
 
 
+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},
+                                       {"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},
+                                       {"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},
+                                       {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
+                                       {"timetz", LogicalTypeId::TIME_TZ},
+                                       {"json", LogicalTypeId::JSON},
+                                       {"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;
+		}
+	}
+	return LogicalTypeId::INVALID;
+}
+
+DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
+    : DefaultGenerator(catalog), schema(schema) {
+}
+
+unique_ptr<CatalogEntry> DefaultTypeGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
+	if (schema->name != DEFAULT_SCHEMA) {
+		return nullptr;
+	}
+	auto type_id = GetDefaultType(entry_name);
+	if (type_id == LogicalTypeId::INVALID) {
+		return nullptr;
+	}
+	CreateTypeInfo info;
+	info.name = entry_name;
+	info.type = LogicalType(type_id);
+	info.internal = true;
+	info.temporary = true;
+	return make_unique_base<CatalogEntry, TypeCatalogEntry>(&catalog, schema, &info);
+}
+
+vector<string> DefaultTypeGenerator::GetDefaultEntries() {
+	vector<string> result;
+	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);
+	}
+	return result;
+}
+
+} // namespace duckdb
+
+
+
+
+
+
 
 
 namespace duckdb {
@@ -5165,7 +5353,6 @@ vector<string> DefaultViewGenerator::GetDefaultEntries() {
 		}
 	}
 	return result;
-
 }
 
 } // namespace duckdb
@@ -35929,7 +36116,9 @@ private:
 };
 
 // adapted from https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
-idx_t StringUtil::LevenshteinDistance(const string &s1, const string &s2) {
+idx_t StringUtil::LevenshteinDistance(const string &s1_p, const string &s2_p) {
+	auto s1 = StringUtil::Lower(s1_p);
+	auto s2 = StringUtil::Lower(s2_p);
 	idx_t len1 = s1.size();
 	idx_t len2 = s2.size();
 	if (len1 == 0) {
@@ -46503,6 +46692,7 @@ const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
 
 
 
+
 #include <cmath>
 
 namespace duckdb {
@@ -46732,9 +46922,9 @@ string TypeIdToString(PhysicalType type) {
 	case PhysicalType::INTERVAL:
 		return "INTERVAL";
 	case PhysicalType::STRUCT:
-		return "STRUCT<?>";
+		return "STRUCT";
 	case PhysicalType::LIST:
-		return "LIST<?>";
+		return "LIST";
 	case PhysicalType::INVALID:
 		return "INVALID";
 	case PhysicalType::BIT:
@@ -46902,11 +47092,11 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 	case LogicalTypeId::VALIDITY:
 		return "VALIDITY";
 	case LogicalTypeId::STRUCT:
-		return "STRUCT<?>";
+		return "STRUCT";
 	case LogicalTypeId::LIST:
-		return "LIST<?>";
+		return "LIST";
 	case LogicalTypeId::MAP:
-		return "MAP<?>";
+		return "MAP";
 	case LogicalTypeId::HASH:
 		return "HASH";
 	case LogicalTypeId::POINTER:
@@ -46920,7 +47110,7 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 	case LogicalTypeId::ENUM:
 		return "ENUM";
 	case LogicalTypeId::AGGREGATE_STATE:
-		return "AGGREGATE_STATE<?>";
+		return "AGGREGATE_STATE";
 	case LogicalTypeId::USER:
 		return "USER";
 	case LogicalTypeId::JSON:
@@ -46993,74 +47183,13 @@ string LogicalType::ToString() const {
 // LCOV_EXCL_STOP
 
 LogicalTypeId TransformStringToLogicalTypeId(const string &str) {
-	auto lower_str = StringUtil::Lower(str);
-	// Transform column type
-	if (lower_str == "int" || lower_str == "int4" || lower_str == "signed" || lower_str == "integer" ||
-	    lower_str == "integral" || lower_str == "int32") {
-		return LogicalTypeId::INTEGER;
-	} else if (lower_str == "varchar" || lower_str == "bpchar" || lower_str == "text" || lower_str == "string" ||
-	           lower_str == "char" || lower_str == "nvarchar") {
-		return LogicalTypeId::VARCHAR;
-	} else if (lower_str == "bytea" || lower_str == "blob" || lower_str == "varbinary" || lower_str == "binary") {
-		return LogicalTypeId::BLOB;
-	} else if (lower_str == "int8" || lower_str == "bigint" || lower_str == "int64" || lower_str == "long" ||
-	           lower_str == "oid") {
-		return LogicalTypeId::BIGINT;
-	} else if (lower_str == "int2" || lower_str == "smallint" || lower_str == "short" || lower_str == "int16") {
-		return LogicalTypeId::SMALLINT;
-	} else if (lower_str == "timestamp" || lower_str == "datetime" || lower_str == "timestamp_us") {
-		return LogicalTypeId::TIMESTAMP;
-	} else if (lower_str == "timestamp_ms") {
-		return LogicalTypeId::TIMESTAMP_MS;
-	} else if (lower_str == "timestamp_ns") {
-		return LogicalTypeId::TIMESTAMP_NS;
-	} else if (lower_str == "timestamp_s") {
-		return LogicalTypeId::TIMESTAMP_SEC;
-	} else if (lower_str == "bool" || lower_str == "boolean" || lower_str == "logical") {
-		return LogicalTypeId::BOOLEAN;
-	} else if (lower_str == "decimal" || lower_str == "dec" || lower_str == "numeric") {
-		return LogicalTypeId::DECIMAL;
-	} else if (lower_str == "real" || lower_str == "float4" || lower_str == "float") {
-		return LogicalTypeId::FLOAT;
-	} else if (lower_str == "double" || lower_str == "float8") {
-		return LogicalTypeId::DOUBLE;
-	} else if (lower_str == "tinyint" || lower_str == "int1") {
-		return LogicalTypeId::TINYINT;
-	} else if (lower_str == "date") {
-		return LogicalTypeId::DATE;
-	} else if (lower_str == "time") {
-		return LogicalTypeId::TIME;
-	} else if (lower_str == "interval") {
-		return LogicalTypeId::INTERVAL;
-	} else if (lower_str == "hugeint" || lower_str == "int128") {
-		return LogicalTypeId::HUGEINT;
-	} else if (lower_str == "uuid" || lower_str == "guid") {
-		return LogicalTypeId::UUID;
-	} else if (lower_str == "struct" || lower_str == "row") {
-		return LogicalTypeId::STRUCT;
-	} else if (lower_str == "map") {
-		return LogicalTypeId::MAP;
-	} else if (lower_str == "utinyint" || lower_str == "uint8") {
-		return LogicalTypeId::UTINYINT;
-	} else if (lower_str == "usmallint" || lower_str == "uint16") {
-		return LogicalTypeId::USMALLINT;
-	} else if (lower_str == "uinteger" || lower_str == "uint32") {
-		return LogicalTypeId::UINTEGER;
-	} else if (lower_str == "ubigint" || lower_str == "uint64") {
-		return LogicalTypeId::UBIGINT;
-	} else if (lower_str == "timestamptz") {
-		return LogicalTypeId::TIMESTAMP_TZ;
-	} else if (lower_str == "timetz") {
-		return LogicalTypeId::TIME_TZ;
-	} else if (lower_str == "json") {
-		return LogicalTypeId::JSON;
-	} else if (lower_str == "null") {
-		return LogicalTypeId::SQLNULL;
-	} else {
+	auto type = DefaultTypeGenerator::GetDefaultType(str);
+	if (type == LogicalTypeId::INVALID) {
 		// This is a User Type, at this point we don't know if its one of the User Defined Types or an error
 		// It is checked in the binder
-		return LogicalTypeId::USER;
+		type = LogicalTypeId::USER;
 	}
+	return type;
 }
 
 LogicalType TransformStringToLogicalType(const string &str) {
@@ -69905,6 +70034,9 @@ using std::stringstream;
 
 static void WriteCatalogEntries(stringstream &ss, vector<CatalogEntry *> &entries) {
 	for (auto &entry : entries) {
+		if (entry->internal) {
+			continue;
+		}
 		ss << entry->ToSQL() << std::endl;
 	}
 	ss << std::endl;
@@ -107478,14 +107610,16 @@ void DuckDBTablesFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct DuckDBTypesData : public FunctionOperatorData {
 	DuckDBTypesData() : offset(0) {
 	}
 
-	vector<LogicalType> types;
+	vector<TypeCatalogEntry *> entries;
 	idx_t offset;
+	unordered_set<int64_t> oids;
 };
 
 static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFunctionBindInput &input,
@@ -107505,6 +107639,9 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 	names.emplace_back("type_size");
 	return_types.emplace_back(LogicalType::BIGINT);
 
+	names.emplace_back("logical_type");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	// NUMERIC, STRING, DATETIME, BOOLEAN, COMPOSITE, USER
 	names.emplace_back("type_category");
 	return_types.emplace_back(LogicalType::VARCHAR);
@@ -107518,37 +107655,61 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 unique_ptr<FunctionOperatorData> DuckDBTypesInit(ClientContext &context, const FunctionData *bind_data,
                                                  const vector<column_t> &column_ids, TableFilterCollection *filters) {
 	auto result = make_unique<DuckDBTypesData>();
-	result->types = LogicalType::AllTypes();
-	// FIXME: add user-defined types here (when we have them)
+	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	for (auto &schema : schemas) {
+		schema->Scan(context, CatalogType::TYPE_ENTRY,
+		             [&](CatalogEntry *entry) { result->entries.push_back((TypeCatalogEntry *)entry); });
+	};
+
+	// check the temp schema as well
+	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
+		result->entries.push_back((TypeCatalogEntry *)entry);
+	});
 	return move(result);
 }
 
 void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
                          DataChunk &output) {
 	auto &data = (DuckDBTypesData &)*operator_state;
-	if (data.offset >= data.types.size()) {
+	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
-	while (data.offset < data.types.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &type = data.types[data.offset++];
+	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &type_entry = data.entries[data.offset++];
+		auto &type = type_entry->user_type;
 
 		// return values:
-		// schema_name, VARCHAR
-		output.SetValue(0, count, Value());
-		// schema_oid, BIGINT
-		output.SetValue(1, count, Value());
+		// schema_name, LogicalType::VARCHAR
+		output.SetValue(0, count, Value(type_entry->schema->name));
+		// schema_oid, LogicalType::BIGINT
+		output.SetValue(1, count, Value::BIGINT(type_entry->schema->oid));
 		// type_oid, BIGINT
-		output.SetValue(2, count, Value::BIGINT(int(type.id())));
+		int64_t oid;
+		if (type_entry->internal) {
+			oid = int64_t(type.id());
+		} else {
+			oid = type_entry->oid;
+		}
+		Value oid_val;
+		if (data.oids.find(oid) == data.oids.end()) {
+			data.oids.insert(oid);
+			oid_val = Value::BIGINT(oid);
+		} else {
+			oid_val = Value();
+		}
+		output.SetValue(2, count, oid_val);
 		// type_name, VARCHAR
-		output.SetValue(3, count, Value(type.ToString()));
+		output.SetValue(3, count, Value(type_entry->name));
 		// type_size, BIGINT
 		auto internal_type = type.InternalType();
 		output.SetValue(4, count,
 		                internal_type == PhysicalType::INVALID ? Value() : Value::BIGINT(GetTypeIdSize(internal_type)));
+		// logical_type, VARCHAR
+		output.SetValue(5, count, Value(LogicalTypeIdToString(type.id())));
 		// type_category, VARCHAR
 		string category;
 		switch (type.id()) {
@@ -107592,9 +107753,9 @@ void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data,
 		default:
 			break;
 		}
-		output.SetValue(5, count, category.empty() ? Value() : Value(category));
+		output.SetValue(6, count, category.empty() ? Value() : Value(category));
 		// internal, BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(true));
+		output.SetValue(7, count, Value::BOOLEAN(type_entry->internal));
 
 		count++;
 	}
@@ -156527,6 +156688,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateEnum(duckdb_libpgquery::
 	D_ASSERT(stmt);
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateTypeInfo>();
+	info->internal = false;
 	info->name = ReadPgListToString(stmt->typeName)[0];
 	idx_t size = 0;
 	auto ordered_array = ReadPgListToVector(stmt->vals, size);
@@ -157942,7 +158104,7 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 		break;
 	}
 	default: {
-		throw NotImplementedException("Join type %d not supported yet...\n", root->jointype);
+		throw NotImplementedException("Join type %d not supported\n", root->jointype);
 	}
 	}
 
@@ -158063,7 +158225,7 @@ unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNod
 	case duckdb_libpgquery::T_PGRangeFunction:
 		return TransformRangeFunction(reinterpret_cast<duckdb_libpgquery::PGRangeFunction *>(n));
 	default:
-		throw NotImplementedException("From Type %d not supported yet...", n->type);
+		throw NotImplementedException("From Type %d not supported", n->type);
 	}
 }
 
@@ -162691,14 +162853,8 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 			type = LogicalType::MAP(child_types);
 		}
 	} else if (type.id() == LogicalTypeId::USER) {
-		auto &user_type_name = UserType::GetTypeName(type);
-		auto user_type_catalog = (TypeCatalogEntry *)context.db->GetCatalog().GetEntry(context, CatalogType::TYPE_ENTRY,
-		                                                                               schema, user_type_name, true);
-		if (!user_type_catalog) {
-			throw NotImplementedException("DataType %s not supported yet...\n", user_type_name);
-		}
-		type = user_type_catalog->user_type;
-		EnumType::SetCatalog(type, user_type_catalog);
+		auto &catalog = Catalog::GetCatalog(context);
+		type = catalog.GetType(context, schema, UserType::GetTypeName(type));
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
 		auto enum_type_catalog = (TypeCatalogEntry *)context.db->GetCatalog().GetEntry(context, CatalogType::TYPE_ENTRY,