duckdb 0.3.3-dev534.0 → 0.3.3-dev551.0

package/package.json

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

package/src/duckdb.cpp

@@ -4212,6 +4212,10 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "array_append", {"arr", "el", nullptr}, "list_append(arr, el)"},
 	{DEFAULT_SCHEMA, "list_prepend", {"e", "l", nullptr}, "list_concat(list_value(e), l)"},
 	{DEFAULT_SCHEMA, "array_prepend", {"el", "arr", nullptr}, "list_prepend(el, arr)"},
+	{DEFAULT_SCHEMA, "array_pop_back", {"arr", nullptr}, "arr[:LEN(arr)-1]"},
+	{DEFAULT_SCHEMA, "array_pop_front", {"arr", nullptr}, "arr[1:]"},
+	{DEFAULT_SCHEMA, "array_push_back", {"arr", "e", nullptr}, "list_concat(arr, list_value(e))"},
+	{DEFAULT_SCHEMA, "array_push_front", {"arr", "e", nullptr}, "list_concat(list_value(e), arr)"},
 	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, "unnest(generate_series(1, array_length(arr, dim)))"},
 	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, "floor(x/y)"},
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
@@ -62789,9 +62793,15 @@ OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk
 				auto &list_vector = state.list_data.data[col_idx];
 				list_vector.Orrify(state.list_data.size(), state.list_vector_data[col_idx]);
 
-				auto &child_vector = ListVector::GetEntry(list_vector);
-				auto list_size = ListVector::GetListSize(list_vector);
-				child_vector.Orrify(list_size, state.list_child_data[col_idx]);
+				if (list_vector.GetType() == LogicalType::SQLNULL) {
+					// UNNEST(NULL)
+					auto &child_vector = list_vector;
+					child_vector.Orrify(0, state.list_child_data[col_idx]);
+				} else {
+					auto list_size = ListVector::GetListSize(list_vector);
+					auto &child_vector = ListVector::GetEntry(list_vector);
+					child_vector.Orrify(list_size, state.list_child_data[col_idx]);
+				}
 			}
 			state.first_fetch = false;
 		}
@@ -62840,34 +62850,40 @@ OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk
 		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
 			auto &result_vector = chunk.data[col_idx + input.ColumnCount()];
 
-			auto &vdata = state.list_vector_data[col_idx];
-			auto &child_data = state.list_child_data[col_idx];
-			auto current_idx = vdata.sel->get_index(state.parent_position);
-
-			auto list_data = (list_entry_t *)vdata.data;
-			auto list_entry = list_data[current_idx];
-
-			idx_t list_count;
-			if (state.list_position >= list_entry.length) {
-				list_count = 0;
+			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
+				// UNNEST(NULL)
+				chunk.SetCardinality(0);
 			} else {
-				list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
-			}
+				auto &vdata = state.list_vector_data[col_idx];
+				auto &child_data = state.list_child_data[col_idx];
+				auto current_idx = vdata.sel->get_index(state.parent_position);
 
-			if (list_entry.length > state.list_position) {
-				if (!vdata.validity.RowIsValid(current_idx)) {
-					UnnestNull(0, list_count, result_vector);
+				auto list_data = (list_entry_t *)vdata.data;
+				auto list_entry = list_data[current_idx];
+
+				idx_t list_count;
+				if (state.list_position >= list_entry.length) {
+					list_count = 0;
 				} else {
-					auto &list_vector = state.list_data.data[col_idx];
-					auto &child_vector = ListVector::GetEntry(list_vector);
-					auto list_size = ListVector::GetListSize(list_vector);
+					list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
+				}
+
+				if (list_entry.length > state.list_position) {
+					if (!vdata.validity.RowIsValid(current_idx)) {
+						UnnestNull(0, list_count, result_vector);
+					} else {
+						auto &list_vector = state.list_data.data[col_idx];
+						auto &child_vector = ListVector::GetEntry(list_vector);
+						auto list_size = ListVector::GetListSize(list_vector);
 
-					auto base_offset = list_entry.offset + state.list_position;
-					UnnestVector(child_data, child_vector, list_size, base_offset, base_offset + list_count,
-					             result_vector);
+						auto base_offset = list_entry.offset + state.list_position;
+						UnnestVector(child_data, child_vector, list_size, base_offset, base_offset + list_count,
+						             result_vector);
+					}
 				}
+
+				UnnestNull(list_count, this_chunk_len, result_vector);
 			}
-			UnnestNull(list_count, this_chunk_len, result_vector);
 		}
 
 		state.list_position += this_chunk_len;
@@ -75757,6 +75773,11 @@ struct ListContainsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListPositionFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CardinalityFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -83759,6 +83780,232 @@ void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+template <class T>
+static inline bool ValueEqualsOrNot(const T &left, const T &right) {
+	return left == right;
+}
+
+template <>
+inline bool ValueEqualsOrNot(const string_t &left, const string_t &right) {
+	return StringComparisonOperators::EqualsOrNot<false>(left, right);
+}
+
+struct ContainsFunctor {
+	static inline bool Initialize() {
+		return false;
+	}
+	static inline bool UpdateResultEntries(idx_t child_idx) {
+		return true;
+	}
+};
+
+struct PositionFunctor {
+	static inline int32_t Initialize() {
+		return 0;
+	}
+	static inline int32_t UpdateResultEntries(idx_t child_idx) {
+		return child_idx + 1;
+	}
+};
+
+template <class CHILD_TYPE, class RETURN_TYPE, class OP>
+static void TemplatedContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result,
+                                        bool is_nested = false) {
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
+	Vector &list = args.data[0];
+	Vector &value_vector = args.data[1];
+
+	// Create a result vector of type RETURN_TYPE
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<RETURN_TYPE>(result);
+	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);
+
+		// not required for a comparison of nested types
+		auto child_value = FlatVector::GetData<CHILD_TYPE>(child_vector);
+		auto values = FlatVector::GetData<CHILD_TYPE>(value_vector);
+
+		result_entries[list_index] = OP::Initialize();
+		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 (!is_nested) {
+				if (ValueEqualsOrNot<CHILD_TYPE>(child_value[child_value_idx], values[value_index])) {
+					result_entries[list_index] = OP::UpdateResultEntries(child_idx);
+					break; // Found value in list, no need to look further
+				}
+			} else {
+				// FIXME: using Value is less efficient than modifying the vector comparison code
+				// to more efficiently compare nested types
+				if (ValueEqualsOrNot<Value>(child_vector.GetValue(child_value_idx),
+				                            value_vector.GetValue(value_index))) {
+					result_entries[list_index] = OP::UpdateResultEntries(child_idx);
+					break; // Found value in list, no need to look further
+				}
+			}
+		}
+	}
+}
+
+template <class T, class OP>
+static void ListContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result) {
+	switch (args.data[1].GetType().InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::INT16:
+		TemplatedContainsOrPosition<int16_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::INT32:
+		TemplatedContainsOrPosition<int32_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::INT64:
+		TemplatedContainsOrPosition<int64_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::INT128:
+		TemplatedContainsOrPosition<hugeint_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::UINT8:
+		TemplatedContainsOrPosition<uint8_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::UINT16:
+		TemplatedContainsOrPosition<uint16_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::UINT32:
+		TemplatedContainsOrPosition<uint32_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::UINT64:
+		TemplatedContainsOrPosition<uint64_t, T, OP>(args, state, result);
+		break;
+	case PhysicalType::FLOAT:
+		TemplatedContainsOrPosition<float, T, OP>(args, state, result);
+		break;
+	case PhysicalType::DOUBLE:
+		TemplatedContainsOrPosition<double, T, OP>(args, state, result);
+		break;
+	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);
+		break;
+	default:
+		throw NotImplementedException("This function has not been implemented for this type");
+	}
+}
+
+static void ListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	return ListContainsOrPosition<bool, ContainsFunctor>(args, state, result);
+}
+
+static void ListPositionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	return ListContainsOrPosition<int32_t, PositionFunctor>(args, state, result);
+}
+
+template <LogicalTypeId RETURN_TYPE>
+static unique_ptr<FunctionData> ListContainsOrPositionBind(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;
+
+		// list_contains and list_position only differ in their return type
+		bound_function.return_type = RETURN_TYPE;
+	}
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+static unique_ptr<FunctionData> ListContainsBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+	return ListContainsOrPositionBind<LogicalType::BOOLEAN>(context, bound_function, arguments);
+}
+
+static unique_ptr<FunctionData> ListPositionBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+	return ListContainsOrPositionBind<LogicalType::INTEGER>(context, bound_function, arguments);
+}
+
+ScalarFunction ListContainsFun::GetFunction() {
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
+	                      LogicalType::BOOLEAN,                                    // return type
+	                      ListContainsFunction, false, ListContainsBind, nullptr);
+}
+
+ScalarFunction ListPositionFun::GetFunction() {
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
+	                      LogicalType::INTEGER,                                    // return type
+	                      ListPositionFunction, false, ListPositionBind, nullptr);
+}
+
+void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_contains", "array_contains", "list_has", "array_has"}, GetFunction());
+}
+
+void ListPositionFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_position", "list_indexof", "array_position", "array_indexof"}, GetFunction());
+}
+} // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -83931,226 +84178,6 @@ 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
-
-
-
 
 
 
@@ -86202,6 +86229,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<StructExtractFun>();
 	Register<ListConcatFun>();
 	Register<ListContainsFun>();
+	Register<ListPositionFun>();
 	Register<ListValueFun>();
 	Register<ListExtractFun>();
 	Register<ListRangeFun>();
@@ -148800,13 +148828,19 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
 	}
 	auto &child = (BoundExpression &)*function.children[0];
 	auto &child_type = child.expr->return_type;
-	if (child_type.id() != LogicalTypeId::LIST) {
-		return BindResult(binder.FormatError(function, "Unnest() can only be applied to lists"));
+
+	if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::SQLNULL) {
+		return BindResult(binder.FormatError(function, "Unnest() can only be applied to lists and NULL"));
 	}
+
 	if (depth > 0) {
 		throw BinderException(binder.FormatError(function, "Unnest() for correlated expressions is not supported yet"));
 	}
-	auto &return_type = ListType::GetChildType(child_type);
+
+	auto return_type = LogicalType(LogicalTypeId::SQLNULL);
+	if (child_type.id() == LogicalTypeId::LIST) {
+		return_type = ListType::GetChildType(child_type);
+	}
 
 	auto result = make_unique<BoundUnnestExpression>(return_type);
 	result->child = move(child.expr);
@@ -148820,6 +148854,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
 	auto colref = make_unique<BoundColumnRefExpression>(
 	    function.alias.empty() ? node.unnests[unnest_index]->ToString() : function.alias, return_type,
 	    ColumnBinding(node.unnest_index, unnest_index), depth);
+
 	return BindResult(move(colref));
 }
 

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 "c47290a22"
-#define DUCKDB_VERSION "v0.3.3-dev534"
+#define DUCKDB_SOURCE_ID "3af6ff8a3"
+#define DUCKDB_VERSION "v0.3.3-dev551"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //