duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/function/scalar/operator/arithmetic.cpp

@@ -1,9 +1,5 @@
-#include "duckdb/main/settings.hpp"
-
 #include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/bignum.hpp"
 #include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/interpolate.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/operator/numeric_binary_operators.hpp"
 #include "duckdb/common/operator/subtract.hpp"
@@ -82,8 +78,6 @@ static scalar_function_t GetScalarBinaryFunction(PhysicalType type) {
 //===--------------------------------------------------------------------===//
 // + [add]
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct AddPropagateStatistics {
 	template <class T, class OP>
 	static bool Operation(const LogicalType &type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
@@ -139,7 +133,7 @@ struct DecimalArithmeticBindData : public FunctionData {
 };
 
 template <class OP, class PROPAGATE, class BASEOP>
-unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
@@ -266,8 +260,8 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 	return std::move(bind_data);
 }
 
-void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                const ScalarFunction &function) {
+static void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                       const ScalarFunction &function) {
 	auto &bind_data = bind_data_p->Cast<DecimalArithmeticBindData>();
 	serializer.WriteProperty(100, "check_overflow", bind_data.check_overflow);
 	serializer.WriteProperty(101, "return_type", function.return_type);
@@ -303,8 +297,6 @@ unique_ptr<FunctionData> NopDecimalBind(ClientContext &context, ScalarFunction &
 	return nullptr;
 }
 
-} // namespace
-
 ScalarFunction AddFunction::GetFunction(const LogicalType &type) {
 	D_ASSERT(type.IsNumeric());
 	if (type.id() == LogicalTypeId::DECIMAL) {
@@ -314,40 +306,6 @@ ScalarFunction AddFunction::GetFunction(const LogicalType &type) {
 	}
 }
 
-void BignumAdd(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &allocator = state.GetAllocator();
-	ArenaAllocator arena(allocator);
-	BinaryExecutor::Execute<bignum_t, bignum_t, string_t>(args.data[0], args.data[1], result, args.size(),
-	                                                      [&](bignum_t a, bignum_t b) {
-		                                                      const BignumIntermediate lhs(a);
-		                                                      const BignumIntermediate rhs(b);
-		                                                      return BignumIntermediate::Add(result, lhs, rhs);
-	                                                      });
-}
-
-void BignumSubtract(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &allocator = state.GetAllocator();
-	ArenaAllocator arena(allocator);
-	BinaryExecutor::Execute<bignum_t, bignum_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](bignum_t a, bignum_t b) {
-		    const BignumIntermediate lhs(a);
-		    BignumIntermediate rhs(b);
-		    rhs.NegateInPlace();
-		    auto result_value = BignumIntermediate::Add(result, lhs, rhs);
-		    rhs.NegateInPlace();
-		    return result_value;
-	    });
-}
-
-void BignumNegate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &allocator = state.GetAllocator();
-	ArenaAllocator arena(allocator);
-	UnaryExecutor::Execute<bignum_t, string_t>(args.data[0], result, args.size(), [&](bignum_t a) {
-		const BignumIntermediate lhs(a);
-		return lhs.Negate(result);
-	});
-}
-
 ScalarFunction AddFunction::GetFunction(const LogicalType &left_type, const LogicalType &right_type) {
 	if (left_type.IsNumeric() && left_type.id() == right_type.id()) {
 		if (left_type.id() == LogicalTypeId::DECIMAL) {
@@ -373,14 +331,6 @@ ScalarFunction AddFunction::GetFunction(const LogicalType &left_type, const Logi
 	}
 
 	switch (left_type.id()) {
-	case LogicalTypeId::BIGNUM:
-		if (right_type.id() == LogicalTypeId::BIGNUM) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::BIGNUM, BignumAdd);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-
 	case LogicalTypeId::DATE:
 		if (right_type.id() == LogicalTypeId::INTEGER) {
 			ScalarFunction function("+", {left_type, right_type}, LogicalType::DATE,
@@ -522,17 +472,12 @@ ScalarFunctionSet OperatorAddFun::GetFunctions() {
 	// we can add lists together
 	add.AddFunction(ListConcatFun::GetFunction());
 
-	// we can add bignums together
-	add.AddFunction(AddFunction::GetFunction(LogicalType::BIGNUM, LogicalType::BIGNUM));
-
 	return add;
 }
 
 //===--------------------------------------------------------------------===//
 // - [subtract]
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct NegateOperator {
 	template <class T>
 	static bool CanNegate(T input) {
@@ -626,7 +571,7 @@ struct NegatePropagateStatistics {
 	}
 };
 
-unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
@@ -667,8 +612,6 @@ unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, Function
 	return stats.ToUnique();
 }
 
-} // namespace
-
 ScalarFunction SubtractFunction::GetFunction(const LogicalType &type) {
 	if (type.id() == LogicalTypeId::INTERVAL) {
 		ScalarFunction func("-", {type}, type, ScalarFunction::UnaryFunction<interval_t, interval_t, NegateOperator>);
@@ -677,9 +620,6 @@ ScalarFunction SubtractFunction::GetFunction(const LogicalType &type) {
 	} else if (type.id() == LogicalTypeId::DECIMAL) {
 		ScalarFunction func("-", {type}, type, nullptr, DecimalNegateBind, nullptr, NegateBindStatistics);
 		return func;
-	} else if (type.id() == LogicalTypeId::BIGNUM) {
-		ScalarFunction func("+", {type}, LogicalType::BIGNUM, BignumNegate);
-		return func;
 	} else {
 		D_ASSERT(type.IsNumeric());
 		ScalarFunction func("-", {type}, type, ScalarFunction::GetScalarUnaryFunction<NegateOperator>(type), nullptr,
@@ -715,10 +655,6 @@ ScalarFunction SubtractFunction::GetFunction(const LogicalType &left_type, const
 	}
 
 	switch (left_type.id()) {
-	case LogicalTypeId::BIGNUM: {
-		ScalarFunction function("-", {left_type, right_type}, left_type, BignumSubtract);
-		return function;
-	}
 	case LogicalTypeId::DATE:
 		if (right_type.id() == LogicalTypeId::DATE) {
 			ScalarFunction function("-", {left_type, right_type}, LogicalType::BIGINT,
@@ -796,8 +732,6 @@ ScalarFunctionSet OperatorSubtractFun::GetFunctions() {
 		// binary subtract function "a - b", subtracts b from a
 		subtract.AddFunction(SubtractFunction::GetFunction(type, type));
 	}
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::BIGNUM));
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::BIGNUM, LogicalType::BIGNUM));
 	// we can subtract dates from each other
 	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::DATE, LogicalType::DATE));
 	// we can subtract integers from dates
@@ -820,8 +754,6 @@ ScalarFunctionSet OperatorSubtractFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // * [multiply]
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct MultiplyPropagateStatistics {
 	template <class T, class OP>
 	static bool Operation(const LogicalType &type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
@@ -929,8 +861,6 @@ unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunct
 	return std::move(bind_data);
 }
 
-} // namespace
-
 ScalarFunctionSet OperatorMultiplyFun::GetFunctions() {
 	ScalarFunctionSet multiply("*");
 	for (auto &type : LogicalType::Numeric()) {
@@ -1001,8 +931,6 @@ interval_t DivideOperator::Operation(interval_t left, double right) {
 	return result;
 }
 
-namespace {
-
 struct BinaryNumericDivideWrapper {
 	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
 	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
@@ -1056,12 +984,12 @@ struct BinaryNumericDivideHugeintWrapper {
 };
 
 template <class TA, class TB, class TC, class OP, class ZWRAPPER = BinaryZeroIsNullWrapper>
-void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &state, Vector &result) {
+static void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<TA, TB, TC, OP, ZWRAPPER>(input.data[0], input.data[1], result, input.size());
 }
 
 template <class OP>
-scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
+static scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT8:
 		return BinaryScalarFunctionIgnoreZero<int8_t, int8_t, int8_t, OP, BinaryNumericDivideWrapper>;
@@ -1095,7 +1023,8 @@ scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
 template <class OP>
 unique_ptr<FunctionData> BindBinaryFloatingPoint(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
-	if (DBConfig::GetSetting<IeeeFloatingPointOpsSetting>(context)) {
+	auto &config = ClientConfig::GetConfig(context);
+	if (config.ieee_floating_point_ops) {
 		bound_function.function = GetScalarBinaryFunction<OP>(bound_function.return_type.InternalType());
 	} else {
 		bound_function.function = GetBinaryFunctionIgnoreZero<OP>(bound_function.return_type.InternalType());
@@ -1103,7 +1032,6 @@ unique_ptr<FunctionData> BindBinaryFloatingPoint(ClientContext &context, ScalarF
 	return nullptr;
 }
 
-} // namespace
 ScalarFunctionSet OperatorFloatDivideFun::GetFunctions() {
 	ScalarFunctionSet fp_divide("/");
 	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT, nullptr,
@@ -1139,8 +1067,8 @@ ScalarFunctionSet OperatorIntegerDivideFun::GetFunctions() {
 // % [modulo]
 //===--------------------------------------------------------------------===//
 template <class OP>
-static unique_ptr<FunctionData> BindDecimalModulo(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindDecimalModulo(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
 	auto bind_data = BindDecimalArithmetic<true>(context, bound_function, arguments);
 	// now select the physical function to execute
 	if (bind_data->check_overflow) {
@@ -1194,52 +1122,4 @@ ScalarFunctionSet OperatorModuloFun::GetFunctions() {
 	return modulo;
 }
 
-//===--------------------------------------------------------------------===//
-// Linear Interpolation
-//===--------------------------------------------------------------------===//
-
-template <>
-double InterpolateOperator::Operation(const double &lo, const double d, const double &hi) {
-	return lo * (1.0 - d) + hi * d;
-}
-
-template <>
-dtime_t InterpolateOperator::Operation(const dtime_t &lo, const double d, const dtime_t &hi) {
-	return dtime_t(std::llround(static_cast<double>(lo.micros) * (1.0 - d) + static_cast<double>(hi.micros) * d));
-}
-
-template <>
-timestamp_t InterpolateOperator::Operation(const timestamp_t &lo, const double d, const timestamp_t &hi) {
-	return timestamp_t(std::llround(static_cast<double>(lo.value) * (1.0 - d) + static_cast<double>(hi.value) * d));
-}
-
-template <>
-hugeint_t InterpolateOperator::Operation(const hugeint_t &lo, const double d, const hugeint_t &hi) {
-	return Hugeint::Convert(Operation(Hugeint::Cast<double>(lo), d, Hugeint::Cast<double>(hi)));
-}
-
-template <>
-uhugeint_t InterpolateOperator::Operation(const uhugeint_t &lo, const double d, const uhugeint_t &hi) {
-	return Hugeint::Convert(Operation(Uhugeint::Cast<double>(lo), d, Uhugeint::Cast<double>(hi)));
-}
-
-static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT
-	D_ASSERT(d >= 0 && d <= 1);
-	return Interval::FromMicro(std::llround(static_cast<double>(Interval::GetMicro(i)) * d));
-}
-
-inline interval_t operator+(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) + Interval::GetMicro(rhs));
-}
-
-inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
-}
-
-template <>
-interval_t InterpolateOperator::Operation(const interval_t &lo, const double d, const interval_t &hi) {
-	const interval_t delta = hi - lo;
-	return lo + MultiplyByDouble(delta, d);
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operator/multiply.cpp

@@ -41,7 +41,7 @@ interval_t MultiplyOperator::Operation(int64_t left, interval_t right) {
 
 // TSROUND.
 // Avoid std::rint because it can raise exceptions and we know that can't happen.
-static inline double PGTimestampRound(const double &j) {
+inline double PGTimestampRound(const double &j) {
 	return (std::nearbyint(((double)(j)) * Interval::MICROS_PER_SEC) / Interval::MICROS_PER_SEC);
 }
 
@@ -125,7 +125,6 @@ interval_t MultiplyOperator::Operation(double left, interval_t right) {
 //===--------------------------------------------------------------------===//
 // * [multiply] with overflow check
 //===--------------------------------------------------------------------===//
-namespace {
 struct OverflowCheckedMultiply {
 	template <class SRCTYPE, class UTYPE>
 	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
@@ -137,7 +136,6 @@ struct OverflowCheckedMultiply {
 		return true;
 	}
 };
-} // namespace
 
 template <>
 bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
@@ -278,7 +276,7 @@ bool TryMultiplyOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_
 // multiply  decimal with overflow check
 //===--------------------------------------------------------------------===//
 template <class T, T min, T max>
-static bool TryDecimalMultiplyTemplated(T left, T right, T &result) {
+bool TryDecimalMultiplyTemplated(T left, T right, T &result) {
 	if (!TryMultiplyOperator::Operation(left, right, result) || result < min || result > max) {
 		return false;
 	}

package/src/duckdb/src/function/scalar/operator/subtract.cpp

@@ -80,7 +80,6 @@ interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right) {
 //===--------------------------------------------------------------------===//
 // - [subtract] with overflow check
 //===--------------------------------------------------------------------===//
-namespace {
 struct OverflowCheckedSubtract {
 	template <class SRCTYPE, class UTYPE>
 	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
@@ -92,7 +91,6 @@ struct OverflowCheckedSubtract {
 		return true;
 	}
 };
-} // namespace
 
 template <>
 bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
@@ -178,7 +176,7 @@ bool TrySubtractOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_
 // subtract decimal with overflow check
 //===--------------------------------------------------------------------===//
 template <class T, T min, T max>
-static bool TryDecimalSubtractTemplated(T left, T right, T &result) {
+bool TryDecimalSubtractTemplated(T left, T right, T &result) {
 	if (right < 0) {
 		if (max + right < left) {
 			return false;

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -17,8 +17,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct CurrentSequenceValueOperator {
 	static int64_t Operation(DuckTransaction &, SequenceCatalogEntry &seq) {
 		return seq.CurrentValue();
@@ -71,7 +69,7 @@ unique_ptr<FunctionLocalState> NextValLocalFunction(ExpressionState &state, cons
 }
 
 template <class OP>
-void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	if (!func_expr.bind_info) {
 		// no bind info - return null
@@ -90,8 +88,8 @@ void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	}
 }
 
-unique_ptr<FunctionData> NextValBind(ScalarFunctionBindInput &bind_input, ScalarFunction &,
-                                     vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> NextValBind(ScalarFunctionBindInput &bind_input, ScalarFunction &,
+                                            vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
 	}
@@ -135,8 +133,6 @@ void NextValModifiedDatabases(ClientContext &context, FunctionModifiedDatabasesI
 	input.properties.RegisterDBModify(seq.sequence.ParentCatalog(), context);
 }
 
-} // namespace
-
 ScalarFunction NextvalFun::GetFunction() {
 	ScalarFunction next_val("nextval", {LogicalType::VARCHAR}, LogicalType::BIGINT,
 	                        NextValFunction<NextSequenceValueOperator>, nullptr, nullptr);

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

@@ -13,7 +13,7 @@
 
 namespace duckdb {
 
-static idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
+idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	switch (specifier) {
 	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
 	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME:
@@ -48,7 +48,7 @@ static idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	}
 }
 
-static void StrfTimeSplitOffset(int offset, int &hh, int &mm, int &ss) {
+void StrfTimeSplitOffset(int offset, int &hh, int &mm, int &ss) {
 	hh = offset / Interval::SECS_PER_HOUR;
 	offset = offset % Interval::SECS_PER_HOUR;
 

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

@@ -93,7 +93,6 @@ static string_t UnicodeCaseConvert(Vector &result, const char *input_data, idx_t
 	return result_str;
 }
 
-namespace {
 template <bool IS_UPPER>
 struct CaseConvertOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -103,14 +102,12 @@ struct CaseConvertOperator {
 		return UnicodeCaseConvert<IS_UPPER>(result, input_data, input_length);
 	}
 };
-} // namespace
 
 template <bool IS_UPPER>
 static void CaseConvertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	UnaryExecutor::ExecuteString<string_t, string_t, CaseConvertOperator<IS_UPPER>>(args.data[0], result, args.size());
 }
 
-namespace {
 template <bool IS_UPPER>
 struct CaseConvertOperatorASCII {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -120,7 +117,6 @@ struct CaseConvertOperatorASCII {
 		return ASCIICaseConvert<IS_UPPER>(result, input_data, input_length);
 	}
 };
-} // namespace
 
 template <bool IS_UPPER>
 static void CaseConvertFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -12,12 +12,11 @@
 
 namespace duckdb {
 
-namespace {
-
 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;
 
@@ -28,6 +27,9 @@ public:
 	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;
@@ -37,7 +39,7 @@ unique_ptr<FunctionData> ConcatFunctionData::Copy() const {
 	return make_uniq<ConcatFunctionData>(return_type, is_operator);
 }
 
-void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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;
@@ -123,7 +125,7 @@ void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	}
 }
 
-void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) {
 		    auto a_data = a.GetData();
@@ -153,7 +155,7 @@ struct ListConcatInputData {
 	const list_entry_t *input_entries = nullptr;
 };
 
-void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result, bool is_operator) {
+static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result, bool is_operator) {
 	auto count = args.size();
 
 	auto result_entries = FlatVector::GetData<list_entry_t>(result);
@@ -205,7 +207,7 @@ void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result,
 	}
 }
 
-void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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) {
@@ -216,7 +218,7 @@ void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	return StringConcatFunction(args, state, result);
 }
 
-void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) {
+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;
@@ -231,8 +233,8 @@ void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bo
 	bound_function.return_type = type;
 }
 
-unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments, bool is_operator) {
+static unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments, bool is_operator) {
 	LogicalType child_type = LogicalType::SQLNULL;
 	bool all_null = true;
 	for (auto &arg : arguments) {
@@ -285,8 +287,9 @@ unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &
 	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
-unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, ScalarFunction &bound_function,
-                                                    vector<unique_ptr<Expression>> &arguments, bool is_operator) {
+static unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, ScalarFunction &bound_function,
+                                                           vector<unique_ptr<Expression>> &arguments,
+                                                           bool is_operator) {
 	bool list_concat = false;
 	// blob concat is only supported for the concat operator - regular concat converts to varchar
 	bool all_blob = is_operator ? true : false;
@@ -311,17 +314,17 @@ unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, Scal
 	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
-unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
 	return BindConcatFunctionInternal(context, bound_function, arguments, false);
 }
 
-unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
 	return BindConcatFunctionInternal(context, bound_function, arguments, true);
 }
 
-unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto stats = child_stats[0].ToUnique();
 	for (idx_t i = 1; i < child_stats.size(); i++) {
@@ -330,8 +333,6 @@ unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStati
 	return stats;
 }
 
-} // namespace
-
 ScalarFunction ListConcatFun::GetFunction() {
 	// The arguments and return types are set in the binder function.
 	auto fun = ScalarFunction({}, LogicalType::LIST(LogicalType::ANY), ConcatFunction, BindConcatFunction, nullptr,

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

@@ -4,13 +4,10 @@
 #include "duckdb/function/scalar/map_functions.hpp"
 #include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/struct_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
 
-namespace {
-
 struct ContainsAligned {
 	template <class UNSIGNED>
 	static bool MatchRemainder(const unsigned char *haystack, const unsigned char *needle, idx_t needle_size) {
@@ -64,15 +61,6 @@ static idx_t Contains(const unsigned char *haystack, idx_t haystack_size, const
 	return DConstants::INVALID_INDEX;
 }
 
-struct ContainsOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return FindStrInStr(left, right) != DConstants::INVALID_INDEX;
-	}
-};
-
-} // namespace
-
 idx_t FindStrInStr(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle, idx_t needle_size) {
 	D_ASSERT(needle_size > 0);
 	// start off by performing a memchr to find the first character of the
@@ -118,6 +106,13 @@ idx_t FindStrInStr(const string_t &haystack_s, const string_t &needle_s) {
 	return FindStrInStr(haystack, haystack_size, needle, needle_size);
 }
 
+struct ContainsOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return FindStrInStr(left, right) != DConstants::INVALID_INDEX;
+	}
+};
+
 ScalarFunction GetStringContains() {
 	ScalarFunction string_fun("contains", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	                          ScalarFunction::BinaryFunction<string_t, string_t, bool, ContainsOperator>);
@@ -129,12 +124,10 @@ ScalarFunctionSet ContainsFun::GetFunctions() {
 	auto string_fun = GetStringContains();
 	auto list_fun = ListContainsFun::GetFunction();
 	auto map_fun = MapContainsFun::GetFunction();
-	auto struct_fun = StructContainsFun::GetFunction();
 	ScalarFunctionSet set("contains");
 	set.AddFunction(string_fun);
 	set.AddFunction(list_fun);
 	set.AddFunction(map_fun);
-	set.AddFunction(struct_fun);
 	return set;
 }