duckdb 1.3.2 → 1.3.3-dev4.0

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

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 // length returns the number of unicode codepoints
 struct StringLengthOperator {
 	template <class TA, class TR>
@@ -55,7 +57,7 @@ struct BitStringLenOperator {
 	}
 };
 
-static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
@@ -69,7 +71,7 @@ static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, F
 //------------------------------------------------------------------
 // ARRAY / LIST LENGTH
 //------------------------------------------------------------------
-static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 	D_ASSERT(input.GetType().id() == LogicalTypeId::LIST);
 	UnaryExecutor::Execute<list_entry_t, int64_t>(
@@ -79,7 +81,7 @@ static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &
 	}
 }
 
-static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnifiedVectorFormat format;
@@ -108,8 +110,8 @@ static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector
 	}
 }
 
-static unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function,
-                                                      vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
 	}
@@ -130,7 +132,7 @@ static unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, Sc
 //------------------------------------------------------------------
 // ARRAY / LIST WITH DIMENSION
 //------------------------------------------------------------------
-static void ListLengthBinaryFunction(DataChunk &args, ExpressionState &, Vector &result) {
+void ListLengthBinaryFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	auto type = args.data[0].GetType();
 	auto &input = args.data[0];
 	auto &dimension = args.data[1];
@@ -161,7 +163,7 @@ struct ArrayLengthBinaryFunctionData : public FunctionData {
 	}
 };
 
-static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto type = args.data[0].GetType();
 	auto &dimension = args.data[1];
 
@@ -183,8 +185,8 @@ static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, V
 	}
 }
 
-static unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &context, ScalarFunction &bound_function,
-                                                            vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &context, ScalarFunction &bound_function,
+                                                     vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
 	}
@@ -217,6 +219,8 @@ static unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &conte
 	}
 }
 
+} // namespace
+
 ScalarFunctionSet LengthFun::GetFunctions() {
 	ScalarFunctionSet length("length");
 	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,

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

@@ -9,6 +9,144 @@
 
 namespace duckdb {
 
+bool Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
+	idx_t sidx = 0;
+	idx_t pidx = 0;
+main_loop : {
+	// main matching loop
+	while (sidx < slen && pidx < plen) {
+		char s = string[sidx];
+		char p = pattern[pidx];
+		switch (p) {
+		case '*': {
+			// asterisk: match any set of characters
+			// skip any subsequent asterisks
+			pidx++;
+			while (pidx < plen && pattern[pidx] == '*') {
+				pidx++;
+			}
+			// if the asterisk is the last character, the pattern always matches
+			if (pidx == plen) {
+				return true;
+			}
+			// recursively match the remainder of the pattern
+			for (; sidx < slen; sidx++) {
+				if (Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		case '?':
+			// when enabled: matches anything but null
+			if (allow_question_mark) {
+				break;
+			}
+			DUCKDB_EXPLICIT_FALLTHROUGH;
+		case '[':
+			pidx++;
+			goto parse_bracket;
+		case '\\':
+			// escape character, next character needs to match literally
+			pidx++;
+			// check that we still have a character remaining
+			if (pidx == plen) {
+				return false;
+			}
+			p = pattern[pidx];
+			if (s != p) {
+				return false;
+			}
+			break;
+		default:
+			// not a control character: characters need to match literally
+			if (s != p) {
+				return false;
+			}
+			break;
+		}
+		sidx++;
+		pidx++;
+	}
+	while (pidx < plen && pattern[pidx] == '*') {
+		pidx++;
+	}
+	// we are finished only if we have consumed the full pattern
+	return pidx == plen && sidx == slen;
+}
+parse_bracket : {
+	// inside a bracket
+	if (pidx == plen) {
+		return false;
+	}
+	// check the first character
+	// if it is an exclamation mark we need to invert our logic
+	char p = pattern[pidx];
+	char s = string[sidx];
+	bool invert = false;
+	if (p == '!') {
+		invert = true;
+		pidx++;
+	}
+	bool found_match = invert;
+	idx_t start_pos = pidx;
+	bool found_closing_bracket = false;
+	// now check the remainder of the pattern
+	while (pidx < plen) {
+		p = pattern[pidx];
+		// if the first character is a closing bracket, we match it literally
+		// otherwise it indicates an end of bracket
+		if (p == ']' && pidx > start_pos) {
+			// end of bracket found: we are done
+			found_closing_bracket = true;
+			pidx++;
+			break;
+		}
+		// we either match a range (a-b) or a single character (a)
+		// check if the next character is a dash
+		if (pidx + 1 == plen) {
+			// no next character!
+			break;
+		}
+		bool matches;
+		if (pattern[pidx + 1] == '-') {
+			// range! find the next character in the range
+			if (pidx + 2 == plen) {
+				break;
+			}
+			char next_char = pattern[pidx + 2];
+			// check if the current character is within the range
+			matches = s >= p && s <= next_char;
+			// shift the pattern forward past the range
+			pidx += 3;
+		} else {
+			// no range! perform a direct match
+			matches = p == s;
+			// shift the pattern forward past the character
+			pidx++;
+		}
+		if (found_match == invert && matches) {
+			// found a match! set the found_matches flag
+			// we keep on pattern matching after this until we reach the end bracket
+			// however, we don't need to update the found_match flag anymore
+			found_match = !invert;
+		}
+	}
+	if (!found_closing_bracket) {
+		// no end of bracket: invalid pattern
+		return false;
+	}
+	if (!found_match) {
+		// did not match the bracket: return false;
+		return false;
+	}
+	// finished the bracket matching: move forward
+	sidx++;
+	goto main_loop;
+}
+}
+
+namespace {
 struct StandardCharacterReader {
 	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
 		sidx++;
@@ -203,8 +341,8 @@ private:
 	bool has_end_percentage;
 };
 
-static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarFunction &bound_function,
+                                          vector<unique_ptr<Expression>> &arguments) {
 	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
 	for (auto &arg : arguments) {
@@ -235,144 +373,7 @@ bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
 	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize(), escape);
 }
 
-bool Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
-	idx_t sidx = 0;
-	idx_t pidx = 0;
-main_loop : {
-	// main matching loop
-	while (sidx < slen && pidx < plen) {
-		char s = string[sidx];
-		char p = pattern[pidx];
-		switch (p) {
-		case '*': {
-			// asterisk: match any set of characters
-			// skip any subsequent asterisks
-			pidx++;
-			while (pidx < plen && pattern[pidx] == '*') {
-				pidx++;
-			}
-			// if the asterisk is the last character, the pattern always matches
-			if (pidx == plen) {
-				return true;
-			}
-			// recursively match the remainder of the pattern
-			for (; sidx < slen; sidx++) {
-				if (Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
-					return true;
-				}
-			}
-			return false;
-		}
-		case '?':
-			// when enabled: matches anything but null
-			if (allow_question_mark) {
-				break;
-			}
-			DUCKDB_EXPLICIT_FALLTHROUGH;
-		case '[':
-			pidx++;
-			goto parse_bracket;
-		case '\\':
-			// escape character, next character needs to match literally
-			pidx++;
-			// check that we still have a character remaining
-			if (pidx == plen) {
-				return false;
-			}
-			p = pattern[pidx];
-			if (s != p) {
-				return false;
-			}
-			break;
-		default:
-			// not a control character: characters need to match literally
-			if (s != p) {
-				return false;
-			}
-			break;
-		}
-		sidx++;
-		pidx++;
-	}
-	while (pidx < plen && pattern[pidx] == '*') {
-		pidx++;
-	}
-	// we are finished only if we have consumed the full pattern
-	return pidx == plen && sidx == slen;
-}
-parse_bracket : {
-	// inside a bracket
-	if (pidx == plen) {
-		return false;
-	}
-	// check the first character
-	// if it is an exclamation mark we need to invert our logic
-	char p = pattern[pidx];
-	char s = string[sidx];
-	bool invert = false;
-	if (p == '!') {
-		invert = true;
-		pidx++;
-	}
-	bool found_match = invert;
-	idx_t start_pos = pidx;
-	bool found_closing_bracket = false;
-	// now check the remainder of the pattern
-	while (pidx < plen) {
-		p = pattern[pidx];
-		// if the first character is a closing bracket, we match it literally
-		// otherwise it indicates an end of bracket
-		if (p == ']' && pidx > start_pos) {
-			// end of bracket found: we are done
-			found_closing_bracket = true;
-			pidx++;
-			break;
-		}
-		// we either match a range (a-b) or a single character (a)
-		// check if the next character is a dash
-		if (pidx + 1 == plen) {
-			// no next character!
-			break;
-		}
-		bool matches;
-		if (pattern[pidx + 1] == '-') {
-			// range! find the next character in the range
-			if (pidx + 2 == plen) {
-				break;
-			}
-			char next_char = pattern[pidx + 2];
-			// check if the current character is within the range
-			matches = s >= p && s <= next_char;
-			// shift the pattern forward past the range
-			pidx += 3;
-		} else {
-			// no range! perform a direct match
-			matches = p == s;
-			// shift the pattern forward past the character
-			pidx++;
-		}
-		if (found_match == invert && matches) {
-			// found a match! set the found_matches flag
-			// we keep on pattern matching after this until we reach the end bracket
-			// however, we don't need to update the found_match flag anymore
-			found_match = !invert;
-		}
-	}
-	if (!found_closing_bracket) {
-		// no end of bracket: invalid pattern
-		return false;
-	}
-	if (!found_match) {
-		// did not match the bracket: return false;
-		return false;
-	}
-	// finished the bracket matching: move forward
-	sidx++;
-	goto main_loop;
-}
-}
-
-static char GetEscapeChar(string_t escape) {
+char GetEscapeChar(string_t escape) {
 	// Only one escape character should be allowed
 	if (escape.GetSize() > 1) {
 		throw SyntaxException("Invalid escape string. Escape string must be empty or one character.");
@@ -481,7 +482,7 @@ struct GlobOperator {
 
 // This can be moved to the scalar_function class
 template <typename FUNC>
-static void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &str = args.data[0];
 	auto &pattern = args.data[1];
 	auto &escape = args.data[2];
@@ -491,7 +492,7 @@ static void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 template <class ASCII_OP>
-static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() >= 1);
@@ -503,7 +504,7 @@ static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, Fu
 }
 
 template <class OP, bool INVERT>
-static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	if (func_expr.bind_info) {
 		auto &matcher = func_expr.bind_info->Cast<LikeMatcher>();
@@ -518,6 +519,8 @@ static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector
 	}
 }
 
+} // namespace
+
 ScalarFunction NotLikeFun::GetFunction() {
 	ScalarFunction not_like("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	                        RegularLikeFunction<NotLikeOperator, true>, LikeBindFunction);

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

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct MD5Operator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -30,18 +32,20 @@ struct MD5Number128Operator {
 	}
 };
 
-static void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
+void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnaryExecutor::ExecuteString<string_t, string_t, MD5Operator>(input, result, args.size());
 }
 
-static void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnaryExecutor::Execute<string_t, uhugeint_t, MD5Number128Operator>(input, result, args.size());
 }
 
+} // namespace
+
 ScalarFunctionSet MD5Fun::GetFunctions() {
 	ScalarFunctionSet set("md5");
 	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, MD5Function));

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

@@ -4,6 +4,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct NFCNormalizeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -20,13 +22,15 @@ struct NFCNormalizeOperator {
 	}
 };
 
-static void NFCNormalizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void NFCNormalizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 
 	UnaryExecutor::ExecuteString<string_t, string_t, NFCNormalizeOperator>(args.data[0], result, args.size());
 	StringVector::AddHeapReference(result, args.data[0]);
 }
 
+} // namespace
+
 ScalarFunction NFCNormalizeFun::GetFunction() {
 	return ScalarFunction("nfc_normalize", {LogicalType::VARCHAR}, LogicalType::VARCHAR, NFCNormalizeFunction);
 }

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

@@ -5,15 +5,9 @@
 
 namespace duckdb {
 
-static bool PrefixFunction(const string_t &str, const string_t &pattern);
+namespace {
 
-struct PrefixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return PrefixFunction(left, right);
-	}
-};
-static bool PrefixFunction(const string_t &str, const string_t &pattern) {
+bool PrefixFunction(const string_t &str, const string_t &pattern) {
 	auto str_length = str.GetSize();
 	auto patt_length = pattern.GetSize();
 	if (patt_length > str_length) {
@@ -58,6 +52,15 @@ static bool PrefixFunction(const string_t &str, const string_t &pattern) {
 	}
 }
 
+struct PrefixOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return PrefixFunction(left, right);
+	}
+};
+
+} // namespace
+
 ScalarFunction PrefixFun::GetFunction() {
 	return ScalarFunction("prefix",                                     // name of the function
 	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list

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

@@ -3,6 +3,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct EscapeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE &input, Vector &result) {
@@ -11,10 +13,12 @@ struct EscapeOperator {
 	}
 };
 
-static void RegexpEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void RegexpEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	UnaryExecutor::ExecuteString<string_t, string_t, EscapeOperator>(args.data[0], result, args.size());
 }
 
+} // namespace
+
 ScalarFunction RegexpEscapeFun::GetFunction() {
 	return ScalarFunction("regexp_escape", {LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexpEscapeFunction);
 }

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

@@ -5,6 +5,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct SHA1Operator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -19,12 +21,14 @@ struct SHA1Operator {
 	}
 };
 
-static void SHA1Function(DataChunk &args, ExpressionState &state, Vector &result) {
+void SHA1Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnaryExecutor::ExecuteString<string_t, string_t, SHA1Operator>(input, result, args.size());
 }
 
+} // namespace
+
 ScalarFunctionSet SHA1Fun::GetFunctions() {
 	ScalarFunctionSet set("sha1");
 	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA1Function));

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

@@ -5,6 +5,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct SHA256Operator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -19,12 +21,14 @@ struct SHA256Operator {
 	}
 };
 
-static void SHA256Function(DataChunk &args, ExpressionState &state, Vector &result) {
+void SHA256Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnaryExecutor::ExecuteString<string_t, string_t, SHA256Operator>(input, result, args.size());
 }
 
+} // namespace
+
 ScalarFunctionSet SHA256Fun::GetFunctions() {
 	ScalarFunctionSet set("sha256");
 	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA256Function));

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

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct StringSplitInput {
 	StringSplitInput(Vector &result_list, Vector &result_child, idx_t offset)
 	    : result_list(result_list), result_child(result_child), offset(offset) {
@@ -105,7 +107,7 @@ struct StringSplitter {
 };
 
 template <class OP>
-static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, void *data = nullptr) {
+void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, void *data = nullptr) {
 	UnifiedVectorFormat input_data;
 	args.data[0].ToUnifiedFormat(args.size(), input_data);
 	auto inputs = UnifiedVectorFormat::GetData<string_t>(input_data);
@@ -156,11 +158,11 @@ static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector
 	StringVector::AddHeapReference(child_entry, args.data[0]);
 }
 
-static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	StringSplitExecutor<RegularStringSplit>(args, state, result, nullptr);
 }
 
-static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
 	if (info.constant_pattern) {
@@ -173,6 +175,8 @@ static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Ve
 	}
 }
 
+} // namespace
+
 ScalarFunction StringSplitFun::GetFunction() {
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
 

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

@@ -27,6 +27,8 @@ bool IsAscii(const char *input, idx_t n) {
 	return true;
 }
 
+namespace {
+
 struct StripAccentsOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -43,13 +45,15 @@ struct StripAccentsOperator {
 	}
 };
 
-static void StripAccentsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void StripAccentsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 
 	UnaryExecutor::ExecuteString<string_t, string_t, StripAccentsOperator>(args.data[0], result, args.size());
 	StringVector::AddHeapReference(result, args.data[0]);
 }
 
+} // namespace
+
 ScalarFunction StripAccentsFun::GetFunction() {
 	return ScalarFunction("strip_accents", {LogicalType::VARCHAR}, LogicalType::VARCHAR, StripAccentsFunction);
 }