duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/function/scalar/string/concat.cpp

@@ -4,12 +4,41 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 
 #include <string.h>
 
 namespace duckdb {
 
-static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+struct ConcatFunctionData : public FunctionData {
+	ConcatFunctionData(const LogicalType &return_type_p, bool is_operator_p)
+	    : return_type(return_type_p), is_operator(is_operator_p) {
+	}
+	~ConcatFunctionData() override;
+
+	LogicalType return_type;
+
+	bool is_operator = false;
+
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
+};
+
+ConcatFunctionData::~ConcatFunctionData() {
+}
+
+bool ConcatFunctionData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ConcatFunctionData>();
+	return return_type == other.return_type && is_operator == other.is_operator;
+}
+
+unique_ptr<FunctionData> ConcatFunctionData::Copy() const {
+	return make_uniq<ConcatFunctionData>(return_type, is_operator);
+}
+
+static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	// iterate over the vectors to count how large the final string will be
 	idx_t constant_lengths = 0;
@@ -114,130 +143,234 @@ static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &resu
 	    });
 }
 
-static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel,
-                              const SelectionVector &rsel, idx_t count, Vector &result) {
-	vector<idx_t> result_lengths(args.size(), 0);
-	vector<bool> has_results(args.size(), false);
-
-	// we overallocate here, but this is important for static analysis
-	auto orrified_data = make_unsafe_uniq_array<UnifiedVectorFormat>(args.ColumnCount());
+static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
 
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
+	Vector &lhs = args.data[0];
+	Vector &rhs = args.data[1];
+	if (lhs.GetType().id() == LogicalTypeId::SQLNULL) {
+		result.Reference(rhs);
+		return;
+	}
+	if (rhs.GetType().id() == LogicalTypeId::SQLNULL) {
+		result.Reference(lhs);
+		return;
 	}
 
-	// first figure out the lengths
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
+	UnifiedVectorFormat lhs_data;
+	UnifiedVectorFormat rhs_data;
+	lhs.ToUnifiedFormat(count, lhs_data);
+	rhs.ToUnifiedFormat(count, rhs_data);
+	auto lhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(lhs_data);
+	auto rhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(rhs_data);
 
-		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				result_lengths[ridx] += sep_data[sep_idx].GetSize();
-			}
-			result_lengths[ridx] += input_data[idx].GetSize();
-			has_results[ridx] = true;
+	auto lhs_list_size = ListVector::GetListSize(lhs);
+	auto rhs_list_size = ListVector::GetListSize(rhs);
+	auto &lhs_child = ListVector::GetEntry(lhs);
+	auto &rhs_child = ListVector::GetEntry(rhs);
+	UnifiedVectorFormat lhs_child_data;
+	UnifiedVectorFormat rhs_child_data;
+	lhs_child.ToUnifiedFormat(lhs_list_size, lhs_child_data);
+	rhs_child.ToUnifiedFormat(rhs_list_size, rhs_child_data);
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<list_entry_t>(result);
+	auto &result_validity = FlatVector::Validity(result);
+
+	idx_t offset = 0;
+	for (idx_t i = 0; i < count; i++) {
+		auto lhs_list_index = lhs_data.sel->get_index(i);
+		auto rhs_list_index = rhs_data.sel->get_index(i);
+		if (!lhs_data.validity.RowIsValid(lhs_list_index) && !rhs_data.validity.RowIsValid(rhs_list_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+		result_entries[i].offset = offset;
+		result_entries[i].length = 0;
+		if (lhs_data.validity.RowIsValid(lhs_list_index)) {
+			const auto &lhs_entry = lhs_entries[lhs_list_index];
+			result_entries[i].length += lhs_entry.length;
+			ListVector::Append(result, lhs_child, *lhs_child_data.sel, lhs_entry.offset + lhs_entry.length,
+			                   lhs_entry.offset);
 		}
+		if (rhs_data.validity.RowIsValid(rhs_list_index)) {
+			const auto &rhs_entry = rhs_entries[rhs_list_index];
+			result_entries[i].length += rhs_entry.length;
+			ListVector::Append(result, rhs_child, *rhs_child_data.sel, rhs_entry.offset + rhs_entry.length,
+			                   rhs_entry.offset);
+		}
+		offset += result_entries[i].length;
 	}
+	D_ASSERT(ListVector::GetListSize(result) == offset);
 
-	// first we allocate the empty strings for each of the values
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		// allocate an empty string of the required size
-		result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]);
-		// we reuse the result_lengths vector to store the currently appended size
-		result_lengths[ridx] = 0;
-		has_results[ridx] = false;
+	if (lhs.GetVectorType() == VectorType::CONSTANT_VECTOR && rhs.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
+}
 
-	// now that the empty space for the strings has been allocated, perform the concatenation
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
-		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				auto sep_size = sep_data[sep_idx].GetSize();
-				auto sep_ptr = sep_data[sep_idx].GetData();
-				memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size);
-				result_lengths[ridx] += sep_size;
-			}
-			auto input_ptr = input_data[idx].GetData();
-			auto input_len = input_data[idx].GetSize();
-			memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len);
-			result_lengths[ridx] += input_len;
-			has_results[ridx] = true;
-		}
+static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ConcatFunctionData>();
+	if (info.return_type.id() == LogicalTypeId::LIST) {
+		return ListConcatFunction(args, state, result);
+	} else if (info.is_operator) {
+		return ConcatOperator(args, state, result);
 	}
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		result_data[ridx].Finalize();
+	return StringConcatFunction(args, state, result);
+}
+
+static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) {
+	if (is_operator) {
+		bound_function.arguments[0] = type;
+		bound_function.arguments[1] = type;
+		bound_function.return_type = type;
+		return;
 	}
+
+	for (auto &arg : bound_function.arguments) {
+		arg = type;
+	}
+	bound_function.varargs = type;
+	bound_function.return_type = type;
 }
 
-static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &separator = args.data[0];
-	UnifiedVectorFormat vdata;
-	separator.ToUnifiedFormat(args.size(), vdata);
+static void HandleArrayBinding(ClientContext &context, vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[1]->return_type.id() != LogicalTypeId::ARRAY &&
+	    arguments[1]->return_type.id() != LogicalTypeId::SQLNULL) {
+		throw BinderException("Cannot concatenate types %s and %s", arguments[0]->return_type.ToString(),
+		                      arguments[1]->return_type.ToString());
+	}
 
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			break;
-		}
+	// if either argument is an array, we cast it to a list
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+	arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1]));
+}
+
+static unique_ptr<FunctionData> HandleListBinding(ClientContext &context, ScalarFunction &bound_function,
+                                                  vector<unique_ptr<Expression>> &arguments, bool is_operator) {
+	// list_concat only accepts two arguments
+	D_ASSERT(arguments.size() == 2);
+
+	auto &lhs = arguments[0]->return_type;
+	auto &rhs = arguments[1]->return_type;
+
+	if (lhs.id() == LogicalTypeId::UNKNOWN || rhs.id() == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	} else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
+		// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
+		auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
+		SetArgumentType(bound_function, return_type, is_operator);
+		return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 	}
-	switch (separator.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		if (ConstantVector::IsNull(separator)) {
-			// constant NULL as separator: return constant NULL vector
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		// no null values
-		auto sel = FlatVector::IncrementalSelectionVector();
-		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, *sel, args.size(), result);
-		return;
+	if (lhs.id() != LogicalTypeId::LIST || rhs.id() != LogicalTypeId::LIST) {
+		throw BinderException("Cannot concatenate types %s and %s", lhs.ToString(), rhs.ToString());
 	}
-	default: {
-		// default case: loop over nullmask and create a non-null selection vector
-		idx_t not_null_count = 0;
-		SelectionVector not_null_vector(STANDARD_VECTOR_SIZE);
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < args.size(); i++) {
-			if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-				result_mask.SetInvalid(i);
-			} else {
-				not_null_vector.set_index(not_null_count++, i);
-			}
+
+	// Resolve list type
+	LogicalType child_type = LogicalType::SQLNULL;
+	for (const auto &argument : arguments) {
+		auto &next_type = ListType::GetChildType(argument->return_type);
+		if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) {
+			throw BinderException("Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required",
+			                      child_type.ToString(), next_type.ToString());
 		}
-		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, not_null_vector,
-		                  not_null_count, result);
-		return;
 	}
+	auto list_type = LogicalType::LIST(child_type);
+
+	SetArgumentType(bound_function, list_type, is_operator);
+	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
+}
+
+static void FindFirstTwoArguments(vector<unique_ptr<Expression>> &arguments, LogicalTypeId &first_arg,
+                                  LogicalTypeId &second_arg) {
+	first_arg = arguments[0]->return_type.id();
+	second_arg = first_arg;
+	if (arguments.size() > 1) {
+		second_arg = arguments[1]->return_type.id();
 	}
 }
 
 static unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
-	for (auto &arg : bound_function.arguments) {
-		arg = LogicalType::VARCHAR;
+	LogicalTypeId first_arg;
+	LogicalTypeId second_arg;
+	FindFirstTwoArguments(arguments, first_arg, second_arg);
+
+	if (arguments.size() > 2 && (first_arg == LogicalTypeId::ARRAY || first_arg == LogicalTypeId::LIST)) {
+		throw BinderException("list_concat only accepts two arguments");
+	}
+
+	if (first_arg == LogicalTypeId::ARRAY || second_arg == LogicalTypeId::ARRAY) {
+		HandleArrayBinding(context, arguments);
+		FindFirstTwoArguments(arguments, first_arg, second_arg);
+	}
+
+	if (first_arg == LogicalTypeId::LIST || second_arg == LogicalTypeId::LIST) {
+		return HandleListBinding(context, bound_function, arguments, false);
+	}
+
+	// we can now assume that the input is a string or castable to a string
+	SetArgumentType(bound_function, LogicalType::VARCHAR, false);
+	return make_uniq<ConcatFunctionData>(bound_function.return_type, false);
+}
+
+static unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(arguments.size() == 2);
+
+	LogicalTypeId lhs;
+	LogicalTypeId rhs;
+	FindFirstTwoArguments(arguments, lhs, rhs);
+
+	if (lhs == LogicalTypeId::UNKNOWN || rhs == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	}
+	if (lhs == LogicalTypeId::ARRAY || rhs == LogicalTypeId::ARRAY) {
+		HandleArrayBinding(context, arguments);
+		FindFirstTwoArguments(arguments, lhs, rhs);
+	}
+
+	if (lhs == LogicalTypeId::LIST || rhs == LogicalTypeId::LIST) {
+		return HandleListBinding(context, bound_function, arguments, true);
+	}
+
+	LogicalType return_type;
+	if (lhs == LogicalTypeId::BLOB && rhs == LogicalTypeId::BLOB) {
+		return_type = LogicalType::BLOB;
+	} else {
+		return_type = LogicalType::VARCHAR;
 	}
-	bound_function.varargs = LogicalType::VARCHAR;
-	return nullptr;
+
+	// we can now assume that the input is a string or castable to a string
+	SetArgumentType(bound_function, return_type, true);
+	return make_uniq<ConcatFunctionData>(bound_function.return_type, true);
+}
+
+static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	D_ASSERT(child_stats.size() == 2);
+
+	auto &left_stats = child_stats[0];
+	auto &right_stats = child_stats[1];
+
+	auto stats = left_stats.ToUnique();
+	stats->Merge(right_stats);
+
+	return stats;
+}
+
+ScalarFunction ListConcatFun::GetFunction() {
+	// The arguments and return types are set in the binder function.
+	auto fun = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)},
+	                          LogicalType::LIST(LogicalType::ANY), ConcatFunction, BindConcatFunction, nullptr,
+	                          ListConcatStats);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return fun;
+}
+
+void ListConcatFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_concat", "list_cat", "array_concat", "array_cat"}, GetFunction());
 }
 
 void ConcatFun::RegisterFunction(BuiltinFunctions &set) {
@@ -249,34 +382,17 @@ void ConcatFun::RegisterFunction(BuiltinFunctions &set) {
 	// i.e. NULL || 'hello' = NULL
 	// the concat function, however, treats NULL values as an empty string
 	// i.e. concat(NULL, 'hello') = 'hello'
-	// concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL
-	// if the separator is not NULL, however, NULL values are counted as empty string
-	// there is one separate rule: there are no separators added between NULL values
-	// so the NULL value and empty string are different!
-	// e.g.:
-	// concat_ws(',', NULL, NULL) = ""
-	// concat_ws(',', '', '') = ","
+
 	ScalarFunction concat =
-	    ScalarFunction("concat", {LogicalType::ANY}, LogicalType::VARCHAR, ConcatFunction, BindConcatFunction);
+	    ScalarFunction("concat", {LogicalType::ANY}, LogicalType::ANY, ConcatFunction, BindConcatFunction);
 	concat.varargs = LogicalType::ANY;
 	concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	set.AddFunction(concat);
 
-	ScalarFunctionSet concat_op("||");
-	concat_op.AddFunction(
-	    ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::VARCHAR, ConcatOperator, BindConcatFunction));
-	concat_op.AddFunction(ScalarFunction({LogicalType::BLOB, LogicalType::BLOB}, LogicalType::BLOB, ConcatOperator));
-	concat_op.AddFunction(ListConcatFun::GetFunction());
-	for (auto &fun : concat_op.functions) {
-		fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	}
+	ScalarFunction concat_op = ScalarFunction("||", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY,
+	                                          ConcatFunction, BindConcatOperator);
+	concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	set.AddFunction(concat_op);
-
-	ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::ANY},
-	                                          LogicalType::VARCHAR, ConcatWSFunction, BindConcatFunction);
-	concat_ws.varargs = LogicalType::ANY;
-	concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(concat_ws);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/string/concat_ws.cpp

@@ -0,0 +1,149 @@
+#include "duckdb/function/scalar/string_functions.hpp"
+
+#include <string.h>
+
+namespace duckdb {
+
+static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel,
+                              const SelectionVector &rsel, idx_t count, Vector &result) {
+	vector<idx_t> result_lengths(args.size(), 0);
+	vector<bool> has_results(args.size(), false);
+
+	// we overallocate here, but this is important for static analysis
+	auto orrified_data = make_unsafe_uniq_array_uninitialized<UnifiedVectorFormat>(args.ColumnCount());
+
+	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
+		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
+	}
+
+	// first figure out the lengths
+	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
+		auto &idata = orrified_data[col_idx - 1];
+
+		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
+		for (idx_t i = 0; i < count; i++) {
+			auto ridx = rsel.get_index(i);
+			auto sep_idx = sep_sel.get_index(ridx);
+			auto idx = idata.sel->get_index(ridx);
+			if (!idata.validity.RowIsValid(idx)) {
+				continue;
+			}
+			if (has_results[ridx]) {
+				result_lengths[ridx] += sep_data[sep_idx].GetSize();
+			}
+			result_lengths[ridx] += input_data[idx].GetSize();
+			has_results[ridx] = true;
+		}
+	}
+
+	// first we allocate the empty strings for each of the values
+	auto result_data = FlatVector::GetData<string_t>(result);
+	for (idx_t i = 0; i < count; i++) {
+		auto ridx = rsel.get_index(i);
+		// allocate an empty string of the required size
+		result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]);
+		// we reuse the result_lengths vector to store the currently appended size
+		result_lengths[ridx] = 0;
+		has_results[ridx] = false;
+	}
+
+	// now that the empty space for the strings has been allocated, perform the concatenation
+	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
+		auto &idata = orrified_data[col_idx - 1];
+		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
+		for (idx_t i = 0; i < count; i++) {
+			auto ridx = rsel.get_index(i);
+			auto sep_idx = sep_sel.get_index(ridx);
+			auto idx = idata.sel->get_index(ridx);
+			if (!idata.validity.RowIsValid(idx)) {
+				continue;
+			}
+			if (has_results[ridx]) {
+				auto sep_size = sep_data[sep_idx].GetSize();
+				auto sep_ptr = sep_data[sep_idx].GetData();
+				memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size);
+				result_lengths[ridx] += sep_size;
+			}
+			auto input_ptr = input_data[idx].GetData();
+			auto input_len = input_data[idx].GetSize();
+			memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len);
+			result_lengths[ridx] += input_len;
+			has_results[ridx] = true;
+		}
+	}
+	for (idx_t i = 0; i < count; i++) {
+		auto ridx = rsel.get_index(i);
+		result_data[ridx].Finalize();
+	}
+}
+
+static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &separator = args.data[0];
+	UnifiedVectorFormat vdata;
+	separator.ToUnifiedFormat(args.size(), vdata);
+
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
+		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+			break;
+		}
+	}
+	switch (separator.GetVectorType()) {
+	case VectorType::CONSTANT_VECTOR: {
+		if (ConstantVector::IsNull(separator)) {
+			// constant NULL as separator: return constant NULL vector
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
+		// no null values
+		auto sel = FlatVector::IncrementalSelectionVector();
+		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, *sel, args.size(), result);
+		return;
+	}
+	default: {
+		// default case: loop over nullmask and create a non-null selection vector
+		idx_t not_null_count = 0;
+		SelectionVector not_null_vector(STANDARD_VECTOR_SIZE);
+		auto &result_mask = FlatVector::Validity(result);
+		for (idx_t i = 0; i < args.size(); i++) {
+			if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
+				result_mask.SetInvalid(i);
+			} else {
+				not_null_vector.set_index(not_null_count++, i);
+			}
+		}
+		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, not_null_vector,
+		                  not_null_count, result);
+		return;
+	}
+	}
+}
+
+static unique_ptr<FunctionData> BindConcatWSFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                     vector<unique_ptr<Expression>> &arguments) {
+	for (auto &arg : bound_function.arguments) {
+		arg = LogicalType::VARCHAR;
+	}
+	bound_function.varargs = LogicalType::VARCHAR;
+	return nullptr;
+}
+
+void ConcatWSFun::RegisterFunction(BuiltinFunctions &set) {
+	// concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL
+	// if the separator is not NULL, however, NULL values are counted as empty string
+	// there is one separate rule: there are no separators added between NULL values,
+	// so the NULL value and empty string are different!
+	// e.g.:
+	// concat_ws(',', NULL, NULL) = ""
+	// concat_ws(',', '', '') = ","
+
+	ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::ANY},
+	                                          LogicalType::VARCHAR, ConcatWSFunction, BindConcatWSFunction);
+	concat_ws.varargs = LogicalType::ANY;
+	concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	set.AddFunction(concat_ws);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/string/contains.cpp

@@ -3,7 +3,8 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 namespace duckdb {
 
 template <class UNSIGNED, int NEEDLE_SIZE>
@@ -151,15 +152,25 @@ struct ContainsOperator {
 	}
 };
 
-ScalarFunction ContainsFun::GetFunction() {
-	return ScalarFunction("contains",                                   // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, ContainsOperator>);
+ScalarFunctionSet ContainsFun::GetFunctions() {
+	auto string_fun = GetStringContains();
+	auto list_fun = ListContainsFun::GetFunction();
+	auto map_fun = MapContainsFun::GetFunction();
+	ScalarFunctionSet set("contains");
+	set.AddFunction(string_fun);
+	set.AddFunction(list_fun);
+	set.AddFunction(map_fun);
+	return set;
+}
+
+ScalarFunction ContainsFun::GetStringContains() {
+	ScalarFunction string_fun("contains", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                          ScalarFunction::BinaryFunction<string_t, string_t, bool, ContainsOperator>);
+	return string_fun;
 }
 
 void ContainsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
+	set.AddFunction(GetFunctions());
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -403,11 +403,11 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0')
 
 	// lowercase both the str and the pattern
 	idx_t str_llength = LowerFun::LowerLength(str_data, str_size);
-	auto str_ldata = make_unsafe_uniq_array<char>(str_llength);
+	auto str_ldata = make_unsafe_uniq_array_uninitialized<char>(str_llength);
 	LowerFun::LowerCase(str_data, str_size, str_ldata.get());
 
 	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
-	auto pat_ldata = make_unsafe_uniq_array<char>(pat_llength);
+	auto pat_ldata = make_unsafe_uniq_array_uninitialized<char>(pat_llength);
 	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
 	string_t str_lcase(str_ldata.get(), UnsafeNumericCast<uint32_t>(str_llength));
 	string_t pat_lcase(pat_ldata.get(), UnsafeNumericCast<uint32_t>(pat_llength));

package/src/duckdb/src/function/scalar/string/substring.cpp

@@ -224,11 +224,7 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 	if (offset < 0) {
 		// negative offset, this case is more difficult
 		// we first need to count the number of characters in the string
-		idx_t num_characters = 0;
-		utf8proc_grapheme_callback(input_data, input_size, [&](size_t start, size_t end) {
-			num_characters++;
-			return true;
-		});
+		idx_t num_characters = Utf8Proc::GraphemeCount(input_data, input_size);
 		// now call substring start and end again, but with the number of unicode characters this time
 		SubstringStartEnd(UnsafeNumericCast<int64_t>(num_characters), offset, length, start, end);
 	}
@@ -236,16 +232,15 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 	// now scan the graphemes of the string to find the positions of the start and end characters
 	int64_t current_character = 0;
 	idx_t start_pos = DConstants::INVALID_INDEX, end_pos = input_size;
-	utf8proc_grapheme_callback(input_data, input_size, [&](size_t gstart, size_t gend) {
+	for (auto cluster : Utf8Proc::GraphemeClusters(input_data, input_size)) {
 		if (current_character == start) {
-			start_pos = gstart;
+			start_pos = cluster.start;
 		} else if (current_character == end) {
-			end_pos = gstart;
-			return false;
+			end_pos = cluster.start;
+			break;
 		}
 		current_character++;
-		return true;
-	});
+	}
 	if (start_pos == DConstants::INVALID_INDEX) {
 		return SubstringEmptyString(result);
 	}

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

@@ -7,6 +7,7 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<UpperFun>();
 	Register<StripAccentsFun>();
 	Register<ConcatFun>();
+	Register<ConcatWSFun>();
 	Register<ContainsFun>();
 	Register<LengthFun>();
 	Register<LikeFun>();