duckdb 0.6.2-dev914.0 → 0.6.2-dev939.0

package/package.json

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

package/src/duckdb/extension/json/json_functions/json_create.cpp

@@ -271,27 +271,22 @@ static void CreateValuesStruct(const JSONCreateFunctionData &info, yyjson_mut_do
 
 static void CreateValuesMap(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
                             Vector &value_v, idx_t count) {
-	auto &entries = StructVector::GetEntries(value_v);
 	// Create nested keys
-	auto &map_key_list_v = *entries[0];
-	auto &map_key_v = ListVector::GetEntry(map_key_list_v);
-	auto map_key_count = ListVector::GetListSize(map_key_list_v);
+	auto &map_key_v = MapVector::GetKeys(value_v);
+	auto map_key_count = ListVector::GetListSize(value_v);
 	auto nested_keys_ptr = unique_ptr<yyjson_mut_val *[]>(new yyjson_mut_val *[map_key_count]);
 	auto nested_keys = nested_keys_ptr.get();
 	TemplatedCreateValues<string_t>(doc, nested_keys, map_key_v, map_key_count);
 	// Create nested values
-	auto &map_val_list_v = *entries[1];
-	auto &map_val_v = ListVector::GetEntry(map_val_list_v);
-	auto map_val_count = ListVector::GetListSize(map_val_list_v);
+	auto &map_val_v = MapVector::GetValues(value_v);
+	auto map_val_count = ListVector::GetListSize(value_v);
 	auto nested_vals_ptr = unique_ptr<yyjson_mut_val *[]>(new yyjson_mut_val *[map_val_count]);
 	auto nested_vals = nested_vals_ptr.get();
 	CreateValues(info, doc, nested_vals, map_val_v, map_val_count);
 	// Add the key/value pairs to the objects
 	UnifiedVectorFormat map_data;
 	value_v.ToUnifiedFormat(count, map_data);
-	UnifiedVectorFormat map_key_list_data;
-	map_key_list_v.ToUnifiedFormat(map_key_count, map_key_list_data);
-	auto map_key_list_entries = (list_entry_t *)map_key_list_data.data;
+	auto map_key_list_entries = (list_entry_t *)map_data.data;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = map_data.sel->get_index(i);
 		if (!map_data.validity.RowIsValid(idx)) {
@@ -299,8 +294,7 @@ static void CreateValuesMap(const JSONCreateFunctionData &info, yyjson_mut_doc *
 			vals[i] = yyjson_mut_null(doc);
 		} else {
 			vals[i] = yyjson_mut_obj(doc);
-			idx_t key_idx = map_key_list_data.sel->get_index(i);
-			const auto &key_list_entry = map_key_list_entries[key_idx];
+			const auto &key_list_entry = map_key_list_entries[idx];
 			for (idx_t child_i = key_list_entry.offset; child_i < key_list_entry.offset + key_list_entry.length;
 			     child_i++) {
 				if (!unsafe_yyjson_is_null(nested_keys[child_i])) {

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

@@ -1908,12 +1908,13 @@ unique_ptr<ColumnWriter> ColumnWriter::CreateWriterRecursive(vector<duckdb_parqu
 			bool is_key = i == 0;
 			auto child_writer = CreateWriterRecursive(schemas, writer, kv_types[i], kv_names[i], schema_path,
 			                                          max_repeat + 1, max_define + 2, !is_key);
-			auto list_writer = make_unique<ListColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
-			                                                 move(child_writer), can_have_nulls);
-			child_writers.push_back(move(list_writer));
+
+			child_writers.push_back(move(child_writer));
 		}
-		return make_unique<StructColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
-		                                       move(child_writers), can_have_nulls);
+		auto struct_writer = make_unique<StructColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
+		                                                     move(child_writers), can_have_nulls);
+		return make_unique<ListColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
+		                                     move(struct_writer), can_have_nulls);
 	}
 	duckdb_parquet::format::SchemaElement schema_element;
 	schema_element.type = ParquetWriter::DuckDBTypeToParquetType(type);

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

@@ -302,14 +302,12 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 				throw IOException("MAP_KEY_VALUE needs to be repeated");
 			}
 			result_type = LogicalType::MAP(move(child_types[0].second), move(child_types[1].second));
-			for (auto &child_reader : child_readers) {
-				auto child_type = LogicalType::LIST(child_reader->Type());
-				child_reader = make_unique<ListColumnReader>(*this, move(child_type), s_ele, this_idx, max_define,
-				                                             max_repeat, move(child_reader));
-			}
-			result = make_unique<StructColumnReader>(*this, result_type, s_ele, this_idx, max_define - 1,
-			                                         max_repeat - 1, move(child_readers));
-			return result;
+
+			auto struct_reader =
+			    make_unique<StructColumnReader>(*this, ListType::GetChildType(result_type), s_ele, this_idx,
+			                                    max_define - 1, max_repeat - 1, move(child_readers));
+			return make_unique<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
+			                                     move(struct_reader));
 		}
 		if (child_types.size() > 1 || (!is_list && !is_map && !is_repeated)) {
 			result_type = LogicalType::STRUCT(move(child_types));

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

@@ -469,33 +469,21 @@ struct ArrowMapData {
 		input.ToUnifiedFormat(size, format);
 
 		AppendValidity(append_data, format, size);
-		// maps exist as a struct of two lists, e.g. STRUCT(key VARCHAR[], value VARCHAR[])
-		// since both lists are the same, arrow tries to be smart by storing the offsets only once
-		// we can append the offsets from any of the two children
-		auto &children = StructVector::GetEntries(input);
-
-		UnifiedVectorFormat child_format;
-		children[0]->ToUnifiedFormat(size, child_format);
 		vector<sel_t> child_indices;
-		AppendListOffsets(append_data, child_format, size, child_indices);
+		AppendListOffsets(append_data, format, size, child_indices);
 
-		// now we can append the children to the lists
-		auto &struct_entries = StructVector::GetEntries(input);
-		D_ASSERT(struct_entries.size() == 2);
 		SelectionVector child_sel(child_indices.data());
-		auto &key_vector = ListVector::GetEntry(*struct_entries[0]);
-		auto &value_vector = ListVector::GetEntry(*struct_entries[1]);
+		auto &key_vector = MapVector::GetKeys(input);
+		auto &value_vector = MapVector::GetValues(input);
 		auto list_size = child_indices.size();
 		key_vector.Slice(child_sel, list_size);
 		value_vector.Slice(child_sel, list_size);
 
-		// perform the append
 		auto &struct_data = *append_data.child_data[0];
 		auto &key_data = *struct_data.child_data[0];
 		auto &value_data = *struct_data.child_data[1];
 		key_data.append_vector(key_data, key_vector, list_size);
 		value_data.append_vector(value_data, value_vector, list_size);
-
 		append_data.row_count += size;
 		struct_data.row_count += size;
 	}

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

@@ -73,11 +73,7 @@ void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
 	InitializeChild(root_holder.nested_children.back()[0]);
 	child.children = &root_holder.nested_children_ptr.back()[0];
 	child.children[0]->name = "entries";
-	child_list_t<LogicalType> struct_child_types;
-	struct_child_types.push_back(std::make_pair("key", ListType::GetChildType(StructType::GetChildType(type, 0))));
-	struct_child_types.push_back(std::make_pair("value", ListType::GetChildType(StructType::GetChildType(type, 1))));
-	auto struct_type = LogicalType::STRUCT(move(struct_child_types));
-	SetArrowFormat(root_holder, *child.children[0], struct_type, config_timezone);
+	SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), config_timezone);
 }
 
 void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,

package/src/duckdb/src/common/row_operations/row_gather.cpp

@@ -163,7 +163,6 @@ void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector
 		GatherVarchar(rows, row_sel, col, col_sel, count, layout, col_no, build_size, heap_ptr);
 		break;
 	case PhysicalType::LIST:
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		GatherNestedVector(rows, row_sel, col, col_sel, count, layout, col_no, heap_ptr);
 		break;

package/src/duckdb/src/common/row_operations/row_match.cpp

@@ -201,7 +201,6 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 		                                               no_match_count);
 		break;
 	case PhysicalType::LIST:
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		TemplatedMatchNested<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
 		break;

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -143,7 +143,6 @@ void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[],
 				ComputeStringEntrySizes(col, entry_sizes, sel, count);
 				break;
 			case PhysicalType::LIST:
-			case PhysicalType::MAP:
 			case PhysicalType::STRUCT:
 				RowOperations::ComputeEntrySizes(vec, col, entry_sizes, vcount, count, sel);
 				break;
@@ -215,7 +214,6 @@ void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[],
 			ScatterStringVector(col, rows, data_locations, sel, count, col_offset, col_no);
 			break;
 		case PhysicalType::LIST:
-		case PhysicalType::MAP:
 		case PhysicalType::STRUCT:
 			ScatterNestedVector(vec, col, rows, data_locations, sel, count, col_offset, col_no, vcount);
 			break;

package/src/duckdb/src/common/sort/sort_state.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/common/sort/sorted_block.hpp"
 #include "duckdb/storage/statistics/string_statistics.hpp"
 #include "duckdb/common/radix.hpp"
-
 #include <algorithm>
 #include <numeric>
 
@@ -28,7 +27,6 @@ idx_t GetNestedSortingColSize(idx_t &col_size, const LogicalType &type) {
 			// Lists get 2 bytes (null and empty list)
 			col_size += 2;
 			return GetNestedSortingColSize(col_size, ListType::GetChildType(type));
-		case PhysicalType::MAP:
 		case PhysicalType::STRUCT:
 			// Structs get 1 bytes (null)
 			col_size++;

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

@@ -528,17 +528,15 @@ Value Value::STRUCT(child_list_t<Value> values) {
 	return result;
 }
 
-Value Value::MAP(Value key, Value value) {
+Value Value::MAP(LogicalType child_type, vector<Value> values) {
 	Value result;
-	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", key.type()});
-	child_types.push_back({"value", value.type()});
-
-	result.type_ = LogicalType::MAP(move(child_types));
 
-	result.struct_value.push_back(move(key));
-	result.struct_value.push_back(move(value));
+	result.type_ = LogicalType::MAP(move(child_type));
 	result.is_null = false;
+	if (values.empty()) {
+		return result;
+	}
+	result.list_value = move(values);
 	return result;
 }
 

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

@@ -546,10 +546,13 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
 	}
 	case LogicalTypeId::MAP: {
-		auto &child_entries = StructVector::GetEntries(*vector);
-		Value key = child_entries[0]->GetValue(index);
-		Value value = child_entries[1]->GetValue(index);
-		return Value::MAP(move(key), move(value));
+		auto offlen = ((list_entry_t *)data)[index];
+		auto &child_vec = ListVector::GetEntry(*vector);
+		std::vector<Value> children;
+		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
+			children.push_back(child_vec.GetValue(i));
+		}
+		return Value::MAP(ListType::GetChildType(type), move(children));
 	}
 	case LogicalTypeId::UNION: {
 		auto tag = UnionVector::GetTag(*vector, index);
@@ -1511,12 +1514,12 @@ void FSSTVector::DecompressVector(const Vector &src, Vector &dst, idx_t src_offs
 }
 
 Vector &MapVector::GetKeys(Vector &vector) {
-	auto &entries = StructVector::GetEntries(vector);
+	auto &entries = StructVector::GetEntries(ListVector::GetEntry(vector));
 	D_ASSERT(entries.size() == 2);
 	return *entries[0];
 }
 Vector &MapVector::GetValues(Vector &vector) {
-	auto &entries = StructVector::GetEntries(vector);
+	auto &entries = StructVector::GetEntries(ListVector::GetEntry(vector));
 	D_ASSERT(entries.size() == 2);
 	return *entries[1];
 }
@@ -1529,8 +1532,7 @@ const Vector &MapVector::GetValues(const Vector &vector) {
 }
 
 vector<unique_ptr<Vector>> &StructVector::GetEntries(Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::STRUCT || vector.GetType().id() == LogicalTypeId::MAP ||
-	         vector.GetType().id() == LogicalTypeId::UNION);
+	D_ASSERT(vector.GetType().id() == LogicalTypeId::STRUCT || vector.GetType().id() == LogicalTypeId::UNION);
 
 	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		auto &child = DictionaryVector::Child(vector);
@@ -1548,7 +1550,7 @@ const vector<unique_ptr<Vector>> &StructVector::GetEntries(const Vector &vector)
 }
 
 const Vector &ListVector::GetEntry(const Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
+	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
 	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		auto &child = DictionaryVector::Child(vector);
 		return ListVector::GetEntry(child);
@@ -1566,7 +1568,7 @@ Vector &ListVector::GetEntry(Vector &vector) {
 }
 
 void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
+	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
 	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
 	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
 	D_ASSERT(vector.auxiliary);
@@ -1576,10 +1578,10 @@ void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
 }
 
 template <class T>
-void TemplatedSearchInMap(Vector &list, T key, vector<idx_t> &offsets, bool is_key_null, idx_t offset, idx_t length) {
-	auto &list_vector = ListVector::GetEntry(list);
+void TemplatedSearchInMap(Vector &keys, idx_t count, T key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
+                          idx_t length) {
 	UnifiedVectorFormat vector_data;
-	list_vector.ToUnifiedFormat(ListVector::GetListSize(list), vector_data);
+	keys.ToUnifiedFormat(count, vector_data);
 	auto data = (T *)vector_data.data;
 	auto validity_mask = vector_data.validity;
 
@@ -1602,16 +1604,15 @@ void TemplatedSearchInMap(Vector &list, T key, vector<idx_t> &offsets, bool is_k
 }
 
 template <class T>
-void TemplatedSearchInMap(Vector &list, const Value &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
-                          idx_t length) {
-	TemplatedSearchInMap<T>(list, key.template GetValueUnsafe<T>(), offsets, is_key_null, offset, length);
+void TemplatedSearchInMap(Vector &keys, idx_t count, const Value &key, vector<idx_t> &offsets, bool is_key_null,
+                          idx_t offset, idx_t length) {
+	TemplatedSearchInMap<T>(keys, count, key.template GetValueUnsafe<T>(), offsets, is_key_null, offset, length);
 }
 
-void SearchStringInMap(Vector &list, const string &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
-                       idx_t length) {
-	auto &list_vector = ListVector::GetEntry(list);
+void SearchStringInMap(Vector &keys, idx_t count, const string &key, vector<idx_t> &offsets, bool is_key_null,
+                       idx_t offset, idx_t length) {
 	UnifiedVectorFormat vector_data;
-	list_vector.ToUnifiedFormat(ListVector::GetListSize(list), vector_data);
+	keys.ToUnifiedFormat(count, vector_data);
 	auto data = (string_t *)vector_data.data;
 	auto validity_mask = vector_data.validity;
 	if (is_key_null) {
@@ -1633,67 +1634,63 @@ void SearchStringInMap(Vector &list, const string &key, vector<idx_t> &offsets,
 	}
 }
 
-vector<idx_t> ListVector::Search(Vector &list, const Value &key, idx_t row) {
+vector<idx_t> MapVector::Search(Vector &keys, idx_t count, const Value &key, list_entry_t &entry) {
 	vector<idx_t> offsets;
 
-	auto &list_vector = ListVector::GetEntry(list);
-	auto &entry = ListVector::GetData(list)[row];
-
-	switch (list_vector.GetType().InternalType()) {
+	switch (keys.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedSearchInMap<int8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<int8_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::INT16:
-		TemplatedSearchInMap<int16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<int16_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::INT32:
-		TemplatedSearchInMap<int32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<int32_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::INT64:
-		TemplatedSearchInMap<int64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<int64_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::INT128:
-		TemplatedSearchInMap<hugeint_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<hugeint_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedSearchInMap<uint8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<uint8_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedSearchInMap<uint16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<uint16_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedSearchInMap<uint32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<uint32_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedSearchInMap<uint64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<uint64_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedSearchInMap<float>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<float>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedSearchInMap<double>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<double>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedSearchInMap<interval_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		TemplatedSearchInMap<interval_t>(keys, count, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	case PhysicalType::VARCHAR:
-		SearchStringInMap(list, StringValue::Get(key), offsets, key.IsNull(), entry.offset, entry.length);
+		SearchStringInMap(keys, count, StringValue::Get(key), offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	default:
-		throw InvalidTypeException(list.GetType().id(), "Invalid type for List Vector Search");
+		throw InvalidTypeException(keys.GetType().id(), "Invalid type for List Vector Search");
 	}
 	return offsets;
 }
 
-Value ListVector::GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets) {
-	auto &child_vec = ListVector::GetEntry(list);
+Value FlatVector::GetValuesFromOffsets(Vector &values, vector<idx_t> &offsets) {
 	vector<Value> list_values;
 	list_values.reserve(offsets.size());
 	for (auto &offset : offsets) {
-		list_values.push_back(child_vec.GetValue(offset));
+		list_values.push_back(values.GetValue(offset));
 	}
-	return Value::LIST(ListType::GetChildType(list.GetType()), move(list_values));
+	return Value::LIST(values.GetType(), move(list_values));
 }
 
 idx_t ListVector::GetListSize(const Vector &vec) {

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

@@ -107,11 +107,11 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::VARCHAR;
 	case LogicalTypeId::INTERVAL:
 		return PhysicalType::INTERVAL;
-	case LogicalTypeId::MAP:
 	case LogicalTypeId::UNION:
 	case LogicalTypeId::STRUCT:
 		return PhysicalType::STRUCT;
 	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
 		return PhysicalType::LIST;
 	case LogicalTypeId::POINTER:
 		// LCOV_EXCL_START
@@ -257,8 +257,6 @@ string TypeIdToString(PhysicalType type) {
 		return "INVALID";
 	case PhysicalType::BIT:
 		return "BIT";
-	case PhysicalType::MAP:
-		return "MAP";
 	case PhysicalType::UNKNOWN:
 		return "UNKNOWN";
 	}
@@ -443,15 +441,9 @@ string LogicalType::ToString() const {
 		if (!type_info_) {
 			return "MAP";
 		}
-		auto &child_types = StructType::GetChildTypes(*this);
-		if (child_types.empty()) {
-			return "MAP(?)";
-		}
-		if (child_types.size() != 2) {
-			throw InternalException("Map needs exactly two child elements");
-		}
-		return "MAP(" + ListType::GetChildType(child_types[0].second).ToString() + ", " +
-		       ListType::GetChildType(child_types[1].second).ToString() + ")";
+		auto &key_type = MapType::KeyType(*this);
+		auto &value_type = MapType::ValueType(*this);
+		return "MAP(" + key_type.ToString() + ", " + value_type.ToString() + ")";
 	}
 	case LogicalTypeId::UNION: {
 		if (!type_info_) {
@@ -747,7 +739,12 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
 		return LogicalType::LIST(move(new_child));
 	}
-	if (type_id == LogicalTypeId::STRUCT || type_id == LogicalTypeId::MAP) {
+	if (type_id == LogicalTypeId::MAP) {
+		// list: perform max recursively on child type
+		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
+		return LogicalType::MAP(move(new_child));
+	}
+	if (type_id == LogicalTypeId::STRUCT) {
 		// struct: perform recursively
 		auto &left_child_types = StructType::GetChildTypes(left);
 		auto &right_child_types = StructType::GetChildTypes(right);
@@ -762,8 +759,7 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 			child_types.push_back(make_pair(left_child_types[i].first, move(child_type)));
 		}
 
-		return type_id == LogicalTypeId::STRUCT ? LogicalType::STRUCT(move(child_types))
-		                                        : LogicalType::MAP(move(child_types));
+		return LogicalType::STRUCT(move(child_types));
 	}
 	if (type_id == LogicalTypeId::UNION) {
 		auto left_member_count = UnionType::GetMemberCount(left);
@@ -1040,7 +1036,7 @@ protected:
 };
 
 const LogicalType &ListType::GetChildType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::LIST);
+	D_ASSERT(type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
 	return ((ListTypeInfo &)*info).child_type;
@@ -1154,8 +1150,7 @@ const string AggregateStateType::GetTypeName(const LogicalType &type) {
 }
 
 const child_list_t<LogicalType> &StructType::GetChildTypes(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::MAP ||
-	         type.id() == LogicalTypeId::UNION);
+	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION);
 
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
@@ -1191,26 +1186,26 @@ LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLI
 //===--------------------------------------------------------------------===//
 // Map Type
 //===--------------------------------------------------------------------===//
-LogicalType LogicalType::MAP(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(move(children));
+LogicalType LogicalType::MAP(LogicalType child) {
+	auto info = make_shared<ListTypeInfo>(move(child));
 	return LogicalType(LogicalTypeId::MAP, move(info));
 }
 
 LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", LogicalType::LIST(move(key))});
-	child_types.push_back({"value", LogicalType::LIST(move(value))});
-	return LogicalType::MAP(move(child_types));
+	child_types.push_back({"key", move(key)});
+	child_types.push_back({"value", move(value)});
+	return LogicalType::MAP(LogicalType::STRUCT(move(child_types)));
 }
 
 const LogicalType &MapType::KeyType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return ListType::GetChildType(StructType::GetChildTypes(type)[0].second);
+	return StructType::GetChildTypes(ListType::GetChildType(type))[0].second;
 }
 
 const LogicalType &MapType::ValueType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return ListType::GetChildType(StructType::GetChildTypes(type)[1].second);
+	return StructType::GetChildTypes(ListType::GetChildType(type))[1].second;
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/vector_operations/comparison_operators.cpp

@@ -250,7 +250,6 @@ public:
 			TemplatedExecute<string_t, OP>(left, right, result, count);
 			break;
 		case PhysicalType::LIST:
-		case PhysicalType::MAP:
 		case PhysicalType::STRUCT:
 			NestedComparisonExecutor<OP>(left, right, result, count);
 			break;

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -769,7 +769,6 @@ static void ExecuteDistinct(Vector &left, Vector &right, Vector &result, idx_t c
 		TemplatedDistinctExecute<string_t, OP>(left, right, result, count);
 		break;
 	case PhysicalType::LIST:
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		NestedDistinctExecute<OP>(left, right, result, count);
 		break;
@@ -810,7 +809,6 @@ static idx_t TemplatedDistinctSelectOperation(Vector &left, Vector &right, const
 		return DistinctSelect<interval_t, interval_t, OP>(left, right, sel, count, true_sel, false_sel);
 	case PhysicalType::VARCHAR:
 		return DistinctSelect<string_t, string_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 	case PhysicalType::LIST:
 		return DistinctSelectNested<OP, OPNESTED>(left, right, sel, count, true_sel, false_sel);

package/src/duckdb/src/common/vector_operations/vector_hash.cpp

@@ -220,7 +220,6 @@ static inline void HashTypeSwitch(Vector &input, Vector &result, const Selection
 	case PhysicalType::VARCHAR:
 		TemplatedLoopHash<HAS_RSEL, string_t>(input, result, rsel, count);
 		break;
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		StructLoopHash<HAS_RSEL, true>(input, result, rsel, count);
 		break;
@@ -352,7 +351,6 @@ static inline void CombineHashTypeSwitch(Vector &hashes, Vector &input, const Se
 	case PhysicalType::VARCHAR:
 		TemplatedLoopCombineHash<HAS_RSEL, string_t>(input, hashes, rsel, count);
 		break;
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		StructLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
 		break;

package/src/duckdb/src/execution/expression_executor/execute_comparison.cpp

@@ -94,7 +94,6 @@ static idx_t TemplatedSelectOperation(Vector &left, Vector &right, const Selecti
 	case PhysicalType::VARCHAR:
 		return BinaryExecutor::Select<string_t, string_t, OP>(left, right, sel, count, true_sel, false_sel);
 	case PhysicalType::LIST:
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		return NestedSelectOperation<OP>(left, right, sel, count, true_sel, false_sel);
 	default:

package/src/duckdb/src/function/aggregate/distributive/minmax.cpp

@@ -268,7 +268,6 @@ static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector
 		return TemplatedOptimumType<string_t, OP>(left, lidx, lcount, right, ridx, rcount);
 	case PhysicalType::LIST:
 		return TemplatedOptimumList<OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 		return TemplatedOptimumStruct<OP>(left, lidx, lcount, right, ridx, rcount);
 	default:

package/src/duckdb/src/function/aggregate/nested/histogram.cpp

@@ -121,40 +121,26 @@ static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &
 	auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 	auto &mask = FlatVector::Validity(result);
-
-	auto &child_entries = StructVector::GetEntries(result);
-	auto &bucket_list = child_entries[0];
-	auto &count_list = child_entries[1];
-
-	auto old_len = ListVector::GetListSize(*bucket_list);
-
-	auto &bucket_validity = FlatVector::Validity(*bucket_list);
-	auto &count_validity = FlatVector::Validity(*count_list);
+	auto old_len = ListVector::GetListSize(result);
 
 	for (idx_t i = 0; i < count; i++) {
-
 		const auto rid = i + offset;
 		auto state = states[sdata.sel->get_index(i)];
 		if (!state->hist) {
 			mask.SetInvalid(rid);
-			bucket_validity.SetInvalid(rid);
-			count_validity.SetInvalid(rid);
 			continue;
 		}
 
 		for (auto &entry : *state->hist) {
 			Value bucket_value = OP::template HistogramFinalize<T>(entry.first);
-			ListVector::PushBack(*bucket_list, bucket_value);
 			auto count_value = Value::CreateValue(entry.second);
-			ListVector::PushBack(*count_list, count_value);
+			auto struct_value =
+			    Value::STRUCT({std::make_pair("key", bucket_value), std::make_pair("value", count_value)});
+			ListVector::PushBack(result, struct_value);
 		}
 
-		auto list_struct_data = FlatVector::GetData<list_entry_t>(*bucket_list);
-		list_struct_data[rid].length = ListVector::GetListSize(*bucket_list) - old_len;
-		list_struct_data[rid].offset = old_len;
-
-		list_struct_data = FlatVector::GetData<list_entry_t>(*count_list);
-		list_struct_data[rid].length = ListVector::GetListSize(*count_list) - old_len;
+		auto list_struct_data = ListVector::GetData(result);
+		list_struct_data[rid].length = ListVector::GetListSize(result) - old_len;
 		list_struct_data[rid].offset = old_len;
 		old_len += list_struct_data[rid].length;
 	}
@@ -171,10 +157,7 @@ unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, Aggregate
 		throw NotImplementedException("Unimplemented type for histogram %s", arguments[0]->return_type.ToString());
 	}
 
-	child_list_t<LogicalType> struct_children;
-	struct_children.push_back({"key", LogicalType::LIST(arguments[0]->return_type)});
-	struct_children.push_back({"value", LogicalType::LIST(LogicalType::UBIGINT)});
-	auto struct_type = LogicalType::MAP(move(struct_children));
+	auto struct_type = LogicalType::MAP(arguments[0]->return_type, LogicalType::UBIGINT);
 
 	function.return_type = struct_type;
 	return make_unique<VariableReturnBindData>(function.return_type);