duckdb 0.4.1-dev754.0 → 0.4.1-dev790.0

package/src/duckdb.cpp

@@ -33160,6 +33160,8 @@ static inline int FastMemcmp(const void *str1, const void *str2, const size_t si
 
 
 
+
+
 namespace duckdb {
 
 class BufferManager;
@@ -33318,6 +33320,84 @@ private:
 	const bool flush;
 };
 
+struct SBIterator {
+	static int ComparisonValue(ExpressionType comparison);
+
+	SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0);
+
+	inline idx_t GetIndex() const {
+		return entry_idx;
+	}
+
+	inline void SetIndex(idx_t entry_idx_p) {
+		const auto new_block_idx = entry_idx_p / block_capacity;
+		if (new_block_idx != scan.block_idx) {
+			scan.SetIndices(new_block_idx, 0);
+			if (new_block_idx < block_count) {
+				scan.PinRadix(scan.block_idx);
+				block_ptr = scan.RadixPtr();
+				if (!all_constant) {
+					scan.PinData(*scan.sb->blob_sorting_data);
+				}
+			}
+		}
+
+		scan.entry_idx = entry_idx_p % block_capacity;
+		entry_ptr = block_ptr + scan.entry_idx * entry_size;
+		entry_idx = entry_idx_p;
+	}
+
+	inline SBIterator &operator++() {
+		if (++scan.entry_idx < block_capacity) {
+			entry_ptr += entry_size;
+			++entry_idx;
+		} else {
+			SetIndex(entry_idx + 1);
+		}
+
+		return *this;
+	}
+
+	inline SBIterator &operator--() {
+		if (scan.entry_idx) {
+			--scan.entry_idx;
+			--entry_idx;
+			entry_ptr -= entry_size;
+		} else {
+			SetIndex(entry_idx - 1);
+		}
+
+		return *this;
+	}
+
+	inline bool Compare(const SBIterator &other) const {
+		int comp_res;
+		if (all_constant) {
+			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
+		} else {
+			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
+		}
+
+		return comp_res <= cmp;
+	}
+
+	// Fixed comparison parameters
+	const SortLayout &sort_layout;
+	const idx_t block_count;
+	const idx_t block_capacity;
+	const size_t cmp_size;
+	const size_t entry_size;
+	const bool all_constant;
+	const bool external;
+	const int cmp;
+
+	// Iteration state
+	SBScanState scan;
+	idx_t entry_idx;
+	data_ptr_t block_ptr;
+	data_ptr_t entry_ptr;
+};
+
 } // namespace duckdb
 
 
@@ -35661,6 +35741,30 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	total_scanned += scanned;
 }
 
+int SBIterator::ComparisonValue(ExpressionType comparison) {
+	switch (comparison) {
+	case ExpressionType::COMPARE_LESSTHAN:
+	case ExpressionType::COMPARE_GREATERTHAN:
+		return -1;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		return 0;
+	default:
+		throw InternalException("Unimplemented comparison type for IEJoin!");
+	}
+}
+
+SBIterator::SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p)
+    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
+      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
+      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
+      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
+
+	scan.sb = gss.sorted_blocks[0].get();
+	scan.block_idx = block_count;
+	SetIndex(entry_idx_p);
+}
+
 } // namespace duckdb
 
 
@@ -45348,6 +45452,10 @@ struct MapFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct MapFromEntriesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct MapExtractFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -45416,6 +45524,7 @@ struct StructExtractFun {
 
 MapInvalidReason CheckMapValidity(Vector &map, idx_t count,
                                   const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+void MapConversionVerify(Vector &vector, idx_t count);
 
 } // namespace duckdb
 
@@ -60147,9 +60256,9 @@ public:
 	using Orders = vector<BoundOrderByNode>;
 	using Types = vector<LogicalType>;
 
-	WindowGlobalHashGroup(BufferManager &buffer_manager, const Orders &orders, const Types &payload_types,
-	                      idx_t max_mem, bool external)
-	    : memory_per_thread(max_mem), count(0) {
+	WindowGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
+	                      const Types &payload_types, idx_t max_mem, bool external)
+	    : memory_per_thread(max_mem), count(0), partition_layout(partitions) {
 
 		RowLayout payload_layout;
 		payload_layout.Initialize(payload_types);
@@ -60165,11 +60274,47 @@ public:
 		global_sort->PrepareMergePhase();
 	}
 
+	void ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask);
+
 	const idx_t memory_per_thread;
 	GlobalSortStatePtr global_sort;
 	atomic<idx_t> count;
+
+	// Mask computation
+	SortLayout partition_layout;
 };
 
+void WindowGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask) {
+	D_ASSERT(count > 0);
+
+	//	Set up a comparator for the partition subset
+	const auto partition_size = partition_layout.comparison_size;
+
+	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
+	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
+
+	partition_mask.SetValidUnsafe(0);
+	order_mask.SetValidUnsafe(0);
+	for (++curr; curr.GetIndex() < count; ++curr) {
+		//	Compare the partition subset first because if that differs, then so does the full ordering
+		int part_cmp = 0;
+		if (partition_layout.all_constant) {
+			part_cmp = FastMemcmp(prev.entry_ptr, curr.entry_ptr, partition_size);
+		} else {
+			part_cmp = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, partition_layout,
+			                                     prev.external);
+		}
+
+		if (part_cmp) {
+			partition_mask.SetValidUnsafe(curr.GetIndex());
+			order_mask.SetValidUnsafe(curr.GetIndex());
+		} else if (prev.Compare(curr)) {
+			order_mask.SetValidUnsafe(curr.GetIndex());
+		}
+		++prev;
+	}
+}
+
 //	Global sink state
 class WindowGlobalSinkState : public GlobalSinkState {
 public:
@@ -60199,6 +60344,7 @@ public:
 				orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
 				                    wexpr->partitions_stats[prt_idx]->Copy());
 			}
+			partitions.emplace_back(orders.back().Copy());
 		}
 
 		for (const auto &order : wexpr->orders) {
@@ -60215,8 +60361,8 @@ public:
 		lock_guard<mutex> guard(lock);
 
 		if (!ungrouped) {
-			ungrouped =
-			    make_unique<WindowGlobalHashGroup>(buffer_manager, orders, payload_types, memory_per_thread, external);
+			ungrouped = make_unique<WindowGlobalHashGroup>(buffer_manager, partitions, orders, payload_types,
+			                                               memory_per_thread, external);
 		}
 
 		return ungrouped.get();
@@ -60244,7 +60390,8 @@ public:
 		auto &hash_group = hash_groups[group];
 		if (!hash_group) {
 			const auto maxmem = memory_per_thread / partition_info.n_partitions;
-			hash_group = make_unique<WindowGlobalHashGroup>(buffer_manager, orders, payload_types, maxmem, external);
+			hash_group =
+			    make_unique<WindowGlobalHashGroup>(buffer_manager, partitions, orders, payload_types, maxmem, external);
 		}
 
 		return hash_group.get();
@@ -60271,6 +60418,7 @@ public:
 	mutex lock;
 
 	// Sorting
+	Orders partitions;
 	Orders orders;
 	Types payload_types;
 	HashGroupPtr ungrouped;
@@ -60671,7 +60819,7 @@ void WindowGlobalSinkState::Finalize() {
 		global_sort.InitializeMergeRound();
 		MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
 		merge_sorter.PerformInMergeRound();
-		global_sort.CompleteMergeRound();
+		global_sort.CompleteMergeRound(true);
 	}
 
 	// 	Sink it into a temporary local sink state
@@ -60714,120 +60862,6 @@ PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expr
     : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
 }
 
-struct MaskColumnOperator {
-	template <class INPUT_TYPE>
-	static INPUT_TYPE GetData(Vector &v, idx_t row_idx) {
-		auto data = FlatVector::GetData<INPUT_TYPE>(v);
-		return data[row_idx];
-	}
-};
-
-struct MaskColumnOperatorValue {
-	template <class INPUT_TYPE>
-	static INPUT_TYPE GetData(Vector &v, idx_t row_idx) {
-		return v.GetValue(row_idx);
-	}
-};
-
-template <typename INPUT_TYPE, class OP = MaskColumnOperator>
-static void MaskTypedColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	idx_t r = 0;
-	bool prev_valid;
-	INPUT_TYPE prev;
-	bool first_chunk = true;
-
-	for (auto &chunk : over_collection.Chunks()) {
-		auto &v = chunk->data[c];
-		auto validity = FlatVector::Validity(v);
-		if (mask.CheckAllValid(r + chunk->size(), r)) {
-#ifdef DEBUG
-			for (idx_t i = 0; i < chunk->size(); i++) {
-				D_ASSERT(mask.RowIsValid(r + i));
-			}
-#endif
-			// all valid for this chunk: we can skip this
-			// we should update the "prev" values though
-			auto last_idx = chunk->size() - 1;
-			prev_valid = validity.RowIsValid(last_idx);
-			prev = OP::template GetData<INPUT_TYPE>(v, last_idx);
-			first_chunk = false;
-			r += chunk->size();
-			continue;
-		}
-		idx_t start_index = 0;
-		if (first_chunk) {
-			// record the first value (if this is the first chunk)
-			prev_valid = validity.RowIsValid(0);
-			prev = OP::template GetData<INPUT_TYPE>(v, 0);
-			first_chunk = false;
-			start_index++;
-			r++;
-		}
-		for (idx_t i = start_index; i < chunk->size(); i++) {
-			auto curr_valid = validity.RowIsValid(i);
-			auto curr = OP::template GetData<INPUT_TYPE>(v, i);
-
-			if (!mask.RowIsValid(r)) {
-				if (curr_valid != prev_valid || (curr_valid && !Equals::Operation(curr, prev))) {
-					mask.SetValidUnsafe(r);
-				}
-			}
-			prev_valid = curr_valid;
-			prev = curr;
-			r++;
-		}
-	}
-}
-
-static void MaskColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	auto &vector = over_collection.GetChunk(0).data[c];
-	switch (vector.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		MaskTypedColumn<int8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT16:
-		MaskTypedColumn<int16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT32:
-		MaskTypedColumn<int32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT64:
-		MaskTypedColumn<int64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT8:
-		MaskTypedColumn<uint8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT16:
-		MaskTypedColumn<uint16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT32:
-		MaskTypedColumn<uint32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT64:
-		MaskTypedColumn<uint64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT128:
-		MaskTypedColumn<hugeint_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::FLOAT:
-		MaskTypedColumn<float>(mask, over_collection, c);
-		break;
-	case PhysicalType::DOUBLE:
-		MaskTypedColumn<double>(mask, over_collection, c);
-		break;
-	case PhysicalType::VARCHAR:
-		MaskTypedColumn<string_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INTERVAL:
-		MaskTypedColumn<interval_t>(mask, over_collection, c);
-		break;
-	default:
-		MaskTypedColumn<Value, MaskColumnOperatorValue>(mask, over_collection, c);
-		break;
-	}
-}
-
 static idx_t FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n) {
 	if (mask.AllValid()) {
 		auto start = MinValue(l + n - 1, r);
@@ -61656,31 +61690,12 @@ using WindowExpressions = vector<BoundWindowExpression *>;
 
 static void ComputeWindowExpressions(WindowExpressions &window_exprs, ChunkCollection &input,
                                      ChunkCollection &window_results, ChunkCollection &over,
+                                     const ValidityMask &partition_mask, const ValidityMask &order_mask,
                                      WindowAggregationMode mode) {
 	//	Idempotency
 	if (input.Count() == 0) {
 		return;
 	}
-	//	Pick out a function for the OVER clause
-	auto over_expr = window_exprs[0];
-
-	//	Set bits for the start of each partition
-	vector<validity_t> partition_bits(ValidityMask::EntryCount(input.Count()), 0);
-	ValidityMask partition_mask(partition_bits.data());
-	partition_mask.SetValid(0);
-
-	for (idx_t c = 0; c < over_expr->partitions.size(); ++c) {
-		MaskColumn(partition_mask, over, c);
-	}
-
-	//	Set bits for the start of each peer group.
-	//	Partitions also break peer groups, so start with the partition bits.
-	const auto sort_col_count = over_expr->partitions.size() + over_expr->orders.size();
-	ValidityMask order_mask(partition_mask, input.Count());
-	for (idx_t c = over_expr->partitions.size(); c < sort_col_count; ++c) {
-		MaskColumn(order_mask, over, c);
-	}
-
 	//	Compute the functions columnwise
 	for (idx_t expr_idx = 0; expr_idx < window_exprs.size(); ++expr_idx) {
 		ChunkCollection output(input.GetAllocator());
@@ -61714,6 +61729,24 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	// 3. Multiple partitions (sorting and hashing)
 	const auto &input_types = op.children[0]->types;
 
+	//	How big is the partition?
+	idx_t count = 0;
+	if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
+		count = gstate.hash_groups[hash_bin]->count;
+	} else if (gstate.rows && !hash_bin) {
+		count = gstate.count;
+	} else {
+		return;
+	}
+
+	//	Initialise masks to false
+	const auto bit_count = ValidityMask::ValidityMaskSize(count);
+	vector<validity_t> partition_bits(bit_count, 0);
+	ValidityMask partition_mask(partition_bits.data());
+
+	vector<validity_t> order_bits(bit_count, 0);
+	ValidityMask order_mask(order_bits.data());
+
 	// Scan the sorted data into new Collections
 	auto &allocator = gstate.allocator;
 	ChunkCollection input(allocator);
@@ -61721,9 +61754,12 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	if (gstate.rows && !hash_bin) {
 		//	No partition - convert row collection to chunk collection
 		ScanRowCollection(*gstate.rows, *gstate.strings, input, input_types);
+		partition_mask.SetValidUnsafe(0);
+		order_mask.SetValidUnsafe(0);
 	} else if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
 		// Overwrite the collections with the sorted data
 		state.hash_group = move(gstate.hash_groups[hash_bin]);
+		state.hash_group->ComputeMasks(partition_mask, order_mask);
 		const auto over_types = state.hash_group->global_sort->sort_layout.logical_types;
 		ScanSortedPartition(state, input, input_types, over, over_types);
 	} else {
@@ -61731,7 +61767,7 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	}
 
 	ChunkCollection output(allocator);
-	ComputeWindowExpressions(window_exprs, input, output, over, gstate.mode);
+	ComputeWindowExpressions(window_exprs, input, output, over, partition_mask, order_mask, gstate.mode);
 	state.chunks.Merge(input);
 	state.window_results.Merge(output);
 }
@@ -61832,7 +61868,7 @@ public:
 	}
 
 	void FinishEvent() override {
-		hash_group.global_sort->CompleteMergeRound();
+		hash_group.global_sort->CompleteMergeRound(true);
 		CreateMergeTasks(pipeline, *this, gstate, hash_group);
 	}
 
@@ -66073,7 +66109,6 @@ private:
 
 
 
-
 #include <thread>
 
 namespace duckdb {
@@ -66254,104 +66289,6 @@ OperatorResultType PhysicalIEJoin::Execute(ExecutionContext &context, DataChunk
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-struct SBIterator {
-	static int ComparisonValue(ExpressionType comparison) {
-		switch (comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHAN:
-			return -1;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			return 0;
-		default:
-			throw InternalException("Unimplemented comparison type for IEJoin!");
-		}
-	}
-
-	explicit SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0)
-	    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
-	      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
-	      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
-	      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
-
-		scan.sb = gss.sorted_blocks[0].get();
-		scan.block_idx = block_count;
-		SetIndex(entry_idx_p);
-	}
-
-	inline idx_t GetIndex() const {
-		return entry_idx;
-	}
-
-	inline void SetIndex(idx_t entry_idx_p) {
-		const auto new_block_idx = entry_idx_p / block_capacity;
-		if (new_block_idx != scan.block_idx) {
-			scan.SetIndices(new_block_idx, 0);
-			if (new_block_idx < block_count) {
-				scan.PinRadix(scan.block_idx);
-				block_ptr = scan.RadixPtr();
-				if (!all_constant) {
-					scan.PinData(*scan.sb->blob_sorting_data);
-				}
-			}
-		}
-
-		scan.entry_idx = entry_idx_p % block_capacity;
-		entry_ptr = block_ptr + scan.entry_idx * entry_size;
-		entry_idx = entry_idx_p;
-	}
-
-	inline SBIterator &operator++() {
-		if (++scan.entry_idx < block_capacity) {
-			entry_ptr += entry_size;
-			++entry_idx;
-		} else {
-			SetIndex(entry_idx + 1);
-		}
-
-		return *this;
-	}
-
-	inline SBIterator &operator--() {
-		if (scan.entry_idx) {
-			--scan.entry_idx;
-			--entry_idx;
-			entry_ptr -= entry_size;
-		} else {
-			SetIndex(entry_idx - 1);
-		}
-
-		return *this;
-	}
-
-	inline bool Compare(const SBIterator &other) const {
-		int comp_res;
-		if (all_constant) {
-			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
-		} else {
-			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
-		}
-
-		return comp_res <= cmp;
-	}
-
-	// Fixed comparison parameters
-	const SortLayout &sort_layout;
-	const idx_t block_count;
-	const idx_t block_capacity;
-	const size_t cmp_size;
-	const size_t entry_size;
-	const bool all_constant;
-	const bool external;
-	const int cmp;
-
-	// Iteration state
-	SBScanState scan;
-	idx_t entry_idx;
-	data_ptr_t block_ptr;
-	data_ptr_t entry_ptr;
-};
-
 struct IEJoinUnion {
 	using SortedTable = PhysicalRangeJoin::GlobalSortedTable;
 
@@ -98427,7 +98364,7 @@ MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVecto
 	return MapInvalidReason::VALID;
 }
 
-static void MapConversionVerify(Vector &vector, idx_t count) {
+void MapConversionVerify(Vector &vector, idx_t count) {
 	auto valid_check = CheckMapValidity(vector, count);
 	switch (valid_check) {
 	case MapInvalidReason::VALID:
@@ -98608,6 +98545,176 @@ void MapExtractFun::RegisterFunction(BuiltinFunctions &set) {
 }
 
 } // namespace duckdb
+
+
+
+
+
+
+
+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]};
+
+		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);
+}
+
+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.");
+	}
+	auto &list = arguments[0]->return_type;
+
+	if (list.id() == LogicalTypeId::UNKNOWN) {
+		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return nullptr;
+	}
+
+	if (list.id() != LogicalTypeId::LIST) {
+		throw InvalidInputException("The provided argument is not a list of structs");
+	}
+	auto &elem_type = ListType::GetChildType(list);
+	if (elem_type.id() != LogicalTypeId::STRUCT) {
+		throw InvalidInputException("The elements of the list must be structs");
+	}
+	auto &children = StructType::GetChildTypes(elem_type);
+	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));
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+void MapFromEntriesFun::RegisterFunction(BuiltinFunctions &set) {
+	//! the arguments and return types are actually set in the binder function
+	ScalarFunction fun("map_from_entries", {}, LogicalTypeId::MAP, MapFromEntriesFunction, MapFromEntriesBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -100127,6 +100234,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListRangeFun>();
 	Register<ListFlattenFun>();
 	Register<MapFun>();
+	Register<MapFromEntriesFun>();
 	Register<MapExtractFun>();
 	Register<CardinalityFun>();
 }
@@ -105855,8 +105963,8 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	if (key_child->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR ||
-	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
+
+	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw BinderException("Key name for struct_extract needs to be a constant string");
 	}
 	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());