duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -1,5 +1,9 @@
+#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"
@@ -78,6 +82,8 @@ 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,
@@ -133,7 +139,7 @@ struct DecimalArithmeticBindData : public FunctionData {
 };
 
 template <class OP, class PROPAGATE, class BASEOP>
-static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
@@ -260,8 +266,8 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 	return std::move(bind_data);
 }
 
-static void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                       const ScalarFunction &function) {
+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);
@@ -297,6 +303,8 @@ 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) {
@@ -306,6 +314,40 @@ 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) {
@@ -331,6 +373,14 @@ 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,
@@ -472,12 +522,17 @@ 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) {
@@ -571,7 +626,7 @@ struct NegatePropagateStatistics {
 	}
 };
 
-static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
@@ -612,6 +667,8 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, F
 	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>);
@@ -620,6 +677,9 @@ 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,
@@ -655,6 +715,10 @@ 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,
@@ -732,6 +796,8 @@ 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
@@ -754,6 +820,8 @@ 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,
@@ -861,6 +929,8 @@ unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunct
 	return std::move(bind_data);
 }
 
+} // namespace
+
 ScalarFunctionSet OperatorMultiplyFun::GetFunctions() {
 	ScalarFunctionSet multiply("*");
 	for (auto &type : LogicalType::Numeric()) {
@@ -931,6 +1001,8 @@ 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) {
@@ -984,12 +1056,12 @@ struct BinaryNumericDivideHugeintWrapper {
 };
 
 template <class TA, class TB, class TC, class OP, class ZWRAPPER = BinaryZeroIsNullWrapper>
-static void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &state, Vector &result) {
+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>
-static scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
+scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT8:
 		return BinaryScalarFunctionIgnoreZero<int8_t, int8_t, int8_t, OP, BinaryNumericDivideWrapper>;
@@ -1023,8 +1095,7 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
 template <class OP>
 unique_ptr<FunctionData> BindBinaryFloatingPoint(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (config.ieee_floating_point_ops) {
+	if (DBConfig::GetSetting<IeeeFloatingPointOpsSetting>(context)) {
 		bound_function.function = GetScalarBinaryFunction<OP>(bound_function.return_type.InternalType());
 	} else {
 		bound_function.function = GetBinaryFunctionIgnoreZero<OP>(bound_function.return_type.InternalType());
@@ -1032,6 +1103,7 @@ 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,
@@ -1067,8 +1139,8 @@ ScalarFunctionSet OperatorIntegerDivideFun::GetFunctions() {
 // % [modulo]
 //===--------------------------------------------------------------------===//
 template <class OP>
-unique_ptr<FunctionData> BindDecimalModulo(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
+static 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) {
@@ -1122,4 +1194,52 @@ 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.
-inline double PGTimestampRound(const double &j) {
+static inline double PGTimestampRound(const double &j) {
 	return (std::nearbyint(((double)(j)) * Interval::MICROS_PER_SEC) / Interval::MICROS_PER_SEC);
 }
 
@@ -125,6 +125,7 @@ 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) {
@@ -136,6 +137,7 @@ struct OverflowCheckedMultiply {
 		return true;
 	}
 };
+} // namespace
 
 template <>
 bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
@@ -276,7 +278,7 @@ bool TryMultiplyOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_
 // multiply  decimal with overflow check
 //===--------------------------------------------------------------------===//
 template <class T, T min, T max>
-bool TryDecimalMultiplyTemplated(T left, T right, T &result) {
+static 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,6 +80,7 @@ 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) {
@@ -91,6 +92,7 @@ struct OverflowCheckedSubtract {
 		return true;
 	}
 };
+} // namespace
 
 template <>
 bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
@@ -176,7 +178,7 @@ bool TrySubtractOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_
 // subtract decimal with overflow check
 //===--------------------------------------------------------------------===//
 template <class T, T min, T max>
-bool TryDecimalSubtractTemplated(T left, T right, T &result) {
+static 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,6 +17,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct CurrentSequenceValueOperator {
 	static int64_t Operation(DuckTransaction &, SequenceCatalogEntry &seq) {
 		return seq.CurrentValue();
@@ -69,7 +71,7 @@ unique_ptr<FunctionLocalState> NextValLocalFunction(ExpressionState &state, cons
 }
 
 template <class OP>
-static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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
@@ -88,8 +90,8 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 	}
 }
 
-static unique_ptr<FunctionData> NextValBind(ScalarFunctionBindInput &bind_input, ScalarFunction &,
-                                            vector<unique_ptr<Expression>> &arguments) {
+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();
 	}
@@ -133,6 +135,8 @@ 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 {
 
-idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
+static idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	switch (specifier) {
 	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
 	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME:
@@ -48,7 +48,7 @@ idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	}
 }
 
-void StrfTimeSplitOffset(int offset, int &hh, int &mm, int &ss) {
+static 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,6 +93,7 @@ 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>
@@ -102,12 +103,14 @@ 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>
@@ -117,6 +120,7 @@ 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,11 +12,12 @@
 
 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;
 
@@ -27,9 +28,6 @@ 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;
@@ -39,7 +37,7 @@ unique_ptr<FunctionData> ConcatFunctionData::Copy() const {
 	return make_uniq<ConcatFunctionData>(return_type, is_operator);
 }
 
-static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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;
@@ -125,7 +123,7 @@ static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector
 	}
 }
 
-static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
+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();
@@ -155,7 +153,7 @@ struct ListConcatInputData {
 	const list_entry_t *input_entries = nullptr;
 };
 
-static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result, bool is_operator) {
+void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result, bool is_operator) {
 	auto count = args.size();
 
 	auto result_entries = FlatVector::GetData<list_entry_t>(result);
@@ -207,7 +205,7 @@ static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &
 	}
 }
 
-static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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) {
@@ -218,7 +216,7 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	return StringConcatFunction(args, state, result);
 }
 
-static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) {
+void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) {
 	if (is_operator) {
 		bound_function.arguments[0] = type;
 		bound_function.arguments[1] = type;
@@ -233,8 +231,8 @@ static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &t
 	bound_function.return_type = type;
 }
 
-static unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments, bool is_operator) {
+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) {
@@ -287,9 +285,8 @@ static unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFun
 	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
-static unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments,
-                                                           bool is_operator) {
+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;
@@ -314,17 +311,17 @@ static unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &contex
 	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
-static unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
 	return BindConcatFunctionInternal(context, bound_function, arguments, false);
 }
 
-static unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
 	return BindConcatFunctionInternal(context, bound_function, arguments, true);
 }
 
-static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+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++) {
@@ -333,6 +330,8 @@ static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, Functi
 	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,10 +4,13 @@
 #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) {
@@ -61,6 +64,15 @@ 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
@@ -106,13 +118,6 @@ 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>);
@@ -124,10 +129,12 @@ 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;
 }