duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

package/src/duckdb/src/function/scalar/date/strftime.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 
 #include <cctype>
+#include <utility>
 
 namespace duckdb {
 
@@ -153,7 +154,7 @@ idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time, int32_t utc_offset, c
 
 char *StrfTimeFormat::WriteString(char *target, const string_t &str) {
 	idx_t size = str.GetSize();
-	memcpy(target, str.GetDataUnsafe(), size);
+	memcpy(target, str.GetData(), size);
 	return target + size;
 }
 
@@ -603,7 +604,7 @@ struct StrfTimeBindData : public FunctionData {
 	bool is_null;
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StrfTimeBindData>(format, format_string, is_null);
+		return make_uniq<StrfTimeBindData>(format, format_string, is_null);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -633,7 +634,7 @@ static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, Sca
 			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
 		}
 	}
-	return make_unique<StrfTimeBindData>(format, format_string, is_null);
+	return make_uniq<StrfTimeBindData>(format, format_string, is_null);
 }
 
 void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t count) {
@@ -657,8 +658,8 @@ void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t coun
 
 template <bool REVERSED>
 static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
 
 	if (info.is_null) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -669,7 +670,7 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 }
 
 void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP);
+	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP || input.GetType().id() == LogicalTypeId::TIMESTAMP_TZ);
 	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
 	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
 	    input, result, count, [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
@@ -691,8 +692,8 @@ void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t
 
 template <bool REVERSED>
 static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
 
 	if (info.is_null) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -765,7 +766,7 @@ int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t s
                                            idx_t collection_count) {
 	for (idx_t c = 0; c < collection_count; c++) {
 		auto &entry = collection[c];
-		auto entry_data = entry.GetDataUnsafe();
+		auto entry_data = entry.GetData();
 		auto entry_size = entry.GetSize();
 		// check if this entry matches
 		if (pos + entry_size > size) {
@@ -804,7 +805,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 	result_data[6] = 0;
 	result_data[7] = 0;
 
-	auto data = str.GetDataUnsafe();
+	auto data = str.GetData();
 	idx_t size = str.GetSize();
 	// skip leading spaces
 	while (StringUtil::CharacterIsSpace(*data)) {
@@ -1187,20 +1188,24 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 }
 
 struct StrpTimeBindData : public FunctionData {
-	explicit StrpTimeBindData(StrpTimeFormat format_p, string format_string_p)
-	    : format(std::move(format_p)), format_string(std::move(format_string_p)) {
+	StrpTimeBindData(const StrpTimeFormat &format, const string &format_string)
+	    : formats(1, format), format_strings(1, format_string) {
 	}
 
-	StrpTimeFormat format;
-	string format_string;
+	StrpTimeBindData(vector<StrpTimeFormat> formats_p, vector<string> format_strings_p)
+	    : formats(std::move(formats_p)), format_strings(std::move(format_strings_p)) {
+	}
+
+	vector<StrpTimeFormat> formats;
+	vector<string> format_strings;
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StrpTimeBindData>(format, format_string);
+		return make_uniq<StrpTimeBindData>(formats, format_strings);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = (const StrpTimeBindData &)other_p;
-		return format_string == other.format_string;
+		return format_strings == other.format_strings;
 	}
 };
 
@@ -1212,13 +1217,13 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 	if (!arguments[1]->IsFoldable()) {
 		throw InvalidInputException("strptime format must be a constant");
 	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	string format_string = options_str.ToString();
+	Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+	string format_string;
 	StrpTimeFormat format;
-	if (!options_str.IsNull()) {
-		if (options_str.type().id() != LogicalTypeId::VARCHAR) {
-			throw InvalidInputException("strptime format must be a string");
-		}
+	if (format_value.IsNull()) {
+		return make_uniq<StrpTimeBindData>(format, format_string);
+	} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
+		format_string = format_value.ToString();
 		format.format_specifier = format_string;
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 		if (!error.empty()) {
@@ -1227,8 +1232,32 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
 			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
 		}
+		return make_uniq<StrpTimeBindData>(format, format_string);
+	} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
+		const auto &children = ListValue::GetChildren(format_value);
+		if (children.empty()) {
+			throw InvalidInputException("strptime format list must not be empty");
+		}
+		vector<string> format_strings;
+		vector<StrpTimeFormat> formats;
+		for (const auto &child : children) {
+			format_string = child.ToString();
+			format.format_specifier = format_string;
+			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+			if (!error.empty()) {
+				throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+			}
+			// If any format has UTC offsets, then we have to produce TSTZ
+			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
+				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+			}
+			format_strings.emplace_back(format_string);
+			formats.emplace_back(format);
+		}
+		return make_uniq<StrpTimeBindData>(formats, format_strings);
+	} else {
+		throw InvalidInputException("strptime format must be a string");
 	}
-	return make_unique<StrpTimeBindData>(format, format_string);
 }
 
 StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
@@ -1256,6 +1285,10 @@ date_t StrpTimeFormat::ParseResult::ToDate() {
 	return Date::FromDate(data[0], data[1], data[2]);
 }
 
+bool StrpTimeFormat::ParseResult::TryToDate(date_t &result) {
+	return Date::TryFromDate(data[0], data[1], data[2], result);
+}
+
 timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
 	date_t date = Date::FromDate(data[0], data[1], data[2]);
 	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
@@ -1264,6 +1297,17 @@ timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
 	return Timestamp::FromDatetime(date, time);
 }
 
+bool StrpTimeFormat::ParseResult::TryToTimestamp(timestamp_t &result) {
+	date_t date;
+	if (!TryToDate(date)) {
+		return false;
+	}
+	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
+	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
+	dtime_t time = Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
+	return Timestamp::TryFromDatetime(date, time, result);
+}
+
 string StrpTimeFormat::ParseResult::FormatError(string_t input, const string &format_specifier) {
 	return StringUtil::Format("Could not parse string \"%s\" according to format specifier \"%s\"\n%s\nError: %s",
 	                          input.GetString(), format_specifier,
@@ -1276,8 +1320,7 @@ bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_
 		error_message = parse_result.FormatError(input, format_specifier);
 		return false;
 	}
-	result = parse_result.ToDate();
-	return true;
+	return parse_result.TryToDate(result);
 }
 
 bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) {
@@ -1286,8 +1329,7 @@ bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, stri
 		error_message = parse_result.FormatError(input, format_specifier);
 		return false;
 	}
-	result = parse_result.ToTimestamp();
-	return true;
+	return parse_result.TryToTimestamp(result);
 }
 
 date_t StrpTimeFormat::ParseDate(string_t input) {
@@ -1306,28 +1348,83 @@ timestamp_t StrpTimeFormat::ParseTimestamp(string_t input) {
 	return result.ToTimestamp();
 }
 
-static void StrpTimeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrpTimeBindData &)*func_expr.bind_info;
+struct StrpTimeFunction {
 
-	if (ConstantVector::IsNull(args.data[1])) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
+	static void Parse(DataChunk &args, ExpressionState &state, Vector &result) {
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
+
+		if (ConstantVector::IsNull(args.data[1])) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
+		UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(), [&](string_t input) {
+			StrpTimeFormat::ParseResult result;
+			for (auto &format : info.formats) {
+				if (format.Parse(input, result)) {
+					return result.ToTimestamp();
+				}
+			}
+			throw InvalidInputException(result.FormatError(input, info.formats[0].format_specifier));
+		});
 	}
-	UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(),
-	                                              [&](string_t input) { return info.format.ParseTimestamp(input); });
-}
+
+	static void TryParse(DataChunk &args, ExpressionState &state, Vector &result) {
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
+
+		if (ConstantVector::IsNull(args.data[1])) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
+
+		UnaryExecutor::ExecuteWithNulls<string_t, timestamp_t>(
+		    args.data[0], result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
+			    timestamp_t result;
+			    string error;
+			    for (auto &format : info.formats) {
+				    if (format.TryParseTimestamp(input, result, error)) {
+					    return result;
+				    }
+			    }
+
+			    mask.SetInvalid(idx);
+			    return timestamp_t();
+		    });
+	}
+};
 
 void StrpTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet strptime("strptime");
 
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP, StrpTimeFunction,
-	                          StrpTimeBindFunction);
+	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
+	                          StrpTimeFunction::Parse, StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	strptime.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse,
+	                     StrpTimeBindFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	strptime.AddFunction(fun);
 
 	set.AddFunction(strptime);
+
+	ScalarFunctionSet try_strptime("try_strptime");
+
+	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
+	                     StrpTimeFunction::TryParse, StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	try_strptime.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::TryParse,
+	                     StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	try_strptime.AddFunction(fun);
+
+	set.AddFunction(try_strptime);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/generic/alias.cpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	Value v(state.expr.alias.empty() ? func_expr.children[0]->GetName() : state.expr.alias);
 	result.Reference(v);
 }

package/src/duckdb/src/function/scalar/generic/constant_or_null.cpp

@@ -13,7 +13,7 @@ struct ConstantOrNullBindData : public FunctionData {
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ConstantOrNullBindData>(value);
+		return make_uniq<ConstantOrNullBindData>(value);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -23,8 +23,8 @@ public:
 };
 
 static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ConstantOrNullBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ConstantOrNullBindData>();
 	result.Reference(info.value);
 	for (idx_t idx = 1; idx < args.ColumnCount(); idx++) {
 		switch (args.data[idx].GetVectorType()) {
@@ -70,7 +70,7 @@ ScalarFunction ConstantOrNull::GetFunction(const LogicalType &return_type) {
 }
 
 unique_ptr<FunctionData> ConstantOrNull::Bind(Value value) {
-	return make_unique<ConstantOrNullBindData>(std::move(value));
+	return make_uniq<ConstantOrNullBindData>(std::move(value));
 }
 
 bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value &val) {
@@ -78,7 +78,7 @@ bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value
 		return false;
 	}
 	D_ASSERT(expr.bind_info);
-	auto &bind_data = (ConstantOrNullBindData &)*expr.bind_info;
+	auto &bind_data = expr.bind_info->Cast<ConstantOrNullBindData>();
 	D_ASSERT(bind_data.value.type() == val.type());
 	return bind_data.value == val;
 }
@@ -94,7 +94,7 @@ unique_ptr<FunctionData> ConstantOrNullBind(ClientContext &context, ScalarFuncti
 	D_ASSERT(arguments.size() >= 2);
 	auto value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
 	bound_function.return_type = arguments[0]->return_type;
-	return make_unique<ConstantOrNullBindData>(std::move(value));
+	return make_uniq<ConstantOrNullBindData>(std::move(value));
 }
 
 void ConstantOrNull::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/generic/current_setting.cpp

@@ -15,7 +15,7 @@ struct CurrentSettingBindData : public FunctionData {
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<CurrentSettingBindData>(value);
+		return make_uniq<CurrentSettingBindData>(value);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -25,8 +25,8 @@ public:
 };
 
 static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (CurrentSettingBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<CurrentSettingBindData>();
 	result.Reference(info.value);
 }
 
@@ -41,7 +41,7 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw ParserException("Key name for current_setting needs to be a constant string");
 	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child.get());
+	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
 	auto &key_str = StringValue::Get(key_val);
 	if (key_val.IsNull() || key_str.empty()) {
@@ -55,7 +55,7 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	}
 
 	bound_function.return_type = val.type();
-	return make_unique<CurrentSettingBindData>(val);
+	return make_uniq<CurrentSettingBindData>(val);
 }
 
 void CurrentSettingFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/generic/error.cpp

@@ -0,0 +1,21 @@
+#include "duckdb/function/scalar/generic_functions.hpp"
+#include <iostream>
+
+namespace duckdb {
+
+struct ErrorOperator {
+	template <class TA, class TR>
+	static inline TR Operation(const TA &input) {
+		throw Exception(input.GetString());
+	}
+};
+
+void ErrorFun::RegisterFunction(BuiltinFunctions &set) {
+	auto fun = ScalarFunction("error", {LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                          ScalarFunction::UnaryFunction<string_t, bool, ErrorOperator>);
+	// Set the function with side effects to avoid the optimization.
+	fun.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/generic/stats.cpp

@@ -11,7 +11,7 @@ struct StatsBindData : public FunctionData {
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StatsBindData>(stats);
+		return make_uniq<StatsBindData>(stats);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -21,8 +21,8 @@ public:
 };
 
 static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StatsBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StatsBindData>();
 	if (info.stats.empty()) {
 		info.stats = "No statistics";
 	}
@@ -32,16 +32,14 @@ static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &resul
 
 unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound_function,
                                    vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<StatsBindData>();
+	return make_uniq<StatsBindData>();
 }
 
 static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
-	if (child_stats[0]) {
-		auto &info = (StatsBindData &)*bind_data;
-		info.stats = child_stats[0]->ToString();
-	}
+	auto &info = bind_data->Cast<StatsBindData>();
+	info.stats = child_stats[0].ToString();
 	return nullptr;
 }
 

package/src/duckdb/src/function/scalar/generic_functions.cpp

@@ -12,6 +12,7 @@ void BuiltinFunctions::RegisterGenericFunctions() {
 	Register<ConstantOrNull>();
 	Register<CurrentSettingFun>();
 	Register<SystemFun>();
+	Register<ErrorFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/array_slice.cpp

@@ -187,7 +187,7 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
 	}
 
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
 void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/list/contains_or_position.cpp

@@ -5,156 +5,14 @@
 
 namespace duckdb {
 
-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);
-
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(list_size, child_data);
-
-	UnifiedVectorFormat list_data;
-	list.ToUnifiedFormat(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
-
-	UnifiedVectorFormat value_data;
-	value_vector.ToUnifiedFormat(count, value_data);
-
-	// not required for a comparison of nested types
-	auto child_value = (CHILD_TYPE *)child_data.data;
-	auto values = (CHILD_TYPE *)value_data.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];
-
-		result_entries[i] = OP::Initialize();
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			auto child_value_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			if (!child_data.validity.RowIsValid(child_value_idx)) {
-				continue;
-			}
-
-			if (!is_nested) {
-				if (Equals::Operation(child_value[child_value_idx], values[value_index])) {
-					result_entries[i] = 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
-				auto lvalue = child_vector.GetValue(child_value_idx);
-				auto rvalue = value_vector.GetValue(value_index);
-				if (Value::NotDistinctFrom(lvalue, rvalue)) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			}
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-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::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);
+	(void)state;
+	return ListContainsOrPosition<bool, ContainsFunctor, ListArgFunctor>(args, result);
 }
 
 static void ListPositionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	return ListContainsOrPosition<int32_t, PositionFunctor>(args, state, result);
+	(void)state;
+	return ListContainsOrPosition<int32_t, PositionFunctor, ListArgFunctor>(args, result);
 }
 
 template <LogicalTypeId RETURN_TYPE>
@@ -188,7 +46,7 @@ static unique_ptr<FunctionData> ListContainsOrPositionBind(ClientContext &contex
 		// 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);
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
 static unique_ptr<FunctionData> ListContainsBind(ClientContext &context, ScalarFunction &bound_function,