duckdb 0.6.2-dev919.0 → 0.6.2-dev942.0

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);

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -12,7 +12,7 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	return make_unique<ListBoundCastData>(move(child_cast));
 }
 
-static bool ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
 
 	// only handle constant and flat vectors here for now
@@ -53,7 +53,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
 	// first cast the child vector to varchar
 	Vector varchar_list(LogicalType::LIST(LogicalType::VARCHAR), count);
-	ListToListCast(source, varchar_list, count, parameters);
+	ListCast::ListToListCast(source, varchar_list, count, parameters);
 
 	// now construct the actual varchar vector
 	varchar_list.Flatten(count);
@@ -116,7 +116,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::LIST:
-		return BoundCastInfo(ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::JSON:
 		return BoundCastInfo(ListToVarcharCast, ListBoundCastData::BindListToListCast(

package/src/duckdb/src/function/cast/map_cast.cpp

@@ -3,75 +3,28 @@
 
 namespace duckdb {
 
-struct MapBoundCastData : public BoundCastData {
-	MapBoundCastData(BoundCastInfo key_cast, BoundCastInfo value_cast)
-	    : key_cast(move(key_cast)), value_cast(move(value_cast)) {
-	}
-
-	BoundCastInfo key_cast;
-	BoundCastInfo value_cast;
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_unique<MapBoundCastData>(key_cast.Copy(), value_cast.Copy());
-	}
-};
-
-unique_ptr<BoundCastData> BindMapToMapCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto source_key = LogicalType::LIST(MapType::KeyType(source));
-	auto target_key = LogicalType::LIST(MapType::KeyType(target));
-	auto source_val = LogicalType::LIST(MapType::ValueType(source));
-	auto target_val = LogicalType::LIST(MapType::ValueType(target));
-	auto key_cast = input.GetCastFunction(source_key, target_key);
-	auto value_cast = input.GetCastFunction(source_val, target_val);
-	return make_unique<MapBoundCastData>(move(key_cast), move(value_cast));
-}
-
-static bool MapToMapCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
-	CastParameters key_params(parameters, cast_data.key_cast.cast_data.get());
-	if (!cast_data.key_cast.function(MapVector::GetKeys(source), MapVector::GetKeys(result), count, key_params)) {
-		return false;
-	}
-	CastParameters val_params(parameters, cast_data.value_cast.cast_data.get());
-	if (!cast_data.value_cast.function(MapVector::GetValues(source), MapVector::GetValues(result), count, val_params)) {
-		return false;
-	}
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, ConstantVector::IsNull(source));
-	} else {
-		source.Flatten(count);
-		FlatVector::Validity(result) = FlatVector::Validity(source);
-	}
-	return true;
-}
-
 static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	// first cast the child elements to varchar
 	auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
 	Vector varchar_map(varchar_type, count);
-	MapToMapCast(source, varchar_map, count, parameters);
 
-	// now construct the actual varchar vector
-	varchar_map.Flatten(count);
+	// since map's physical type is a list, the ListCast can be utilized
+	ListCast::ListToListCast(source, varchar_map, count, parameters);
 
+	varchar_map.Flatten(count);
 	auto &validity = FlatVector::Validity(varchar_map);
-	auto &key_lists = MapVector::GetKeys(varchar_map);
-	auto &val_lists = MapVector::GetValues(varchar_map);
-	auto &key_str = ListVector::GetEntry(key_lists);
-	auto &val_str = ListVector::GetEntry(val_lists);
+	auto &key_str = MapVector::GetKeys(varchar_map);
+	auto &val_str = MapVector::GetValues(varchar_map);
 
-	key_str.Flatten(ListVector::GetListSize(key_lists));
-	val_str.Flatten(ListVector::GetListSize(val_lists));
+	key_str.Flatten(ListVector::GetListSize(source));
+	val_str.Flatten(ListVector::GetListSize(source));
 
-	auto list_data = FlatVector::GetData<list_entry_t>(key_lists);
+	auto list_data = ListVector::GetData(varchar_map);
 	auto key_data = FlatVector::GetData<string_t>(key_str);
 	auto val_data = FlatVector::GetData<string_t>(val_str);
 	auto &key_validity = FlatVector::Validity(key_str);
 	auto &val_validity = FlatVector::Validity(val_str);
+	auto &struct_validity = FlatVector::Validity(ListVector::GetEntry(varchar_map));
 
 	auto result_data = FlatVector::GetData<string_t>(result);
 	for (idx_t i = 0; i < count; i++) {
@@ -86,8 +39,15 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa
 				ret += ", ";
 			}
 			auto idx = list.offset + list_idx;
+
+			if (!struct_validity.RowIsValid(idx)) {
+				ret += "NULL";
+				continue;
+			}
 			if (!key_validity.RowIsValid(idx)) {
-				throw InternalException("Error in map: key validity invalid?!");
+				// throw InternalException("Error in map: key validity invalid?!");
+				ret += "invalid";
+				continue;
 			}
 			ret += key_data[idx].GetString();
 			ret += "=";
@@ -106,12 +66,11 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa
 BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::MAP:
-		return BoundCastInfo(MapToMapCast, BindMapToMapCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
 	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
-		// bind a cast in which we convert the key/value to VARCHAR entries
 		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-		return BoundCastInfo(MapToVarcharCast, BindMapToMapCast(input, source, varchar_type));
+		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type));
 	}
 	default:
 		return TryVectorNullCast;

package/src/duckdb/src/function/scalar/list/contains_or_position.cpp

@@ -140,7 +140,6 @@ static void ListContainsOrPosition(DataChunk &args, ExpressionState &state, Vect
 	case PhysicalType::VARCHAR:
 		TemplatedContainsOrPosition<string_t, T, OP>(args, state, result);
 		break;
-	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 	case PhysicalType::LIST:
 		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result, true);

package/src/duckdb/src/function/scalar/map/cardinality.cpp

@@ -8,17 +8,14 @@ namespace duckdb {
 
 static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &map = args.data[0];
-	UnifiedVectorFormat list_data;
 	UnifiedVectorFormat map_data;
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<uint64_t>(result);
 	auto &result_validity = FlatVector::Validity(result);
 
 	map.ToUnifiedFormat(args.size(), map_data);
-	auto &children = StructVector::GetEntries(map);
-	children[0]->ToUnifiedFormat(args.size(), list_data);
 	for (idx_t row = 0; row < args.size(); row++) {
-		auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
+		auto list_entry = ((list_entry_t *)map_data.data)[map_data.sel->get_index(row)];
 		result_data[row] = list_entry.length;
 		result_validity.Set(row, map_data.validity.RowIsValid(map_data.sel->get_index(row)));
 	}

package/src/duckdb/src/function/scalar/map/map.cpp

@@ -2,31 +2,25 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/aggregate/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/value_map.hpp"
 
 namespace duckdb {
 
-// TODO: this doesn't recursively verify maps if maps are nested
 MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
 	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
 	UnifiedVectorFormat map_vdata;
+
 	map.ToUnifiedFormat(count, map_vdata);
 	auto &map_validity = map_vdata.validity;
 
-	auto &key_vector = *(StructVector::GetEntries(map)[0]);
+	auto list_data = ListVector::GetData(map);
+	auto &keys = MapVector::GetKeys(map);
 	UnifiedVectorFormat key_vdata;
-	key_vector.ToUnifiedFormat(count, key_vdata);
-	auto key_data = (list_entry_t *)key_vdata.data;
+	keys.ToUnifiedFormat(count, key_vdata);
 	auto &key_validity = key_vdata.validity;
 
-	auto &key_entries = ListVector::GetEntry(key_vector);
-	UnifiedVectorFormat key_entry_vdata;
-	key_entries.ToUnifiedFormat(count, key_entry_vdata);
-	auto &entry_validity = key_entry_vdata.validity;
-
 	for (idx_t row = 0; row < count; row++) {
 		auto mapped_row = sel.get_index(row);
 		auto row_idx = map_vdata.sel->get_index(mapped_row);
@@ -35,17 +29,14 @@ MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVecto
 			continue;
 		}
 		row_idx = key_vdata.sel->get_index(row);
-		if (!key_validity.RowIsValid(row_idx)) {
-			return MapInvalidReason::NULL_KEY_LIST;
-		}
 		value_set_t unique_keys;
-		for (idx_t i = 0; i < key_data[row_idx].length; i++) {
-			auto index = key_data[row_idx].offset + i;
-			index = key_entry_vdata.sel->get_index(index);
-			if (!entry_validity.RowIsValid(index)) {
+		for (idx_t i = 0; i < list_data[row_idx].length; i++) {
+			auto index = list_data[row_idx].offset + i;
+			index = key_vdata.sel->get_index(index);
+			if (!key_validity.RowIsValid(index)) {
 				return MapInvalidReason::NULL_KEY;
 			}
-			auto value = key_entries.GetValue(index);
+			auto value = keys.GetValue(index);
 			auto result = unique_keys.insert(value);
 			if (!result.second) {
 				return MapInvalidReason::DUPLICATE_KEY;
@@ -86,28 +77,19 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 		}
 	}
 
-	auto &child_entries = StructVector::GetEntries(result);
-	D_ASSERT(child_entries.size() == 2);
-	auto &key_vector = *child_entries[0];
-	auto &value_vector = *child_entries[1];
-	if (args.data.empty()) {
-		// no arguments: construct an empty map
-		ListVector::SetListSize(key_vector, 0);
-		key_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto list_data = ConstantVector::GetData<list_entry_t>(key_vector);
-		list_data->offset = 0;
-		list_data->length = 0;
+	auto &key_vector = MapVector::GetKeys(result);
+	auto &value_vector = MapVector::GetValues(result);
+	auto list_data = ListVector::GetData(result);
 
-		ListVector::SetListSize(value_vector, 0);
-		value_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		list_data = ConstantVector::GetData<list_entry_t>(value_vector);
+	if (args.data.empty()) {
+		ListVector::SetListSize(result, 0);
 		list_data->offset = 0;
 		list_data->length = 0;
-
 		result.Verify(args.size());
 		return;
 	}
 
+	auto args_data = ListVector::GetData(args.data[0]);
 	auto key_count = ListVector::GetListSize(args.data[0]);
 	auto value_count = ListVector::GetListSize(args.data[1]);
 	if (key_count != value_count) {
@@ -115,11 +97,16 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 		    "Error in MAP creation: key list has a different size from value list (%lld keys, %lld values)", key_count,
 		    value_count);
 	}
+	ListVector::Reserve(result, key_count);
+	ListVector::SetListSize(result, key_count);
 
-	key_vector.Reference(args.data[0]);
-	value_vector.Reference(args.data[1]);
-	MapConversionVerify(result, args.size());
+	for (idx_t i = 0; i < args.size(); i++) {
+		list_data[i] = args_data[i];
+	}
 
+	key_vector.Reference(ListVector::GetEntry(args.data[0]));
+	value_vector.Reference(ListVector::GetEntry(args.data[1]));
+	MapConversionVerify(result, args.size());
 	result.Verify(args.size());
 }
 
@@ -147,8 +134,9 @@ static unique_ptr<FunctionData> MapBind(ClientContext &context, ScalarFunction &
 		child_types.push_back(make_pair("value", empty));
 	}
 
-	//! this is more for completeness reasons
-	bound_function.return_type = LogicalType::MAP(move(child_types));
+	bound_function.return_type =
+	    LogicalType::MAP(ListType::GetChildType(child_types[0].second), ListType::GetChildType(child_types[1].second));
+
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 

package/src/duckdb/src/function/scalar/map/map_extract.cpp

@@ -27,7 +27,6 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	if (args.data[1].GetType().id() == LogicalTypeId::SQLNULL) {
 		//! We don't need to look through the map if the 'key' to look for is NULL
-		//! Because maps can't have NULL as key
 		ListVector::SetListSize(result, 0);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		auto list_data = ConstantVector::GetData<list_entry_t>(result);
@@ -40,21 +39,23 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto &map = args.data[0];
 	auto &key = args.data[1];
 
-	UnifiedVectorFormat map_keys_data;
+	UnifiedVectorFormat map_data;
 	UnifiedVectorFormat key_data;
 
 	auto &map_keys = MapVector::GetKeys(map);
 	auto &map_values = MapVector::GetValues(map);
 
-	map_keys.ToUnifiedFormat(args.size(), map_keys_data);
+	map.ToUnifiedFormat(args.size(), map_data);
 	key.ToUnifiedFormat(args.size(), key_data);
 
 	for (idx_t row = 0; row < args.size(); row++) {
-		idx_t row_index = map_keys_data.sel->get_index(row);
+		idx_t row_index = map_data.sel->get_index(row);
 		idx_t key_index = key_data.sel->get_index(row);
 		auto key_value = key.GetValue(key_index);
-		auto offsets = ListVector::Search(map_keys, key_value, row_index);
-		auto values = ListVector::GetValuesFromOffsets(map_values, offsets);
+
+		list_entry_t entry = ListVector::GetData(map)[row_index];
+		auto offsets = MapVector::Search(map_keys, args.size(), key_value, entry);
+		auto values = FlatVector::GetValuesFromOffsets(map_values, offsets);
 		FillResult(values, result, row);
 	}
 

package/src/duckdb/src/function/scalar/map/map_from_entries.cpp

@@ -3,124 +3,14 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
 
 namespace duckdb {
 
-struct VectorInfo {
-	Vector &container;
-	list_entry_t &data;
-};
-
-static void MapStruct(Value &element, VectorInfo &keys, VectorInfo &values) {
-	D_ASSERT(element.type().id() == LogicalTypeId::STRUCT);
-	D_ASSERT(!element.IsNull());
-	auto &key_value = StructValue::GetChildren(element);
-	auto &key = key_value[0];
-	auto &value = key_value[1];
-
-	if (key.IsNull()) {
-		throw InvalidInputException("None of the keys of the map can be NULL");
-	}
-	// Add to the inner key/value lists of the resulting map
-	ListVector::PushBack(keys.container, key);
-	ListVector::PushBack(values.container, value);
-}
-
-// FIXME: this operation has a time complexity of O(n^2)
-void CheckKeyUniqueness(VectorInfo &keys) {
-	auto end = keys.data.offset + keys.data.length;
-	auto &entries = ListVector::GetEntry(keys.container);
-	for (auto lhs = keys.data.offset; lhs < end; lhs++) {
-		auto element = entries.GetValue(lhs);
-		D_ASSERT(!element.IsNull());
-		for (auto rhs = lhs + 1; rhs < end; rhs++) {
-			auto other = entries.GetValue(rhs);
-			D_ASSERT(!other.IsNull());
-
-			if (element.type() != other.type()) {
-				throw InvalidInputException("Not all keys are of the same type!");
-			}
-			if (element == other) {
-				throw InvalidInputException("The given keys aren't unique");
-			}
-		}
-	}
-}
-
-static bool MapSingleList(VectorInfo &input, VectorInfo &keys, VectorInfo &values) {
-	// Get the length and offset of this list from the argument data
-	auto pair_amount = input.data.length;
-	auto input_offset = input.data.offset;
-
-	// Loop over the list of structs
-	idx_t inserted_values = 0;
-	for (idx_t i = 0; i < pair_amount; i++) {
-		auto index = i + input_offset;
-		// Get the struct using the offset and the index;
-		auto element = input.container.GetValue(index);
-		if (element.IsNull()) {
-			continue;
-		}
-		MapStruct(element, keys, values);
-		inserted_values++;
-	}
-	// Set the length of the key value lists
-	keys.data.length = inserted_values;
-	values.data.length = inserted_values;
-	return inserted_values != 0;
-}
-
 static void MapFromEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-
-	result.SetVectorType(duckdb::VectorType::FLAT_VECTOR);
-
-	// Get the arguments vector
-	auto &input_list = args.data[0];
-	auto arg_data = FlatVector::GetData<list_entry_t>(input_list);
-	auto &entries = ListVector::GetEntry(input_list);
-
-	// Prepare the result vectors
-	auto &child_entries = StructVector::GetEntries(result);
-	D_ASSERT(child_entries.size() == 2);
-	auto &key_vector = *child_entries[0];
-	auto &value_vector = *child_entries[1];
-	auto &result_validity = FlatVector::Validity(result);
-
-	// Get the offset+length data for the list(s)
-	auto key_data = FlatVector::GetData<list_entry_t>(key_vector);
-	auto value_data = FlatVector::GetData<list_entry_t>(value_vector);
-
-	auto &key_validity = FlatVector::Validity(key_vector);
-	auto &value_validity = FlatVector::Validity(value_vector);
-
 	auto count = args.size();
 
-	UnifiedVectorFormat input_list_data;
-	input_list.ToUnifiedFormat(count, input_list_data);
-
-	// Current offset into the keys/values list
-	idx_t offset = 0;
-
-	// Transform to mapped values
-	for (idx_t i = 0; i < count; i++) {
-		VectorInfo input {entries, arg_data[i]};
-		VectorInfo keys {key_vector, key_data[i]};
-		VectorInfo values {value_vector, value_data[i]};
+	result.Reinterpret(args.data[0]);
 
-		keys.data.offset = offset;
-		values.data.offset = offset;
-		auto row_valid = MapSingleList(input, keys, values);
-		offset += keys.data.length;
-
-		// Check validity
-		if (!row_valid || !input_list_data.validity.RowIsValid(i)) {
-			key_validity.SetInvalid(i);
-			value_validity.SetInvalid(i);
-			result_validity.SetInvalid(i);
-		}
-	}
 	MapConversionVerify(result, count);
 	result.Verify(count);
 
@@ -131,8 +21,6 @@ static void MapFromEntriesFunction(DataChunk &args, ExpressionState &state, Vect
 
 static unique_ptr<FunctionData> MapFromEntriesBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
-	child_list_t<LogicalType> child_types;
-
 	if (arguments.size() != 1) {
 		throw InvalidInputException("The input argument must be a list of structs.");
 	}
@@ -155,11 +43,8 @@ static unique_ptr<FunctionData> MapFromEntriesBind(ClientContext &context, Scala
 	if (children.size() != 2) {
 		throw InvalidInputException("The provided struct type should only contain 2 fields, a key and a value");
 	}
-	child_types.push_back(make_pair("key", LogicalType::LIST(children[0].second)));
-	child_types.push_back(make_pair("value", LogicalType::LIST(children[1].second)));
 
-	//! this is more for completeness reasons
-	bound_function.return_type = LogicalType::MAP(move(child_types));
+	bound_function.return_type = LogicalType::MAP(elem_type);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -219,6 +219,7 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 		// FIXME: this is really hacky
 		// but the aggregate state export needs a rework around how it handles more complex aggregates anyway
 		vector<unique_ptr<Expression>> args;
+		args.reserve(state_type.bound_argument_types.size());
 		for (auto &arg_type : state_type.bound_argument_types) {
 			args.push_back(make_unique<BoundConstantExpression>(Value(arg_type)));
 		}
@@ -302,7 +303,6 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	// this should be required
 	D_ASSERT(bound_function.state_size);
 	D_ASSERT(bound_function.finalize);
-	D_ASSERT(!bound_function.window);
 
 	D_ASSERT(child_aggregate->function.return_type.id() != LogicalTypeId::INVALID);
 #ifdef DEBUG

package/src/duckdb/src/function/table/arrow.cpp

@@ -124,17 +124,13 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		return LogicalType::STRUCT(move(child_types));
 
 	} else if (format == "+m") {
-		child_list_t<LogicalType> child_types;
-		//! First type will be struct, so we skip it
-		auto &struct_schema = *schema.children[0];
-		for (idx_t type_idx = 0; type_idx < (idx_t)struct_schema.n_children; type_idx++) {
-			//! The other types must be added on lists
-			auto child_type = GetArrowLogicalType(*struct_schema.children[type_idx], arrow_convert_data, col_idx);
+		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 
-			auto list_type = LogicalType::LIST(child_type);
-			child_types.push_back({struct_schema.children[type_idx]->name, list_type});
-		}
-		return LogicalType::MAP(move(child_types));
+		auto &arrow_struct_type = *schema.children[0];
+		D_ASSERT(arrow_struct_type.n_children == 2);
+		auto key_type = GetArrowLogicalType(*arrow_struct_type.children[0], arrow_convert_data, col_idx);
+		auto value_type = GetArrowLogicalType(*arrow_struct_type.children[1], arrow_convert_data, col_idx);
+		return LogicalType::MAP(key_type, value_type);
 	} else if (format == "z") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		return LogicalType::BLOB;

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -227,47 +227,6 @@ void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
 	}
 }
 
-void ArrowToDuckDBMapList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                          unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                          pair<idx_t, idx_t> &arrow_convert_idx, uint32_t *offsets, ValidityMask *parent_mask) {
-	idx_t list_size = offsets[size] - offsets[0];
-	ListVector::Reserve(vector, list_size);
-
-	auto &child_vector = ListVector::GetEntry(vector);
-	auto list_data = FlatVector::GetData<list_entry_t>(vector);
-	auto cur_offset = 0;
-	for (idx_t i = 0; i < size; i++) {
-		auto &le = list_data[i];
-		le.offset = cur_offset;
-		le.length = offsets[i + 1] - offsets[i];
-		cur_offset += le.length;
-	}
-	ListVector::SetListSize(vector, list_size);
-	if (list_size == 0 && offsets[0] == 0) {
-		SetValidityMask(child_vector, array, scan_state, list_size, -1);
-	} else {
-		SetValidityMask(child_vector, array, scan_state, list_size, offsets[0]);
-	}
-
-	auto &list_mask = FlatVector::Validity(vector);
-	if (parent_mask) {
-		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
-		if (!parent_mask->AllValid()) {
-			for (idx_t i = 0; i < size; i++) {
-				if (!parent_mask->RowIsValid(i)) {
-					list_mask.SetInvalid(i);
-				}
-			}
-		}
-	}
-	if (list_size == 0 && offsets[0] == 0) {
-		ColumnArrowToDuckDB(child_vector, array, scan_state, list_size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                    -1);
-	} else {
-		ColumnArrowToDuckDB(child_vector, array, scan_state, list_size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                    offsets[0]);
-	}
-}
 template <class T>
 static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets) {
 	auto strings = FlatVector::GetData<string_t>(vector);
@@ -619,20 +578,8 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 		break;
 	}
 	case LogicalTypeId::MAP: {
-		//! Since this is a map we skip first child, because its a struct
-		auto &struct_arrow = *array.children[0];
-		auto &child_entries = StructVector::GetEntries(vector);
-		D_ASSERT(child_entries.size() == 2);
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + nested_offset;
-		}
-		auto &struct_validity_mask = FlatVector::Validity(vector);
-		//! Fill the children
-		for (idx_t type_idx = 0; type_idx < (idx_t)struct_arrow.n_children; type_idx++) {
-			ArrowToDuckDBMapList(*child_entries[type_idx], *struct_arrow.children[type_idx], scan_state, size,
-			                     arrow_convert_data, col_idx, arrow_convert_idx, offsets, &struct_validity_mask);
-		}
+		ArrowToDuckDBList(vector, array, scan_state, size, arrow_convert_data, col_idx, arrow_convert_idx,
+		                  nested_offset, parent_mask);
 		ArrowToDuckDBMapVerify(vector, size);
 		break;
 	}