duckdb 0.7.2-dev457.0 → 0.7.2-dev586.0

package/binding.gyp

@@ -223,18 +223,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-strptime.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
-                "src/duckdb/extension/icu/./icu-extension.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev457.0",
+  "version": "0.7.2-dev586.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -354,6 +354,7 @@ public:
 		return_types.assign(union_col_types.begin(), union_col_types.end());
 		result->SetInitialReader(result->union_readers[0]);
 		D_ASSERT(names.size() == return_types.size());
+		result->types = union_col_types;
 
 		return std::move(result);
 	}

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

@@ -625,6 +625,19 @@ vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context) {
 	return schemas;
 }
 
+bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, const string &schema, const string &name) {
+	CatalogEntry *entry;
+	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, true);
+	if (!entry) {
+		// look in the system catalog
+		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, true);
+		if (!entry) {
+			return false;
+		}
+	}
+	return true;
+}
+
 vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
 	vector<Catalog *> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {

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

@@ -682,27 +682,8 @@ void DuckTableEntry::SetAsRoot() {
 	storage->info->table = name;
 }
 
-void DuckTableEntry::CommitAlter(AlterInfo &info) {
-	D_ASSERT(info.type == AlterType::ALTER_TABLE);
-	auto &alter_table = (AlterTableInfo &)info;
-	string column_name;
-	switch (alter_table.alter_table_type) {
-	case AlterTableType::REMOVE_COLUMN: {
-		auto &remove_info = (RemoveColumnInfo &)alter_table;
-		column_name = remove_info.removed_column;
-		break;
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto &change_info = (ChangeColumnTypeInfo &)alter_table;
-		column_name = change_info.column_name;
-		break;
-	}
-	default:
-		break;
-	}
-	if (column_name.empty()) {
-		return;
-	}
+void DuckTableEntry::CommitAlter(string &column_name) {
+	D_ASSERT(!column_name.empty());
 	idx_t removed_index = DConstants::INVALID_INDEX;
 	for (auto &col : columns.Logical()) {
 		if (col.Name() == column_name) {

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

@@ -23,7 +23,13 @@ void TypeCatalogEntry::Serialize(Serializer &serializer) {
 	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();
 }
 
@@ -43,7 +49,7 @@ string TypeCatalogEntry::ToSQL() {
 	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_set.cpp

@@ -258,6 +258,7 @@ 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();
 

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/common/array.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/uuid.hpp"
+#include "duckdb/function/table/arrow.hpp"
 
 namespace duckdb {
 
@@ -127,7 +128,11 @@ struct ArrowScalarConverter {
 struct ArrowIntervalConverter {
 	template <class TGT, class SRC>
 	static TGT Operation(SRC input) {
-		return Interval::GetMilli(input);
+		ArrowInterval result;
+		result.months = input.months;
+		result.days = input.days;
+		result.nanoseconds = input.micros * Interval::NANOS_PER_MICRO;
+		return result;
 	}
 
 	static bool SkipNulls() {
@@ -136,7 +141,6 @@ struct ArrowIntervalConverter {
 
 	template <class TGT>
 	static void SetNull(TGT &value) {
-		value = 0;
 	}
 };
 
@@ -185,11 +189,51 @@ struct ArrowScalarData : public ArrowScalarBaseData<TGT, SRC, OP> {
 //===--------------------------------------------------------------------===//
 template <class TGT>
 struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
+	static idx_t GetLength(string_t input) {
+		return input.GetSize();
+	}
+	static void WriteData(data_ptr_t target, string_t input) {
+		memcpy(target, input.GetDataUnsafe(), input.GetSize());
+	}
+	static void EnumAppendVector(ArrowAppendData &append_data, const Vector &input, idx_t size) {
+		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
+
+		// resize the validity mask and set up the validity buffer for iteration
+		ResizeValidity(append_data.validity, append_data.row_count + size);
+
+		// resize the offset buffer - the offset buffer holds the offsets into the child array
+		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
+		auto data = (string_t *)FlatVector::GetData<string_t>(input);
+		auto offset_data = (uint32_t *)append_data.main_buffer.data();
+		if (append_data.row_count == 0) {
+			// first entry
+			offset_data[0] = 0;
+		}
+		// now append the string data to the auxiliary buffer
+		// the auxiliary buffer's length depends on the string lengths, so we resize as required
+		auto last_offset = offset_data[append_data.row_count];
+		for (idx_t i = 0; i < size; i++) {
+			auto offset_idx = append_data.row_count + i + 1;
+
+			auto string_length = GetLength(data[i]);
+
+			// append the offset data
+			auto current_offset = last_offset + string_length;
+			offset_data[offset_idx] = current_offset;
+
+			// resize the string buffer if required, and write the string data
+			append_data.aux_buffer.resize(current_offset);
+			WriteData(append_data.aux_buffer.data() + last_offset, data[i]);
+
+			last_offset = current_offset;
+		}
+		append_data.row_count += size;
+	}
 	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
 		result.main_buffer.reserve(capacity * sizeof(TGT));
 		// construct the enum child data
 		auto enum_data = InitializeArrowChild(LogicalType::VARCHAR, EnumType::GetSize(type));
-		enum_data->append_vector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
+		EnumAppendVector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
 		result.child_data.push_back(std::move(enum_data));
 	}
 
@@ -629,7 +673,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		}
 		break;
 	case LogicalTypeId::INTERVAL:
-		InitializeFunctionPointers<ArrowScalarData<int64_t, interval_t, ArrowIntervalConverter>>(append_data);
+		InitializeFunctionPointers<ArrowScalarData<ArrowInterval, interval_t, ArrowIntervalConverter>>(append_data);
 		break;
 	case LogicalTypeId::STRUCT:
 		InitializeFunctionPointers<ArrowStructData>(append_data);

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -150,7 +150,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "tsm:";
 		break;
 	case LogicalTypeId::INTERVAL:
-		child.format = "tDm";
+		child.format = "tin";
 		break;
 	case LogicalTypeId::DECIMAL: {
 		uint8_t width, scale;

package/src/duckdb/src/common/field_writer.cpp

@@ -8,6 +8,7 @@ namespace duckdb {
 FieldWriter::FieldWriter(Serializer &serializer_p)
     : serializer(serializer_p), buffer(make_unique<BufferedSerializer>()), field_count(0), finalized(false) {
 	buffer->SetVersion(serializer.GetVersion());
+	buffer->is_query_plan = serializer.is_query_plan;
 }
 
 FieldWriter::~FieldWriter() {

package/src/duckdb/src/common/serializer/buffered_deserializer.cpp

@@ -20,4 +20,8 @@ void BufferedDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
 	ptr += read_size;
 }
 
+ClientContext &BufferedContextDeserializer::GetContext() {
+	return context;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -7,8 +7,10 @@
 
 namespace duckdb {
 
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type, FileOpener *opener)
-    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0) {
+BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context, FileLockType lock_type,
+                                       FileOpener *opener)
+    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), context(context),
+      total_read(0) {
 	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener);
 	file_size = fs.GetFileSize(*handle);
 }
@@ -54,4 +56,15 @@ uint64_t BufferedFileReader::CurrentOffset() {
 	return total_read + offset;
 }
 
+ClientContext &BufferedFileReader::GetContext() {
+	if (!context) {
+		throw InternalException("Trying to acquire a client context that does not exist");
+	}
+	return *context;
+}
+
+Catalog *BufferedFileReader::GetCatalog() {
+	return catalog;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/types.cpp

@@ -1,7 +1,9 @@
 #include "duckdb/common/types.hpp"
 
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/catalog/default/default_types.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
@@ -17,6 +19,11 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/cast_rules.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/client_data.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/database_manager.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 #include "duckdb/parser/parser.hpp"
 
@@ -785,7 +792,7 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 		child_list_t<LogicalType> child_types;
 		for (idx_t i = 0; i < left_child_types.size(); i++) {
 			auto child_type = MaxLogicalType(left_child_types[i].second, right_child_types[i].second);
-			child_types.push_back(make_pair(left_child_types[i].first, std::move(child_type)));
+			child_types.emplace_back(left_child_types[i].first, std::move(child_type));
 		}
 
 		return LogicalType::STRUCT(std::move(child_types));
@@ -797,7 +804,7 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 			// return the "larger" type, with the most members
 			return left_member_count > right_member_count ? left : right;
 		}
-		// otherwise, keep left, dont try to meld the two together.
+		// otherwise, keep left, don't try to meld the two together.
 		return left;
 	}
 	// types are equal but no extra specifier: just return the type
@@ -838,17 +845,6 @@ bool ApproxEqual(double ldecimal, double rdecimal) {
 //===--------------------------------------------------------------------===//
 // Extra Type Info
 //===--------------------------------------------------------------------===//
-enum class ExtraTypeInfoType : uint8_t {
-	INVALID_TYPE_INFO = 0,
-	GENERIC_TYPE_INFO = 1,
-	DECIMAL_TYPE_INFO = 2,
-	STRING_TYPE_INFO = 3,
-	LIST_TYPE_INFO = 4,
-	STRUCT_TYPE_INFO = 5,
-	ENUM_TYPE_INFO = 6,
-	USER_TYPE_INFO = 7,
-	AGGREGATE_STATE_TYPE_INFO = 8
-};
 
 struct ExtraTypeInfo {
 	explicit ExtraTypeInfo(ExtraTypeInfoType type) : type(type) {
@@ -941,6 +937,10 @@ TypeCatalogEntry *LogicalType::GetCatalog(const LogicalType &type) {
 	return ((ExtraTypeInfo &)*info).catalog_entry;
 }
 
+ExtraTypeInfoType LogicalType::GetExtraTypeInfoType(const ExtraTypeInfo &type) {
+	return type.type;
+}
+
 //===--------------------------------------------------------------------===//
 // Decimal Type
 //===--------------------------------------------------------------------===//
@@ -1108,7 +1108,7 @@ public:
 		for (uint32_t i = 0; i < child_types_size; i++) {
 			auto name = source.Read<string>();
 			auto type = LogicalType::Deserialize(source);
-			child_list.push_back(make_pair(std::move(name), std::move(type)));
+			child_list.emplace_back(std::move(name), std::move(type));
 		}
 		return make_shared<StructTypeInfo>(std::move(child_list));
 	}
@@ -1227,8 +1227,8 @@ LogicalType LogicalType::MAP(LogicalType child) {
 
 LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", std::move(key)});
-	child_types.push_back({"value", std::move(value)});
+	child_types.emplace_back("key", std::move(key));
+	child_types.emplace_back("value", std::move(value));
 	return LogicalType::MAP(LogicalType::STRUCT(std::move(child_types)));
 }
 
@@ -1247,7 +1247,7 @@ const LogicalType &MapType::ValueType(const LogicalType &type) {
 //===--------------------------------------------------------------------===//
 
 LogicalType LogicalType::UNION(child_list_t<LogicalType> members) {
-	D_ASSERT(members.size() > 0);
+	D_ASSERT(!members.empty());
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	// union types always have a hidden "tag" field in front
 	members.insert(members.begin(), {"", LogicalType::TINYINT});
@@ -1270,7 +1270,7 @@ const string &UnionType::GetMemberName(const LogicalType &type, idx_t index) {
 }
 
 idx_t UnionType::GetMemberCount(const LogicalType &type) {
-	// dont count the "tag" field
+	// don't count the "tag" field
 	return StructType::GetChildTypes(type).size() - 1;
 }
 const child_list_t<LogicalType> UnionType::CopyMemberTypes(const LogicalType &type) {
@@ -1326,13 +1326,27 @@ enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 };
 
 struct EnumTypeInfo : public ExtraTypeInfo {
 	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), dict_type(EnumDictType::VECTOR_DICT),
-	      enum_name(std::move(enum_name_p)), values_insert_order(values_insert_order_p), dict_size(dict_size_p) {
-	}
-	EnumDictType dict_type;
-	string enum_name;
-	Vector values_insert_order;
-	idx_t dict_size;
+	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
+	      dict_type(EnumDictType::VECTOR_DICT), enum_name(std::move(enum_name_p)), dict_size(dict_size_p) {
+	}
+
+	const EnumDictType &GetEnumDictType() {
+		return dict_type;
+	};
+	const string &GetEnumName() {
+		return enum_name;
+	};
+	const string GetSchemaName() const {
+		return catalog_entry ? catalog_entry->schema->name : "";
+	};
+	const Vector &GetValuesInsertOrder() {
+		return values_insert_order;
+	};
+	const idx_t &GetDictSize() {
+		return dict_size;
+	};
+	EnumTypeInfo(const EnumTypeInfo &) = delete;
+	EnumTypeInfo &operator=(const EnumTypeInfo &) = delete;
 
 protected:
 	// Equalities are only used in enums with different catalog entries
@@ -1362,12 +1376,39 @@ protected:
 		if (dict_type != EnumDictType::VECTOR_DICT) {
 			throw InternalException("Cannot serialize non-vector dictionary ENUM types");
 		}
-		writer.WriteField<uint32_t>(dict_size);
-		writer.WriteString(enum_name);
-		((Vector &)values_insert_order).Serialize(dict_size, writer.GetSerializer());
+		bool serialize_internals = GetSchemaName().empty() || writer.GetSerializer().is_query_plan;
+		EnumType::Serialize(writer, *this, serialize_internals);
 	}
+
+	Vector values_insert_order;
+
+private:
+	EnumDictType dict_type;
+	string enum_name;
+	idx_t dict_size;
 };
 
+// If this type is primarily stored in the catalog or not. Enums from Pandas/Factors are not in the catalog.
+
+void EnumType::Serialize(FieldWriter &writer, const ExtraTypeInfo &type_info, bool serialize_internals) {
+	D_ASSERT(type_info.type == ExtraTypeInfoType::ENUM_TYPE_INFO);
+	auto &enum_info = (EnumTypeInfo &)type_info;
+	// Store Schema Name
+	writer.WriteString(enum_info.GetSchemaName());
+	// Store Enum Name
+	writer.WriteString(enum_info.GetEnumName());
+	// Store If we are serializing the internals
+	writer.WriteField<bool>(serialize_internals);
+	if (serialize_internals) {
+		// We must serialize the internals
+		auto dict_size = enum_info.GetDictSize();
+		// Store Dictionary Size
+		writer.WriteField<uint32_t>(dict_size);
+		// Store Vector Order By Insertion
+		((Vector &)enum_info.GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer());
+	}
+}
+
 template <class T>
 struct EnumTypeInfoTemplated : public EnumTypeInfo {
 	explicit EnumTypeInfoTemplated(const string &enum_name_p, Vector &values_insert_order_p, idx_t size_p)
@@ -1391,13 +1432,21 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		}
 	}
 
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size) {
-		auto enum_name = reader.ReadRequired<string>();
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size, string enum_name) {
+
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.Deserialize(size, reader.GetSource());
 		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
 	}
 
+	string_map_t<T> &GetValues() {
+		return values;
+	}
+
+	EnumTypeInfoTemplated(const EnumTypeInfoTemplated &) = delete;
+	EnumTypeInfoTemplated &operator=(const EnumTypeInfoTemplated &) = delete;
+
+private:
 	string_map_t<T> values;
 };
 
@@ -1405,7 +1454,7 @@ const string &EnumType::GetTypeName(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).enum_name;
+	return ((EnumTypeInfo &)*info).GetEnumName();
 }
 
 static PhysicalType EnumVectorDictType(idx_t size) {
@@ -1454,11 +1503,11 @@ int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
 	auto info = type.AuxInfo();
 	switch (type.InternalType()) {
 	case PhysicalType::UINT8:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint8_t> &)*info).values, key);
+		return TemplatedGetPos(((EnumTypeInfoTemplated<uint8_t> &)*info).GetValues(), key);
 	case PhysicalType::UINT16:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint16_t> &)*info).values, key);
+		return TemplatedGetPos(((EnumTypeInfoTemplated<uint16_t> &)*info).GetValues(), key);
 	case PhysicalType::UINT32:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint32_t> &)*info).values, key);
+		return TemplatedGetPos(((EnumTypeInfoTemplated<uint32_t> &)*info).GetValues(), key);
 	default:
 		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 	}
@@ -1466,22 +1515,22 @@ int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
 
 const string EnumType::GetValue(const Value &val) {
 	auto info = val.type().AuxInfo();
-	auto &values_insert_order = ((EnumTypeInfo &)*info).values_insert_order;
+	auto &values_insert_order = ((EnumTypeInfo &)*info).GetValuesInsertOrder();
 	return StringValue::Get(values_insert_order.GetValue(val.GetValue<uint32_t>()));
 }
 
-Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
+const Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).values_insert_order;
+	return ((EnumTypeInfo &)*info).GetValuesInsertOrder();
 }
 
 idx_t EnumType::GetSize(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).dict_size;
+	return ((EnumTypeInfo &)*info).GetDictSize();
 }
 
 void EnumType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
@@ -1497,13 +1546,18 @@ TypeCatalogEntry *EnumType::GetCatalog(const LogicalType &type) {
 	return ((EnumTypeInfo &)*info).catalog_entry;
 }
 
+string EnumType::GetSchemaName(const LogicalType &type) {
+	auto catalog_entry = EnumType::GetCatalog(type);
+	return catalog_entry ? catalog_entry->schema->name : "";
+}
+
 PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto aux_info = type.AuxInfo();
 	D_ASSERT(aux_info);
 	auto &info = (EnumTypeInfo &)*aux_info;
-	D_ASSERT(info.dict_type == EnumDictType::VECTOR_DICT);
-	return EnumVectorDictType(info.dict_size);
+	D_ASSERT(info.GetEnumDictType() == EnumDictType::VECTOR_DICT);
+	return EnumVectorDictType(info.GetDictSize());
 }
 
 //===--------------------------------------------------------------------===//
@@ -1549,20 +1603,40 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(FieldReader &reader) {
 		extra_info = UserTypeInfo::Deserialize(reader);
 		break;
 	case ExtraTypeInfoType::ENUM_TYPE_INFO: {
-		auto enum_size = reader.ReadRequired<uint32_t>();
-		auto enum_internal_type = EnumVectorDictType(enum_size);
-		switch (enum_internal_type) {
-		case PhysicalType::UINT8:
-			extra_info = EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size);
-			break;
-		case PhysicalType::UINT16:
-			extra_info = EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size);
-			break;
-		case PhysicalType::UINT32:
-			extra_info = EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size);
+		auto schema_name = reader.ReadRequired<string>();
+		auto enum_name = reader.ReadRequired<string>();
+		auto deserialize_internals = reader.ReadRequired<bool>();
+		if (!deserialize_internals) {
+			// this means the enum should already be in the catalog.
+			auto &client_context = reader.GetSource().GetContext();
+			// See if the serializer has a catalog
+			auto catalog = reader.GetSource().GetCatalog();
+			if (catalog) {
+				auto enum_type = catalog->GetType(client_context, schema_name, enum_name, true);
+				if (enum_type != LogicalType::INVALID) {
+					extra_info = enum_type.GetAuxInfoShrPtr();
+				}
+			}
+			if (!extra_info) {
+				throw InternalException("Could not find ENUM in the Catalog to deserialize");
+			}
 			break;
-		default:
-			throw InternalException("Invalid Physical Type for ENUMs");
+		} else {
+			auto enum_size = reader.ReadRequired<uint32_t>();
+			auto enum_internal_type = EnumVectorDictType(enum_size);
+			switch (enum_internal_type) {
+			case PhysicalType::UINT8:
+				extra_info = EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size, enum_name);
+				break;
+			case PhysicalType::UINT16:
+				extra_info = EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size, enum_name);
+				break;
+			case PhysicalType::UINT32:
+				extra_info = EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size, enum_name);
+				break;
+			default:
+				throw InternalException("Invalid Physical Type for ENUMs");
+			}
 		}
 	} break;
 	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
@@ -1592,6 +1666,15 @@ void LogicalType::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void LogicalType::SerializeEnumType(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<LogicalTypeId>(id_);
+	writer.WriteField<ExtraTypeInfoType>(type_info_->type);
+	EnumType::Serialize(writer, *type_info_, true);
+	writer.WriteString(type_info_->alias);
+	writer.Finalize();
+}
+
 LogicalType LogicalType::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto id = reader.ReadRequired<LogicalTypeId>();