duckdb 0.3.2-dev556.0 → 0.3.2-dev569.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev556.0",
+  "version": "0.3.2-dev569.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -5475,14 +5475,15 @@ string TypeCatalogEntry::ToSQL() {
 	std::stringstream ss;
 	switch (user_type->id()) {
 	case (LogicalTypeId::ENUM): {
-		auto values_insert_order = EnumType::GetValuesInsertOrder(*user_type);
+		Vector values_insert_order(EnumType::GetValuesInsertOrder(*user_type));
+		idx_t size = EnumType::GetSize(*user_type);
 		ss << "CREATE TYPE ";
 		ss << name;
 		ss << " AS ENUM ( ";
 
-		for (idx_t i = 0; i < values_insert_order.size(); i++) {
-			ss << "'" << values_insert_order[i] << "'";
-			if (i != values_insert_order.size() - 1) {
+		for (idx_t i = 0; i < size; i++) {
+			ss << "'" << values_insert_order.GetValue(i).ToString() << "'";
+			if (i != size - 1) {
 				ss << ", ";
 			}
 		}
@@ -32897,6 +32898,8 @@ public:
 
 
 
+
+
 namespace duckdb {
 
 DataChunk::DataChunk() : count(0), capacity(STANDARD_VECTOR_SIZE) {
@@ -33299,6 +33302,79 @@ void SetStructMap(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &
 	}
 }
 
+struct ArrowUUIDConversion {
+	using internal_type_t = uint64_t;
+
+	static unique_ptr<Vector> InitializeVector(Vector &data, idx_t size) {
+		return make_unique<Vector>(LogicalType::VARCHAR, size);
+	}
+
+	static idx_t GetStringLength(uint64_t value) {
+		return UUID::STRING_SIZE;
+	}
+
+	static string_t ConvertValue(Vector &tgt_vec, string_t *tgt_ptr, internal_type_t *src_ptr, idx_t row) {
+		auto str_value = UUID::ToString(src_ptr[row]);
+		// Have to store this string
+		tgt_ptr[row] = StringVector::AddStringOrBlob(tgt_vec, str_value);
+		return tgt_ptr[row];
+	}
+};
+
+struct ArrowVarcharConversion {
+	using internal_type_t = string_t;
+
+	static unique_ptr<Vector> InitializeVector(Vector &data, idx_t size) {
+		return make_unique<Vector>(data);
+	}
+	static idx_t GetStringLength(string_t value) {
+		return value.GetSize();
+	}
+
+	static string_t ConvertValue(Vector &tgt_vec, string_t *tgt_ptr, internal_type_t *src_ptr, idx_t row) {
+		return src_ptr[row];
+	}
+};
+
+template <class CONVERT, class VECTOR_TYPE>
+void SetVarchar(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
+	auto &child = child_holder.array;
+	child_holder.vector = CONVERT::InitializeVector(data, size);
+	auto target_data_ptr = FlatVector::GetData<string_t>(data);
+	child.n_buffers = 3;
+	child_holder.offsets = unique_ptr<data_t[]>(new data_t[sizeof(uint32_t) * (size + 1)]);
+	child.buffers[1] = child_holder.offsets.get();
+	D_ASSERT(child.buffers[1]);
+	//! step 1: figure out total string length:
+	idx_t total_string_length = 0;
+	auto source_ptr = FlatVector::GetData<VECTOR_TYPE>(data);
+	auto &mask = FlatVector::Validity(data);
+	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
+		if (!mask.RowIsValid(row_idx)) {
+			continue;
+		}
+		total_string_length += CONVERT::GetStringLength(source_ptr[row_idx]);
+	}
+	//! step 2: allocate this much
+	child_holder.data = unique_ptr<data_t[]>(new data_t[total_string_length]);
+	child.buffers[2] = child_holder.data.get();
+	D_ASSERT(child.buffers[2]);
+	//! step 3: assign buffers
+	idx_t current_heap_offset = 0;
+	auto target_ptr = (uint32_t *)child.buffers[1];
+
+	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
+		target_ptr[row_idx] = current_heap_offset;
+		if (!mask.RowIsValid(row_idx)) {
+			continue;
+		}
+		string_t str = CONVERT::ConvertValue(*child_holder.vector, target_data_ptr, source_ptr, row_idx);
+		memcpy((void *)((uint8_t *)child.buffers[2] + current_heap_offset), str.GetDataUnsafe(), str.GetSize());
+		current_heap_offset += str.GetSize();
+	}
+	target_ptr[size] = current_heap_offset; //! need to terminate last string!
+}
+
 void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
 	auto &child = child_holder.array;
 	switch (type.id()) {
@@ -33404,39 +33480,11 @@ void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType
 	}
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR: {
-		child_holder.vector = make_unique<Vector>(data);
-		child.n_buffers = 3;
-		child_holder.offsets = unique_ptr<data_t[]>(new data_t[sizeof(uint32_t) * (size + 1)]);
-		child.buffers[1] = child_holder.offsets.get();
-		D_ASSERT(child.buffers[1]);
-		//! step 1: figure out total string length:
-		idx_t total_string_length = 0;
-		auto string_t_ptr = FlatVector::GetData<string_t>(*child_holder.vector);
-		auto &mask = FlatVector::Validity(*child_holder.vector);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (!mask.RowIsValid(row_idx)) {
-				continue;
-			}
-			total_string_length += string_t_ptr[row_idx].GetSize();
-		}
-		//! step 2: allocate this much
-		child_holder.data = unique_ptr<data_t[]>(new data_t[total_string_length]);
-		child.buffers[2] = child_holder.data.get();
-		D_ASSERT(child.buffers[2]);
-		//! step 3: assign buffers
-		idx_t current_heap_offset = 0;
-		auto target_ptr = (uint32_t *)child.buffers[1];
-
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			target_ptr[row_idx] = current_heap_offset;
-			if (!mask.RowIsValid(row_idx)) {
-				continue;
-			}
-			auto &str = string_t_ptr[row_idx];
-			memcpy((void *)((uint8_t *)child.buffers[2] + current_heap_offset), str.GetDataUnsafe(), str.GetSize());
-			current_heap_offset += str.GetSize();
-		}
-		target_ptr[size] = current_heap_offset; //! need to terminate last string!
+		SetVarchar<ArrowVarcharConversion, string_t>(child_holder, type, data, size);
+		break;
+	}
+	case LogicalTypeId::UUID: {
+		SetVarchar<ArrowUUIDConversion, uint64_t>(child_holder, type, data, size);
 		break;
 	}
 	case LogicalTypeId::LIST: {
@@ -33492,6 +33540,23 @@ void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType
 		}
 		break;
 	}
+	case LogicalTypeId::ENUM: {
+		// We need to initialize our dictionary
+		child_holder.children.resize(1);
+		idx_t dict_size = EnumType::GetSize(type);
+		InitializeChild(child_holder.children[0], dict_size);
+		Vector dictionary(EnumType::GetValuesInsertOrder(type));
+		SetArrowChild(child_holder.children[0], dictionary.GetType(), dictionary, dict_size);
+		child_holder.children_ptrs.push_back(&child_holder.children[0].array);
+
+		// now we set the data
+		child.dictionary = child_holder.children_ptrs[0];
+		child_holder.vector = make_unique<Vector>(data);
+		child.n_buffers = 2;
+		child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
+
+		break;
+	}
 	default:
 		throw std::runtime_error("Unsupported type " + type.ToString());
 	}
@@ -38061,7 +38126,7 @@ string Value::ToString() const {
 		default:
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
-		return values_insert_order[enum_idx];
+		return values_insert_order.GetValue(enum_idx).ToString();
 	}
 	default:
 		throw NotImplementedException("Unimplemented type for printing: %s", type_.ToString());
@@ -40615,6 +40680,8 @@ const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
 
 
 
+
+
 namespace duckdb {
 
 LogicalType::LogicalType() : LogicalType(LogicalTypeId::INVALID) {
@@ -41348,7 +41415,7 @@ struct ExtraTypeInfo {
 public:
 	virtual bool Equals(ExtraTypeInfo *other) = 0;
 	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer) const = 0;
+	virtual void Serialize(Serializer &serializer) = 0;
 	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
 	static void Serialize(ExtraTypeInfo *info, Serializer &serializer);
 	//! Deserializes a blob back into an ExtraTypeInfo
@@ -41378,7 +41445,7 @@ public:
 		return width == other.width && scale == other.scale;
 	}
 
-	void Serialize(Serializer &serializer) const override {
+	void Serialize(Serializer &serializer) override {
 		serializer.Write<uint8_t>(width);
 		serializer.Write<uint8_t>(scale);
 	}
@@ -41425,7 +41492,7 @@ public:
 		return true;
 	}
 
-	void Serialize(Serializer &serializer) const override {
+	void Serialize(Serializer &serializer) override {
 		serializer.WriteString(collation);
 	}
 
@@ -41473,7 +41540,7 @@ public:
 		return child_type == other.child_type;
 	}
 
-	void Serialize(Serializer &serializer) const override {
+	void Serialize(Serializer &serializer) override {
 		child_type.Serialize(serializer);
 	}
 
@@ -41517,7 +41584,7 @@ public:
 		return child_types == other.child_types;
 	}
 
-	void Serialize(Serializer &serializer) const override {
+	void Serialize(Serializer &serializer) override {
 		serializer.Write<uint32_t>(child_types.size());
 		for (idx_t i = 0; i < child_types.size(); i++) {
 			serializer.WriteString(child_types[i].first);
@@ -41599,7 +41666,7 @@ public:
 		return other.user_type_name == user_type_name;
 	}
 
-	void Serialize(Serializer &serializer) const override {
+	void Serialize(Serializer &serializer) override {
 		serializer.WriteString(user_type_name);
 	}
 
@@ -41625,12 +41692,13 @@ LogicalType LogicalType::USER(const string &user_type_name) {
 // Enum Type
 //===--------------------------------------------------------------------===//
 struct EnumTypeInfo : public ExtraTypeInfo {
-	explicit EnumTypeInfo(string enum_name_p, vector<string> values_insert_order_p)
+	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t size)
 	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), enum_name(move(enum_name_p)),
-	      values_insert_order(std::move(values_insert_order_p)) {
+	      values_insert_order(values_insert_order_p), size(size) {
 	}
 	string enum_name;
-	vector<string> values_insert_order;
+	Vector values_insert_order;
+	idx_t size;
 	TypeCatalogEntry *catalog_entry = nullptr;
 
 public:
@@ -41643,33 +41711,42 @@ public:
 			return false;
 		}
 		auto &other = (EnumTypeInfo &)*other_p;
-		// We must check if all elements are equal
-		if (other.values_insert_order == values_insert_order) {
-			return true;
+
+		// We must check if both enums have the same size
+		if (other.size != size) {
+			return false;
 		}
-		return false;
+		auto other_vector_ptr = FlatVector::GetData<string_t>(other.values_insert_order);
+		auto this_vector_ptr = FlatVector::GetData<string_t>(values_insert_order);
+
+		// Now we must check if all strings are the same
+		for (idx_t i = 0; i < size; i++) {
+			if (!Equals::Operation(other_vector_ptr[i], this_vector_ptr[i])) {
+				return false;
+			}
+		}
+		return true;
 	}
-	void Serialize(Serializer &serializer) const override {
-		serializer.Write<uint32_t>(values_insert_order.size());
+	void Serialize(Serializer &serializer) override {
+		serializer.Write<uint32_t>(size);
 		serializer.WriteString(enum_name);
-		serializer.WriteStringVector(values_insert_order);
+		values_insert_order.Serialize(size, serializer);
 	}
 };
 
 template <class T>
 struct EnumTypeInfoTemplated : public EnumTypeInfo {
-	explicit EnumTypeInfoTemplated(const string &enum_name_p, const vector<string> &values_insert_order_p)
-	    : EnumTypeInfo(enum_name_p, values_insert_order_p) {
-		idx_t count = 0;
-		for (auto &value : values_insert_order) {
-			values[value] = count++;
+	explicit EnumTypeInfoTemplated(const string &enum_name_p, Vector &values_insert_order_p, idx_t size_p)
+	    : EnumTypeInfo(enum_name_p, values_insert_order_p, size_p) {
+		for (idx_t count = 0; count < size_p; count++) {
+			values[values_insert_order_p.GetValue(count).ToString()] = count;
 		}
 	}
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &source) {
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &source, uint32_t size) {
 		auto enum_name = source.Read<string>();
-		vector<string> values_insert_order;
-		source.ReadStringVector(values_insert_order);
-		return make_shared<EnumTypeInfoTemplated>(move(enum_name), move(values_insert_order));
+		Vector values_insert_order(LogicalType::VARCHAR, size);
+		values_insert_order.Deserialize(size, source);
+		return make_shared<EnumTypeInfoTemplated>(move(enum_name), values_insert_order, size);
 	}
 	unordered_map<string, T> values;
 };
@@ -41681,20 +41758,19 @@ const string &EnumType::GetTypeName(const LogicalType &type) {
 	return ((EnumTypeInfo &)*info).enum_name;
 }
 
-LogicalType LogicalType::ENUM(const string &enum_name, const vector<string> &ordered_data) {
-	auto size = ordered_data.size();
+LogicalType LogicalType::ENUM(const string &enum_name, Vector &ordered_data, idx_t size) {
 	// Generate EnumTypeInfo
 	shared_ptr<ExtraTypeInfo> info;
 	auto enum_internal_type = EnumType::GetPhysicalType(size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
-		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(enum_name, ordered_data);
+		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(enum_name, ordered_data, size);
 		break;
 	case PhysicalType::UINT16:
-		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(enum_name, ordered_data);
+		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(enum_name, ordered_data, size);
 		break;
 	case PhysicalType::UINT32:
-		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(enum_name, ordered_data);
+		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(enum_name, ordered_data, size);
 		break;
 	default:
 		throw InternalException("Invalid Physical Type for ENUMs");
@@ -41725,22 +41801,22 @@ int64_t EnumType::GetPos(const LogicalType &type, const string &key) {
 	}
 }
 
-const string &EnumType::GetValue(const Value &val) {
+const string EnumType::GetValue(const Value &val) {
 	auto info = val.type().AuxInfo();
-	vector<string> &values_insert_order = ((EnumTypeInfo &)*info).values_insert_order;
+	auto &values_insert_order = ((EnumTypeInfo &)*info).values_insert_order;
 	switch (val.type().InternalType()) {
 	case PhysicalType::UINT8:
-		return values_insert_order[val.value_.utinyint];
+		return values_insert_order.GetValue(val.value_.utinyint).ToString();
 	case PhysicalType::UINT16:
-		return values_insert_order[val.value_.usmallint];
+		return values_insert_order.GetValue(val.value_.usmallint).ToString();
 	case PhysicalType::UINT32:
-		return values_insert_order[val.value_.uinteger];
+		return values_insert_order.GetValue(val.value_.uinteger).ToString();
 	default:
 		throw InternalException("Invalid Internal Type for ENUMs");
 	}
 }
 
-const vector<string> &EnumType::GetValuesInsertOrder(const LogicalType &type) {
+Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
@@ -41751,7 +41827,7 @@ idx_t EnumType::GetSize(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).values_insert_order.size();
+	return ((EnumTypeInfo &)*info).size;
 }
 
 void EnumType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
@@ -41806,14 +41882,15 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(Deserializer &source) {
 	case ExtraTypeInfoType::USER_TYPE_INFO:
 		return UserTypeInfo::Deserialize(source);
 	case ExtraTypeInfoType::ENUM_TYPE_INFO: {
-		auto enum_internal_type = EnumType::GetPhysicalType(source.Read<uint32_t>());
+		auto enum_size = source.Read<uint32_t>();
+		auto enum_internal_type = EnumType::GetPhysicalType(enum_size);
 		switch (enum_internal_type) {
 		case PhysicalType::UINT8:
-			return EnumTypeInfoTemplated<uint8_t>::Deserialize(source);
+			return EnumTypeInfoTemplated<uint8_t>::Deserialize(source, enum_size);
 		case PhysicalType::UINT16:
-			return EnumTypeInfoTemplated<uint16_t>::Deserialize(source);
+			return EnumTypeInfoTemplated<uint16_t>::Deserialize(source, enum_size);
 		case PhysicalType::UINT32:
-			return EnumTypeInfoTemplated<uint32_t>::Deserialize(source);
+			return EnumTypeInfoTemplated<uint32_t>::Deserialize(source, enum_size);
 		default:
 			throw InternalException("Invalid Physical Type for ENUMs");
 		}
@@ -44933,7 +45010,9 @@ void FillEnum(Vector &source, Vector &result, idx_t count) {
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 
-	auto str_vec = EnumType::GetValuesInsertOrder(source.GetType());
+	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
+	auto str_vec_ptr = FlatVector::GetData<string_t>(str_vec);
+
 	auto res_enum_type = result.GetType();
 
 	VectorData vdata;
@@ -44952,7 +45031,7 @@ void FillEnum(Vector &source, Vector &result, idx_t count) {
 			result_mask.SetInvalid(i);
 			continue;
 		}
-		auto str = str_vec[source_data[src_idx]];
+		auto str = str_vec_ptr[source_data[src_idx]].GetString();
 		auto key = EnumType::GetPos(res_enum_type, str);
 		if (key == -1) {
 			// key doesn't exist on result enum
@@ -44986,13 +45065,17 @@ void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enu
 	} else {
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 	}
+	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
+	auto str_vec_ptr = FlatVector::GetData<string_t>(str_vec);
+	auto res_vec_ptr = FlatVector::GetData<string_t>(result);
+
 	for (idx_t i = 0; i < count; i++) {
 		auto src_val = source.GetValue(i);
 		if (src_val.is_null) {
 			result.SetValue(i, Value());
 			continue;
 		}
-		auto str_vec = EnumType::GetValuesInsertOrder(source.GetType());
+
 		uint64_t enum_idx;
 		switch (enum_physical_type) {
 		case PhysicalType::UINT8:
@@ -45007,7 +45090,7 @@ void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enu
 		default:
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
-		result.SetValue(i, Value(str_vec[enum_idx]));
+		res_vec_ptr[i] = str_vec_ptr[enum_idx];
 	}
 }
 
@@ -97988,21 +98071,26 @@ static vector<TestType> GetTestTypes() {
 	                    Value("\\x00\\x00\\x00a"));
 
 	// enums
-	vector<string> small_enum {"DUCK_DUCK_ENUM", "GOOSE"};
-	result.emplace_back(LogicalType::ENUM("small_enum", small_enum), "small_enum");
-
-	vector<string> medium_enum;
+	Vector small_enum(LogicalType::VARCHAR, 2);
+	auto small_enum_ptr = FlatVector::GetData<string_t>(small_enum);
+	small_enum_ptr[0] = StringVector::AddStringOrBlob(small_enum, "DUCK_DUCK_ENUM");
+	small_enum_ptr[1] = StringVector::AddStringOrBlob(small_enum, "GOOSE");
+	result.emplace_back(LogicalType::ENUM("small_enum", small_enum, 2), "small_enum");
+
+	Vector medium_enum(LogicalType::VARCHAR, 300);
+	auto medium_enum_ptr = FlatVector::GetData<string_t>(medium_enum);
 	for (idx_t i = 0; i < 300; i++) {
-		medium_enum.push_back(string("enum_") + to_string(i));
+		medium_enum_ptr[i] = StringVector::AddStringOrBlob(medium_enum, string("enum_") + to_string(i));
 	}
-	result.emplace_back(LogicalType::ENUM("medium_enum", medium_enum), "medium_enum");
+	result.emplace_back(LogicalType::ENUM("medium_enum", medium_enum, 300), "medium_enum");
 
 	// this is a big one... not sure if we should push this one here, but it's required for completeness
-	vector<string> large_enum;
+	Vector large_enum(LogicalType::VARCHAR, 70000);
+	auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
 	for (idx_t i = 0; i < 70000; i++) {
-		large_enum.push_back(string("enum_") + to_string(i));
+		large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
 	}
-	result.emplace_back(LogicalType::ENUM("large_enum", large_enum), "large_enum");
+	result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 70000), "large_enum");
 
 	// arrays
 	auto int_list_type = LogicalType::LIST(LogicalType::INTEGER);
@@ -112024,6 +112112,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	case LogicalTypeId::DOUBLE:
 		child.format = "g";
 		break;
+	case LogicalTypeId::UUID:
 	case LogicalTypeId::VARCHAR:
 		child.format = "u";
 		break;
@@ -112118,6 +112207,29 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		SetArrowMapFormat(root_holder, child, type);
 		break;
 	}
+	case LogicalTypeId::ENUM: {
+		switch (EnumType::GetPhysicalType(EnumType::GetSize(type))) {
+		case PhysicalType::UINT8:
+			child.format = "C";
+			break;
+		case PhysicalType::UINT16:
+			child.format = "S";
+			break;
+		case PhysicalType::UINT32:
+			child.format = "I";
+			break;
+		default:
+			throw InternalException("Unsupported Enum Internal Type");
+		}
+		root_holder.nested_children.emplace_back();
+		root_holder.nested_children.back().resize(1);
+		root_holder.nested_children_ptr.emplace_back();
+		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
+		InitializeChild(root_holder.nested_children.back()[0]);
+		child.dictionary = root_holder.nested_children_ptr.back()[0];
+		child.dictionary->format = "u";
+		break;
+	}
 	default:
 		throw InternalException("Unsupported Arrow type " + type.ToString());
 	}
@@ -121868,8 +121980,11 @@ bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
 		small_enum = &right;
 		big_enum = &left;
 	}
-	auto string_vec = EnumType::GetValuesInsertOrder(*small_enum);
-	for (auto &key : string_vec) {
+	auto &string_vec = EnumType::GetValuesInsertOrder(*small_enum);
+	auto string_vec_ptr = FlatVector::GetData<string_t>(string_vec);
+	auto size = EnumType::GetSize(*small_enum);
+	for (idx_t i = 0; i < size; i++) {
+		auto key = string_vec_ptr[i].GetString();
 		if (EnumType::GetPos(*big_enum, key) != -1) {
 			return true;
 		}
@@ -142594,6 +142709,7 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 
 
 
+
 namespace duckdb {
 
 vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list) {
@@ -142608,14 +142724,36 @@ vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list) {
 	return result;
 }
 
+Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
+	if (!column_list) {
+		Vector result(LogicalType::VARCHAR);
+		return result;
+	}
+	// First we discover the size of this list
+	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
+		size++;
+	}
+
+	Vector result(LogicalType::VARCHAR, size);
+	auto result_ptr = FlatVector::GetData<string_t>(result);
+
+	size = 0;
+	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
+		auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
+		result_ptr[size++] = StringVector::AddStringOrBlob(result, target->name);
+	}
+	return result;
+}
+
 unique_ptr<CreateStatement> Transformer::TransformCreateEnum(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateEnumStmt *>(node);
 	D_ASSERT(stmt);
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateTypeInfo>();
 	info->name = ReadPgListToString(stmt->typeName)[0];
-	vector<string> ordered_array = ReadPgListToString(stmt->vals);
-	info->type = make_unique<LogicalType>(LogicalType::ENUM(info->name, ordered_array));
+	idx_t size = 0;
+	auto ordered_array = ReadPgListToVector(stmt->vals, size);
+	info->type = make_unique<LogicalType>(LogicalType::ENUM(info->name, ordered_array, size));
 	result->info = move(info);
 	return result;
 }

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "3c1a9e3b7"
-#define DUCKDB_VERSION "0.3.2-dev556"
+#define DUCKDB_SOURCE_ID "048bce50e"
+#define DUCKDB_VERSION "0.3.2-dev569"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -586,6 +586,7 @@ class Serializer;
 class Deserializer;
 class Value;
 class TypeCatalogEntry;
+class Vector;
 //! Type used to represent dates (days since 1970-01-01)
 struct date_t {
 	int32_t days;
@@ -1040,7 +1041,7 @@ public:
 	DUCKDB_API static LogicalType STRUCT( child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
 	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
-	DUCKDB_API static LogicalType ENUM(const string &enum_name, const vector<string> &ordered_data); // NOLINT
+	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
 	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
 	DUCKDB_API static const vector<LogicalType> NUMERIC;
@@ -1070,9 +1071,9 @@ struct UserType{
 struct EnumType{
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string& key);
-	DUCKDB_API static const vector<string> &GetValuesInsertOrder(const LogicalType &type);
+	DUCKDB_API static Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
-	DUCKDB_API static const string& GetValue(const Value &val);
+	DUCKDB_API static const string GetValue(const Value &val);
 	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
 	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(idx_t size);
@@ -11782,6 +11783,7 @@ namespace duckdb {
 //! The UUID class contains static operations for the UUID type
 class UUID {
 public:
+	constexpr static const uint8_t STRING_SIZE = 36;
 	//! Convert a uuid string to a hugeint object
 	static bool FromString(string str, hugeint_t &result);
 	//! Convert a uuid string to a hugeint object
@@ -11793,9 +11795,9 @@ public:
 
 	//! Convert a hugeint object to a uuid style string
 	static string ToString(hugeint_t input) {
-		char buff[36];
+		char buff[STRING_SIZE];
 		ToString(input, buff);
-		return string(buff, 36);
+		return string(buff, STRING_SIZE);
 	}
 
 	static hugeint_t FromString(string str) {