duckdb 0.3.3-dev534.0 → 0.3.3-dev575.0

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,16 @@ struct ListContainsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListFlattenFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListPositionFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CardinalityFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -83759,6 +83785,231 @@ 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
 //
@@ -83797,6 +84048,142 @@ public:
 } // namespace duckdb
 
 
+namespace duckdb {
+
+void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 1);
+
+	Vector &input = args.data[0];
+	if (input.GetType().id() == LogicalTypeId::SQLNULL) {
+		result.Reference(input);
+		return;
+	}
+
+	idx_t count = args.size();
+
+	VectorData list_data;
+	input.Orrify(count, list_data);
+	auto list_entries = (list_entry_t *)list_data.data;
+
+	auto &child_vector = ListVector::GetEntry(input);
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<list_entry_t>(result);
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (child_vector.GetType().id() == LogicalTypeId::SQLNULL) {
+		auto result_entries = FlatVector::GetData<list_entry_t>(result);
+		for (idx_t i = 0; i < count; i++) {
+			auto list_index = list_data.sel->get_index(i);
+			if (!list_data.validity.RowIsValid(list_index)) {
+				result_validity.SetInvalid(i);
+				continue;
+			}
+			result_entries[i].offset = 0;
+			result_entries[i].length = 0;
+		}
+		return;
+	}
+
+	auto child_size = ListVector::GetListSize(input);
+	VectorData child_data;
+	child_vector.Orrify(child_size, child_data);
+	auto child_entries = (list_entry_t *)child_data.data;
+	auto &data_vector = ListVector::GetEntry(child_vector);
+
+	idx_t offset = 0;
+	for (idx_t i = 0; i < count; i++) {
+		auto list_index = list_data.sel->get_index(i);
+		if (!list_data.validity.RowIsValid(list_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+		auto list_entry = list_entries[list_index];
+
+		idx_t source_offset = 0;
+		// Find first valid child list entry to get offset
+		for (idx_t j = 0; j < list_entry.length; j++) {
+			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
+			if (child_data.validity.RowIsValid(child_list_index)) {
+				source_offset = child_entries[child_list_index].offset;
+				break;
+			}
+		}
+
+		idx_t length = 0;
+		// Find last valid child list entry to get length
+		for (idx_t j = list_entry.length - 1; j != (idx_t)-1; j--) {
+			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
+			if (child_data.validity.RowIsValid(child_list_index)) {
+				auto child_entry = child_entries[child_list_index];
+				length = child_entry.offset + child_entry.length - source_offset;
+				break;
+			}
+		}
+		ListVector::Append(result, data_vector, source_offset + length, source_offset);
+
+		result_entries[i].offset = offset;
+		result_entries[i].length = length;
+		offset += length;
+	}
+
+	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 1);
+
+	auto &input_type = arguments[0]->return_type;
+	bound_function.arguments[0] = input_type;
+	if (input_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return make_unique<VariableReturnBindData>(bound_function.return_type);
+	}
+	D_ASSERT(input_type.id() == LogicalTypeId::LIST);
+
+	auto child_type = ListType::GetChildType(input_type);
+	if (child_type.id() == LogicalType::SQLNULL) {
+		bound_function.return_type = input_type;
+		return make_unique<VariableReturnBindData>(bound_function.return_type);
+	}
+	D_ASSERT(child_type.id() == LogicalTypeId::LIST);
+
+	bound_function.return_type = child_type;
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, BoundFunctionExpression &expr,
+                                                   FunctionData *bind_data,
+                                                   vector<unique_ptr<BaseStatistics>> &child_stats) {
+	if (!child_stats[0]) {
+		return nullptr;
+	}
+	auto &list_stats = (ListStatistics &)*child_stats[0];
+	if (!list_stats.child_stats || list_stats.child_stats->type == LogicalTypeId::SQLNULL) {
+		return nullptr;
+	}
+
+	auto child_copy = list_stats.child_stats->Copy();
+	child_copy->validity_stats = make_unique<ValidityStatistics>(true);
+	return child_copy;
+}
+
+void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction fun({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
+	                   ListFlattenFunction, false, ListFlattenBind, nullptr, ListFlattenStats);
+	set.AddFunction({"flatten"}, fun);
+}
+
+} // namespace duckdb
+
+
+
+
+
+
 
 namespace duckdb {
 
@@ -83931,226 +84318,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,9 +86369,11 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<StructExtractFun>();
 	Register<ListConcatFun>();
 	Register<ListContainsFun>();
+	Register<ListPositionFun>();
 	Register<ListValueFun>();
 	Register<ListExtractFun>();
 	Register<ListRangeFun>();
+	Register<ListFlattenFun>();
 	Register<MapFun>();
 	Register<MapExtractFun>();
 	Register<CardinalityFun>();
@@ -104282,7 +104451,7 @@ class SelectStatement;
 
 class QueryRelation : public Relation {
 public:
-	QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt, string alias);
+	QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
 	~QueryRelation();
 
 	unique_ptr<SelectStatement> select_stmt;
@@ -104320,8 +104489,8 @@ namespace duckdb {
 
 class ReadCSVRelation : public Relation {
 public:
-	ReadCSVRelation(ClientContext &context, string csv_file, vector<ColumnDefinition> columns, bool auto_detect = false,
-	                string alias = string());
+	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file, vector<ColumnDefinition> columns,
+	                bool auto_detect = false, string alias = string());
 
 	string csv_file;
 	bool auto_detect;
@@ -104355,7 +104524,7 @@ namespace duckdb {
 
 class TableRelation : public Relation {
 public:
-	TableRelation(ClientContext &context, unique_ptr<TableDescription> description);
+	TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
 
 	unique_ptr<TableDescription> description;
 
@@ -104390,10 +104559,10 @@ namespace duckdb {
 
 class TableFunctionRelation : public Relation {
 public:
-	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr);
 
-	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr);
 
 	string name;
@@ -104430,9 +104599,10 @@ namespace duckdb {
 
 class ValueRelation : public Relation {
 public:
-	ValueRelation(ClientContext &context, const vector<vector<Value>> &values, vector<string> names,
+	ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
+	              vector<string> names, string alias = "values");
+	ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values, vector<string> names,
 	              string alias = "values");
-	ValueRelation(ClientContext &context, const string &values, vector<string> names, string alias = "values");
 
 	vector<vector<unique_ptr<ParsedExpression>>> expressions;
 	vector<string> names;
@@ -104467,7 +104637,7 @@ namespace duckdb {
 
 class ViewRelation : public Relation {
 public:
-	ViewRelation(ClientContext &context, string schema_name, string view_name);
+	ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name, string view_name);
 
 	string schema_name;
 	string view_name;
@@ -104662,7 +104832,7 @@ shared_ptr<Relation> Connection::Table(const string &schema_name, const string &
 	if (!table_info) {
 		throw Exception("Table does not exist!");
 	}
-	return make_shared<TableRelation>(*context, move(table_info));
+	return make_shared<TableRelation>(context, move(table_info));
 }
 
 shared_ptr<Relation> Connection::View(const string &tname) {
@@ -104670,7 +104840,7 @@ shared_ptr<Relation> Connection::View(const string &tname) {
 }
 
 shared_ptr<Relation> Connection::View(const string &schema_name, const string &table_name) {
-	return make_shared<ViewRelation>(*context, schema_name, table_name);
+	return make_shared<ViewRelation>(context, schema_name, table_name);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
@@ -104681,11 +104851,11 @@ shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
                                                const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(*context, fname, values, named_parameters);
+	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(*context, fname, values);
+	return make_shared<TableFunctionRelation>(context, fname, values);
 }
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
@@ -104695,7 +104865,7 @@ shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values, const vector<string> &column_names,
                                         const string &alias) {
-	return make_shared<ValueRelation>(*context, values, column_names, alias);
+	return make_shared<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::Values(const string &values) {
@@ -104704,7 +104874,7 @@ shared_ptr<Relation> Connection::Values(const string &values) {
 }
 
 shared_ptr<Relation> Connection::Values(const string &values, const vector<string> &column_names, const string &alias) {
-	return make_shared<ValueRelation>(*context, values, column_names, alias);
+	return make_shared<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
@@ -104716,7 +104886,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
 	for (idx_t i = 0; i < reader.sql_types.size(); i++) {
 		column_list.emplace_back(reader.col_names[i], reader.sql_types[i]);
 	}
-	return make_shared<ReadCSVRelation>(*context, csv_file, move(column_list), true);
+	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list), true);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<string> &columns) {
@@ -104729,19 +104899,19 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 		}
 		column_list.push_back(move(col_list[0]));
 	}
-	return make_shared<ReadCSVRelation>(*context, csv_file, move(column_list));
+	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list));
 }
 
 unordered_set<string> Connection::GetTableNames(const string &query) {
 	return context->GetTableNames(query);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(const string &query, string alias, const string &error) {
-	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), move(alias));
+shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias, const string &error) {
+	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), alias);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, string alias) {
-	return make_shared<QueryRelation>(*context, move(select_stmt), move(alias));
+shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
+	return make_shared<QueryRelation>(context, move(select_stmt), alias);
 }
 
 void Connection::BeginTransaction() {
@@ -114959,7 +115129,7 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
       child(move(child_p)) {
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
@@ -114968,7 +115138,7 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
       groups(move(groups_p)), child(move(child_p)) {
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
@@ -115104,7 +115274,7 @@ namespace duckdb {
 CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
     : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(move(child_p)),
       schema_name(move(schema_name)), table_name(move(table_name)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement CreateTableRelation::Bind(Binder &binder) {
@@ -115177,7 +115347,7 @@ CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view
                                        bool temporary_p)
     : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(move(child_p)),
       view_name(move(view_name_p)), replace(replace_p), temporary(temporary_p) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement CreateViewRelation::Bind(Binder &binder) {
@@ -115247,10 +115417,10 @@ namespace duckdb {
 
 CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p)
     : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(move(left_p)), right(move(right_p)) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
@@ -115295,7 +115465,7 @@ namespace duckdb {
 
 class DeleteRelation : public Relation {
 public:
-	DeleteRelation(ClientContext &context, unique_ptr<ParsedExpression> condition, string schema_name,
+	DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
 	               string table_name);
 
 	vector<ColumnDefinition> columns;
@@ -115353,11 +115523,11 @@ public:
 
 namespace duckdb {
 
-DeleteRelation::DeleteRelation(ClientContext &context, unique_ptr<ParsedExpression> condition_p, string schema_name_p,
-                               string table_name_p)
+DeleteRelation::DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
+                               string schema_name_p, string table_name_p)
     : Relation(context, RelationType::DELETE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
       table_name(move(table_name_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement DeleteRelation::Bind(Binder &binder) {
@@ -115430,7 +115600,7 @@ namespace duckdb {
 DistinctRelation::DistinctRelation(shared_ptr<Relation> child_p)
     : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(move(child_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> DistinctRelation::GetQueryNode() {
@@ -115496,7 +115666,7 @@ namespace duckdb {
 
 ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
     : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(move(child_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
@@ -115628,7 +115798,7 @@ namespace duckdb {
 FilterRelation::FilterRelation(shared_ptr<Relation> child_p, unique_ptr<ParsedExpression> condition_p)
     : Relation(child_p->context, RelationType::FILTER_RELATION), condition(move(condition_p)), child(move(child_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
@@ -115753,7 +115923,7 @@ namespace duckdb {
 InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
     : Relation(child_p->context, RelationType::INSERT_RELATION), child(move(child_p)), schema_name(move(schema_name)),
       table_name(move(table_name)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement InsertRelation::Bind(Binder &binder) {
@@ -115827,20 +115997,20 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
                            unique_ptr<ParsedExpression> condition_p, JoinType type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
       condition(move(condition_p)), join_type(type) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
                            JoinType type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
       using_columns(move(using_columns_p)), join_type(type) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
@@ -116007,7 +116177,7 @@ OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> o
     : Relation(child_p->context, RelationType::ORDER_RELATION), orders(move(orders)), child(move(child_p)) {
 	// bind the expressions
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
@@ -116094,7 +116264,7 @@ ProjectionRelation::ProjectionRelation(shared_ptr<Relation> child_p,
 		}
 	}
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
@@ -116151,9 +116321,10 @@ string ProjectionRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-QueryRelation::QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt_p, string alias_p)
+QueryRelation::QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
+                             string alias_p)
     : Relation(context, RelationType::QUERY_RELATION), select_stmt(move(select_stmt_p)), alias(move(alias_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 QueryRelation::~QueryRelation() {
@@ -116212,8 +116383,8 @@ string QueryRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ReadCSVRelation::ReadCSVRelation(ClientContext &context, string csv_file_p, vector<ColumnDefinition> columns_p,
-                                 bool auto_detect, string alias_p)
+ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file_p,
+                                 vector<ColumnDefinition> columns_p, bool auto_detect, string alias_p)
     : Relation(context, RelationType::READ_CSV_RELATION), csv_file(move(csv_file_p)), auto_detect(auto_detect),
       alias(move(alias_p)), columns(move(columns_p)) {
 	if (alias.empty()) {
@@ -116306,11 +116477,11 @@ namespace duckdb {
 SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, SetOperationType setop_type_p)
     : Relation(left_p->context, RelationType::SET_OPERATION_RELATION), left(move(left_p)), right(move(right_p)),
       setop_type(setop_type_p) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
@@ -116395,7 +116566,7 @@ namespace duckdb {
 SubqueryRelation::SubqueryRelation(shared_ptr<Relation> child_p, string alias_p)
     : Relation(child_p->context, RelationType::SUBQUERY_RELATION), child(move(child_p)), alias(move(alias_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> SubqueryRelation::GetQueryNode() {
@@ -116429,19 +116600,20 @@ string SubqueryRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
-                                             named_parameter_map_t named_parameters,
+TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
+                                             vector<Value> parameters_p, named_parameter_map_t named_parameters,
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
-TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
+TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
+                                             vector<Value> parameters_p,
 
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       input_relation(move(input_relation_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
@@ -116524,7 +116696,7 @@ namespace duckdb {
 
 class UpdateRelation : public Relation {
 public:
-	UpdateRelation(ClientContext &context, unique_ptr<ParsedExpression> condition, string schema_name,
+	UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
 	               string table_name, vector<string> update_columns, vector<unique_ptr<ParsedExpression>> expressions);
 
 	vector<ColumnDefinition> columns;
@@ -116550,7 +116722,7 @@ public:
 
 namespace duckdb {
 
-TableRelation::TableRelation(ClientContext &context, unique_ptr<TableDescription> description)
+TableRelation::TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
     : Relation(context, RelationType::TABLE_RELATION), description(move(description)) {
 }
 
@@ -116595,15 +116767,15 @@ static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const
 void TableRelation::Update(const string &update_list, const string &condition) {
 	vector<string> update_columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(context, condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetParserOptions());
+	auto cond = ParseCondition(*context.GetContext(), condition);
+	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetContext()->GetParserOptions());
 	auto update = make_shared<UpdateRelation>(context, move(cond), description->schema, description->table,
 	                                          move(update_columns), move(expressions));
 	update->Execute();
 }
 
 void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(context, condition);
+	auto cond = ParseCondition(*context.GetContext(), condition);
 	auto del = make_shared<DeleteRelation>(context, move(cond), description->schema, description->table);
 	del->Execute();
 }
@@ -116652,13 +116824,13 @@ public:
 
 namespace duckdb {
 
-UpdateRelation::UpdateRelation(ClientContext &context, unique_ptr<ParsedExpression> condition_p, string schema_name_p,
-                               string table_name_p, vector<string> update_columns_p,
+UpdateRelation::UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
+                               string schema_name_p, string table_name_p, vector<string> update_columns_p,
                                vector<unique_ptr<ParsedExpression>> expressions_p)
     : Relation(context, RelationType::UPDATE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
       table_name(move(table_name_p)), update_columns(move(update_columns_p)), expressions(move(expressions_p)) {
 	D_ASSERT(update_columns.size() == expressions.size());
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement UpdateRelation::Bind(Binder &binder) {
@@ -116702,8 +116874,8 @@ string UpdateRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>> &values, vector<string> names_p,
-                             string alias_p)
+ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
+                             vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
 	// create constant expressions for the values
 	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
@@ -116714,13 +116886,14 @@ ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>>
 		}
 		this->expressions.push_back(move(expressions));
 	}
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
-ValueRelation::ValueRelation(ClientContext &context, const string &values_list, vector<string> names_p, string alias_p)
+ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values_list,
+                             vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list, context.GetParserOptions());
-	context.TryBindRelation(*this, this->columns);
+	this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions());
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ValueRelation::GetQueryNode() {
@@ -116791,9 +116964,9 @@ string ValueRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ViewRelation::ViewRelation(ClientContext &context, string schema_name_p, string view_name_p)
+ViewRelation::ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
     : Relation(context, RelationType::VIEW_RELATION), schema_name(move(schema_name_p)), view_name(move(view_name_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
@@ -116896,7 +117069,7 @@ namespace duckdb {
 
 WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file_p)
     : Relation(child_p->context, RelationType::WRITE_CSV_RELATION), child(move(child_p)), csv_file(move(csv_file_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement WriteCSVRelation::Bind(Binder &binder) {
@@ -116958,7 +117131,7 @@ shared_ptr<Relation> Relation::Project(const string &expression, const string &a
 }
 
 shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list, context.GetParserOptions());
+	auto expressions = Parser::ParseExpressionList(select_list, context.GetContext()->GetParserOptions());
 	return make_shared<ProjectionRelation>(shared_from_this(), move(expressions), aliases);
 }
 
@@ -116984,12 +117157,12 @@ static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientCon
 }
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(context, expressions);
+	auto result_list = StringListToExpressionList(*context.GetContext(), expressions);
 	return make_shared<ProjectionRelation>(shared_from_this(), move(result_list), aliases);
 }
 
 shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(expression, context.GetContext()->GetParserOptions());
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
@@ -116998,7 +117171,7 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(context, expressions);
+	auto expression_list = StringListToExpressionList(*context.GetContext(), expressions);
 	D_ASSERT(!expression_list.empty());
 
 	auto expr = move(expression_list[0]);
@@ -117014,7 +117187,7 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 }
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression, context.GetParserOptions());
+	auto order_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
 	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
 }
 
@@ -117024,7 +117197,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 	}
 	vector<OrderByNode> order_list;
 	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression, context.GetParserOptions());
+		auto inner_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
 		if (inner_list.size() != 1) {
 			throw ParserException("Expected a single ORDER BY expression in the expression list");
 		}
@@ -117034,7 +117207,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
-	auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(condition, context.GetContext()->GetParserOptions());
 	D_ASSERT(!expression_list.empty());
 
 	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
@@ -117082,24 +117255,24 @@ shared_ptr<Relation> Relation::Alias(const string &alias) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
-	auto groups = Parser::ParseExpressionList(group_list, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
+	auto groups = Parser::ParseExpressionList(group_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list), move(groups));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(context, aggregates);
+	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(context, aggregates);
-	auto group_list = StringListToExpressionList(context, groups);
+	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
+	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list), move(group_list));
 }
 
@@ -117114,7 +117287,7 @@ unique_ptr<TableRef> Relation::GetTableRef() {
 }
 
 unique_ptr<QueryResult> Relation::Execute() {
-	return context.Execute(shared_from_this());
+	return context.GetContext()->Execute(shared_from_this());
 }
 
 BoundStatement Relation::Bind(Binder &binder) {
@@ -117137,7 +117310,7 @@ void Relation::Insert(const string &schema_name, const string &table_name) {
 
 void Relation::Insert(const vector<vector<Value>> &values) {
 	vector<string> column_names;
-	auto rel = make_shared<ValueRelation>(context, values, move(column_names), "values");
+	auto rel = make_shared<ValueRelation>(context.GetContext(), values, move(column_names), "values");
 	rel->Insert(GetAlias());
 }
 
@@ -117171,7 +117344,7 @@ shared_ptr<Relation> Relation::CreateView(const string &name, bool replace, bool
 }
 
 unique_ptr<QueryResult> Relation::Query(const string &sql) {
-	return context.Query(sql, false);
+	return context.GetContext()->Query(sql, false);
 }
 
 unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
@@ -117194,11 +117367,12 @@ void Relation::Delete(const string &condition) {
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
                                              const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters, shared_from_this());
+	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, named_parameters,
+	                                          shared_from_this());
 }
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context, fname, values, shared_from_this());
+	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, shared_from_this());
 }
 
 string Relation::ToString() {
@@ -148800,13 +148974,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 +149000,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));
 }