duckdb 0.3.3-dev332.0 → 0.3.3-dev373.0

package/package.json

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

package/src/duckdb.cpp

@@ -51894,7 +51894,6 @@ SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSi
 	sink.Reset();
 
 	DataChunk &payload_chunk = sink.payload_chunk;
-	sink.child_executor.SetChunk(input);
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
 		DataChunk filtered_input;
 		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
@@ -51910,6 +51909,7 @@ SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSi
 			sink.child_executor.SetChunk(filtered_input);
 			payload_chunk.SetCardinality(count);
 		} else {
+			sink.child_executor.SetChunk(input);
 			payload_chunk.SetCardinality(input);
 		}
 		// resolve the child expressions of the aggregate (if any)
@@ -75343,6 +75343,11 @@ struct ListConcatFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListContainsFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CardinalityFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -83501,6 +83506,226 @@ void ListConcatFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+template <class T>
+static inline bool ValueCompare(const T &left, const T &right) {
+	return left == right;
+}
+
+template <>
+inline bool ValueCompare(const string_t &left, const string_t &right) {
+	return StringComparisonOperators::EqualsOrNot<false>(left, right);
+}
+
+template <>
+inline bool ValueCompare(const Value &left, const Value &right) {
+	return left == right;
+}
+
+template <class T>
+static void TemplatedListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
+	Vector &list = args.data[0];
+	Vector &value_vector = args.data[1];
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<bool>(result); // Create a vector of bool
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	auto list_size = ListVector::GetListSize(list);
+	auto &child_vector = ListVector::GetEntry(list);
+
+	VectorData child_data;
+	child_vector.Orrify(list_size, child_data);
+
+	VectorData list_data;
+	list.Orrify(count, list_data);
+	auto list_entries = (list_entry_t *)list_data.data;
+
+	VectorData value_data;
+	value_vector.Orrify(count, value_data);
+
+	for (idx_t i = 0; i < count; i++) {
+		auto list_index = list_data.sel->get_index(i);
+		auto value_index = value_data.sel->get_index(i);
+
+		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		const auto &list_entry = list_entries[list_index];
+		auto source_idx = child_data.sel->get_index(list_entry.offset);
+		auto child_value = FlatVector::GetData<T>(child_vector);
+
+		auto values = FlatVector::GetData<T>(value_vector);
+		result_entries[list_index] = false;
+		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
+			auto child_value_idx = source_idx + child_idx;
+
+			if (!child_data.validity.RowIsValid(child_value_idx)) {
+				continue;
+			}
+			if (ValueCompare<T>(child_value[child_value_idx], values[value_index])) {
+				result_entries[list_index] = true;
+				break; // Found value in list, no need to look further
+			}
+		}
+	}
+}
+
+static void NestedListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
+	Vector &list = args.data[0];
+	Vector &value_vector = args.data[1];
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<bool>(result); // Create a vector of bool
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	auto list_size = ListVector::GetListSize(list);
+	auto &child_vector = ListVector::GetEntry(list);
+
+	VectorData child_data;
+	child_vector.Orrify(list_size, child_data);
+
+	VectorData list_data;
+	list.Orrify(count, list_data);
+	auto list_entries = (list_entry_t *)list_data.data;
+
+	VectorData value_data;
+	value_vector.Orrify(count, value_data);
+
+	for (idx_t i = 0; i < count; i++) {
+		auto list_index = list_data.sel->get_index(i);
+		auto value_index = value_data.sel->get_index(i);
+
+		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		const auto &list_entry = list_entries[list_index];
+		auto source_idx = child_data.sel->get_index(list_entry.offset);
+
+		result_entries[list_index] = false;
+		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
+			auto child_value_idx = source_idx + child_idx;
+			if (!child_data.validity.RowIsValid(child_value_idx)) {
+				continue;
+			}
+			if (ValueCompare<Value>(child_vector.GetValue(child_value_idx), value_vector.GetValue(value_index))) {
+				result_entries[list_index] = true;
+				break; // Found value in list, no need to look further
+			}
+		}
+	}
+}
+
+static void ListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	switch (args.data[1].GetType().InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		TemplatedListContainsFunction<int8_t>(args, state, result);
+		break;
+	case PhysicalType::INT16:
+		TemplatedListContainsFunction<int16_t>(args, state, result);
+		break;
+	case PhysicalType::INT32:
+		TemplatedListContainsFunction<int32_t>(args, state, result);
+		break;
+	case PhysicalType::INT64:
+		TemplatedListContainsFunction<int64_t>(args, state, result);
+		break;
+	case PhysicalType::INT128:
+		TemplatedListContainsFunction<hugeint_t>(args, state, result);
+		break;
+	case PhysicalType::UINT8:
+		TemplatedListContainsFunction<uint8_t>(args, state, result);
+		break;
+	case PhysicalType::UINT16:
+		TemplatedListContainsFunction<uint16_t>(args, state, result);
+		break;
+	case PhysicalType::UINT32:
+		TemplatedListContainsFunction<uint32_t>(args, state, result);
+		break;
+	case PhysicalType::UINT64:
+		TemplatedListContainsFunction<uint64_t>(args, state, result);
+		break;
+	case PhysicalType::FLOAT:
+		TemplatedListContainsFunction<float>(args, state, result);
+		break;
+	case PhysicalType::DOUBLE:
+		TemplatedListContainsFunction<double>(args, state, result);
+		break;
+	case PhysicalType::VARCHAR:
+		TemplatedListContainsFunction<string_t>(args, state, result);
+		break;
+	case PhysicalType::MAP:
+	case PhysicalType::STRUCT:
+	case PhysicalType::LIST:
+		NestedListContainsFunction(args, state, result);
+		break;
+	default:
+		throw NotImplementedException("This function has not been implemented for this type");
+	}
+}
+
+static unique_ptr<FunctionData> ListContainsBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2);
+
+	const auto &list = arguments[0]->return_type; // change to list
+	const auto &value = arguments[1]->return_type;
+	if (list.id() == LogicalTypeId::SQLNULL && value.id() == LogicalTypeId::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.arguments[1] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+	} else if (list.id() == LogicalTypeId::SQLNULL || value.id() == LogicalTypeId::SQLNULL) {
+		// In case either the list or the value is NULL, return NULL
+		// Similar to behaviour of prestoDB
+		bound_function.arguments[0] = list;
+		bound_function.arguments[1] = value;
+		bound_function.return_type = LogicalTypeId::SQLNULL;
+	} else {
+		auto const &child_type = ListType::GetChildType(arguments[0]->return_type);
+		auto max_child_type = LogicalType::MaxLogicalType(child_type, value);
+		ExpressionBinder::ResolveParameterType(max_child_type);
+		auto list_type = LogicalType::LIST(max_child_type);
+
+		bound_function.arguments[0] = list_type;
+		bound_function.arguments[1] = value == max_child_type ? value : max_child_type;
+		bound_function.return_type = LogicalType::BOOLEAN;
+	}
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+ScalarFunction ListContainsFun::GetFunction() {
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
+	                      LogicalType::BOOLEAN,                                    // return type
+	                      ListContainsFunction, false, ListContainsBind, nullptr);
+}
+
+void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_contains", "array_contains", "list_has", "array_has"}, GetFunction());
+}
+} // namespace duckdb
+
+
+
 
 
 
@@ -85551,6 +85776,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<StructPackFun>();
 	Register<StructExtractFun>();
 	Register<ListConcatFun>();
+	Register<ListContainsFun>();
 	Register<ListValueFun>();
 	Register<ListExtractFun>();
 	Register<ListRangeFun>();

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 "618e5518a"
-#define DUCKDB_VERSION "v0.3.3-dev332"
+#define DUCKDB_SOURCE_ID "8a131088c"
+#define DUCKDB_VERSION "v0.3.3-dev373"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //