duckdb 0.4.1-dev752.0 → 0.4.1-dev787.0

package/package.json

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

package/src/duckdb.cpp

@@ -45348,6 +45348,10 @@ struct MapFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct MapFromEntriesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct MapExtractFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -45416,6 +45420,7 @@ struct StructExtractFun {
 
 MapInvalidReason CheckMapValidity(Vector &map, idx_t count,
                                   const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+void MapConversionVerify(Vector &vector, idx_t count);
 
 } // namespace duckdb
 
@@ -98427,7 +98432,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 +98613,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 +100302,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListRangeFun>();
 	Register<ListFlattenFun>();
 	Register<MapFun>();
+	Register<MapFromEntriesFun>();
 	Register<MapExtractFun>();
 	Register<CardinalityFun>();
 }
@@ -105855,8 +106031,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());

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "208448575"
-#define DUCKDB_VERSION "v0.4.1-dev752"
+#define DUCKDB_SOURCE_ID "cafd60e6b"
+#define DUCKDB_VERSION "v0.4.1-dev787"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -3325,7 +3325,7 @@ public:
 	DUCKDB_API Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
 	                     reallocate_function_ptr_t reallocate_function_p,
 	                     unique_ptr<PrivateAllocatorData> private_data);
-	DUCKDB_API Allocator &operator=(Allocator &&allocator) noexcept = delete;
+	Allocator &operator=(Allocator &&allocator) noexcept = delete;
 	DUCKDB_API ~Allocator();
 
 	data_ptr_t AllocateData(idx_t size);
@@ -3656,8 +3656,8 @@ public:
 	DUCKDB_API BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node);
 	DUCKDB_API ~BufferHandle();
 	// disable copy constructors
-	DUCKDB_API BufferHandle(const BufferHandle &other) = delete;
-	DUCKDB_API BufferHandle &operator=(const BufferHandle &) = delete;
+	BufferHandle(const BufferHandle &other) = delete;
+	BufferHandle &operator=(const BufferHandle &) = delete;
 	//! enable move constructors
 	DUCKDB_API BufferHandle(BufferHandle &&other) noexcept;
 	DUCKDB_API BufferHandle &operator=(BufferHandle &&) noexcept;
@@ -6656,6 +6656,7 @@ class TableFunction;
 
 struct PragmaInfo;
 
+//! The default null handling is NULL in, NULL out
 enum class FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0, SPECIAL_HANDLING = 1 };
 enum class FunctionSideEffects : uint8_t { NO_SIDE_EFFECTS = 0, HAS_SIDE_EFFECTS = 1 };
 
@@ -11986,7 +11987,7 @@ public:
 	DUCKDB_API ColumnDependencyManager();
 	DUCKDB_API ~ColumnDependencyManager();
 	DUCKDB_API ColumnDependencyManager(ColumnDependencyManager &&other) = default;
-	DUCKDB_API ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
+	ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
 
 public:
 	//! Get the bind order that ensures dependencies are resolved before dependents are