duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/extension/core_functions/scalar/date/date_sub.cpp

@@ -12,8 +12,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct DateSub {
 	static int64_t SubtractMicros(timestamp_t startdate, timestamp_t enddate) {
 		const auto start = Timestamp::GetEpochMicroSeconds(startdate);
@@ -313,7 +311,7 @@ int64_t DateSub::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
 }
 
 template <typename TA, typename TB, typename TR>
-int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
+static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 	case DatePartSpecifier::ISOYEAR:
@@ -366,7 +364,7 @@ struct DateSubTernaryOperator {
 };
 
 template <typename TA, typename TB, typename TR>
-void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
+static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 	case DatePartSpecifier::ISOYEAR:
@@ -420,7 +418,7 @@ void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right,
 }
 
 template <typename T>
-void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 	auto &part_arg = args.data[0];
 	auto &start_arg = args.data[1];
@@ -442,8 +440,6 @@ void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	}
 }
 
-} // namespace
-
 ScalarFunctionSet DateSubFun::GetFunctions() {
 	ScalarFunctionSet date_sub("date_sub");
 	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},

package/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp

@@ -10,8 +10,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct DateTrunc {
 	template <class TA, class TR, class OP>
 	static inline TR UnaryFunction(TA input) {
@@ -460,7 +458,7 @@ interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
 }
 
 template <class TA, class TR>
-TR TruncateElement(DatePartSpecifier type, TA element) {
+static TR TruncateElement(DatePartSpecifier type, TA element) {
 	if (!Value::IsFinite(element)) {
 		return Cast::template Operation<TA, TR>(element);
 	}
@@ -513,7 +511,7 @@ struct DateTruncBinaryOperator {
 };
 
 template <typename TA, typename TR>
-void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
+static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::MILLENNIUM:
 		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillenniumOperator>(left, result, count);
@@ -569,7 +567,7 @@ void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result
 }
 
 template <typename TA, typename TR>
-void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 	auto &part_arg = args.data[0];
 	auto &date_arg = args.data[1];
@@ -590,7 +588,7 @@ void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result)
 }
 
 template <class TA, class TR, class OP>
-unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_stats) {
+static unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_stats) {
 	// we can only propagate date stats if the child has stats
 	auto &nstats = child_stats[1];
 	if (!NumericStats::HasMinMax(nstats)) {
@@ -617,12 +615,12 @@ unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_sta
 }
 
 template <class TA, class TR, class OP>
-unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 	return DateTruncStatistics<TA, TR, OP>(input.child_stats);
 }
 
 template <typename TA, typename TR>
-function_statistics_t DateTruncStats(DatePartSpecifier type) {
+static function_statistics_t DateTruncStats(DatePartSpecifier type) {
 	switch (type) {
 	case DatePartSpecifier::MILLENNIUM:
 		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillenniumOperator>;
@@ -663,8 +661,8 @@ function_statistics_t DateTruncStats(DatePartSpecifier type) {
 	}
 }
 
-unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
-                                       vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	if (!arguments[0]->IsFoldable()) {
 		return nullptr;
 	}
@@ -722,8 +720,6 @@ unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &b
 	return nullptr;
 }
 
-} // namespace
-
 ScalarFunctionSet DateTruncFun::GetFunctions() {
 	ScalarFunctionSet date_trunc("date_trunc");
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,

package/src/duckdb/extension/core_functions/scalar/date/epoch.cpp

@@ -6,8 +6,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct EpochSecOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE sec) {
@@ -19,12 +17,17 @@ struct EpochSecOperator {
 	}
 };
 
-void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
 	UnaryExecutor::Execute<double, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
 }
 
+ScalarFunction ToTimestampFun::GetFunction() {
+	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
+}
+
 struct NormalizedIntervalOperator {
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input) {
@@ -32,12 +35,16 @@ struct NormalizedIntervalOperator {
 	}
 };
 
-void NormalizedIntervalFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void NormalizedIntervalFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
 	UnaryExecutor::Execute<interval_t, interval_t, NormalizedIntervalOperator>(input.data[0], result, input.size());
 }
 
+ScalarFunction NormalizedIntervalFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTERVAL}, LogicalType::INTERVAL, NormalizedIntervalFunction);
+}
+
 struct TimeTZSortKeyOperator {
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input) {
@@ -45,23 +52,12 @@ struct TimeTZSortKeyOperator {
 	}
 };
 
-void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
 	UnaryExecutor::Execute<dtime_tz_t, uint64_t, TimeTZSortKeyOperator>(input.data[0], result, input.size());
 }
 
-} // namespace
-
-ScalarFunction ToTimestampFun::GetFunction() {
-	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
-}
-
-ScalarFunction NormalizedIntervalFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTERVAL}, LogicalType::INTERVAL, NormalizedIntervalFunction);
-}
-
 ScalarFunction TimeTZSortKeyFun::GetFunction() {
 	return ScalarFunction({LogicalType::TIME_TZ}, LogicalType::UBIGINT, TimeTZSortKeyFunction);
 }

package/src/duckdb/extension/core_functions/scalar/date/make_date.cpp

@@ -11,9 +11,7 @@
 
 namespace duckdb {
 
-namespace {
-
-void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
+static void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 	result.Reinterpret(input.data[0]);
 }
@@ -27,7 +25,7 @@ struct MakeDateOperator {
 };
 
 template <typename T>
-void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 3);
 	auto &yyyy = input.data[0];
 	auto &mm = input.data[1];
@@ -38,7 +36,7 @@ void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
 }
 
 template <typename T>
-date_t FromDateCast(T year, T month, T day) {
+static date_t FromDateCast(T year, T month, T day) {
 	date_t result;
 	if (!Date::TryFromDate(Cast::Operation<T, int32_t>(year), Cast::Operation<T, int32_t>(month),
 	                       Cast::Operation<T, int32_t>(day), result)) {
@@ -48,7 +46,7 @@ date_t FromDateCast(T year, T month, T day) {
 }
 
 template <typename T>
-void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
 	// this should be guaranteed by the binder
 	D_ASSERT(input.ColumnCount() == 1);
 	auto &vec = input.data[0];
@@ -85,7 +83,7 @@ struct MakeTimeOperator {
 };
 
 template <typename T>
-void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
+static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 3);
 	auto &yyyy = input.data[0];
 	auto &mm = input.data[1];
@@ -114,7 +112,7 @@ struct MakeTimestampOperator {
 };
 
 template <typename T>
-void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
+static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
 	if (input.ColumnCount() == 1) {
 		auto func = MakeTimestampOperator::Operation<T, timestamp_t>;
 		UnaryExecutor::Execute<T, timestamp_t>(input.data[0], result, input.size(), func);
@@ -128,7 +126,7 @@ void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &resu
 }
 
 template <typename T>
-void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
+static void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
 	auto func = MakeTimestampOperator::Operation<T, timestamp_ns_t>;
@@ -136,8 +134,6 @@ void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &re
 	return;
 }
 
-} // namespace
-
 ScalarFunctionSet MakeDateFun::GetFunctions() {
 	ScalarFunctionSet make_date("make_date");
 	make_date.AddFunction(ScalarFunction({LogicalType::INTEGER}, LogicalType::DATE, MakeDateFromEpoch));

package/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp

@@ -13,8 +13,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct TimeBucket {
 
 	// Use 2000-01-03 00:00:00 (Monday) as origin when bucket_width is days, hours, ... for TimescaleDB compatibility
@@ -228,7 +226,7 @@ struct TimeBucket {
 };
 
 template <typename T>
-void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 
 	auto &bucket_width_arg = args.data[0];
@@ -267,7 +265,7 @@ void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result)
 }
 
 template <typename T>
-void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 
 	auto &bucket_width_arg = args.data[0];
@@ -309,7 +307,7 @@ void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 template <typename T>
-void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 
 	auto &bucket_width_arg = args.data[0];
@@ -352,8 +350,6 @@ void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &r
 	}
 }
 
-} // namespace
-
 ScalarFunctionSet TimeBucketFun::GetFunctions() {
 	ScalarFunctionSet time_bucket;
 	time_bucket.AddFunction(

package/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp

@@ -11,8 +11,6 @@ bool TryMultiplyOperator::Operation(double left, int64_t right, int64_t &result)
 	return TryCast::Operation<double, int64_t>(left * double(right), result);
 }
 
-namespace {
-
 struct ToMillenniaOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -188,8 +186,6 @@ ScalarFunctionSet GetIntegerIntervalFunctions() {
 	return function_set;
 }
 
-} // namespace
-
 ScalarFunctionSet ToMillenniaFun::GetFunctions() {
 	return GetIntegerIntervalFunctions<ToMillenniaOperator>();
 }

package/src/duckdb/extension/core_functions/scalar/enum/enum_functions.cpp

@@ -71,8 +71,8 @@ static void CheckEnumParameter(const Expression &expr) {
 	}
 }
 
-static unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
+                                          vector<unique_ptr<Expression>> &arguments) {
 	CheckEnumParameter(*arguments[0]);
 	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
 		throw BinderException("This function needs an ENUM as an argument");
@@ -80,8 +80,8 @@ static unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarF
 	return nullptr;
 }
 
-static unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	CheckEnumParameter(*arguments[0]);
 	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
 		throw BinderException("This function needs an ENUM as an argument");
@@ -108,8 +108,8 @@ static unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, Sca
 	return nullptr;
 }
 
-static unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                              vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                       vector<unique_ptr<Expression>> &arguments) {
 	CheckEnumParameter(*arguments[0]);
 	CheckEnumParameter(*arguments[1]);
 	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM && arguments[0]->return_type != LogicalType::SQLNULL) {

package/src/duckdb/extension/core_functions/scalar/generic/binning.cpp

@@ -10,9 +10,7 @@
 
 namespace duckdb {
 
-namespace {
-
-hugeint_t GetPreviousPowerOfTen(hugeint_t input) {
+static hugeint_t GetPreviousPowerOfTen(hugeint_t input) {
 	hugeint_t power_of_ten = 1;
 	while (power_of_ten < input) {
 		power_of_ten *= 10;
@@ -62,7 +60,7 @@ hugeint_t MakeNumberNice(hugeint_t input, hugeint_t step, NiceRounding rounding)
 	}
 }
 
-double GetPreviousPowerOfTen(double input) {
+static double GetPreviousPowerOfTen(double input) {
 	double power_of_ten = 1;
 	if (input < 1) {
 		while (power_of_ten > input) {
@@ -427,7 +425,7 @@ unique_ptr<FunctionData> BindEquiWidthFunction(ClientContext &, ScalarFunction &
 }
 
 template <class T, class OP>
-void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	static constexpr int64_t MAX_BIN_COUNT = 1000000;
 	auto &min_arg = args.data[0];
 	auto &max_arg = args.data[1];
@@ -469,7 +467,7 @@ void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	VectorOperations::DefaultCast(intermediate_result, result, args.size());
 }
 
-void UnsupportedEquiWidth(DataChunk &args, ExpressionState &state, Vector &) {
+static void UnsupportedEquiWidth(DataChunk &args, ExpressionState &state, Vector &) {
 	throw BinderException(state.expr, "Unsupported type \"%s\" for equi_width_bins", args.data[0].GetType());
 }
 
@@ -482,8 +480,6 @@ unique_ptr<FunctionData> EquiWidthBinDeserialize(Deserializer &deserializer, Sca
 	return nullptr;
 }
 
-} // namespace
-
 ScalarFunctionSet EquiWidthBinsFun::GetFunctions() {
 	ScalarFunctionSet functions("equi_width_bins");
 	functions.AddFunction(

package/src/duckdb/extension/core_functions/scalar/generic/can_implicitly_cast.cpp

@@ -6,13 +6,11 @@
 
 namespace duckdb {
 
-namespace {
-
 bool CanCastImplicitly(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	return CastFunctionSet::ImplicitCastCost(context, source, target) >= 0;
+	return CastFunctionSet::Get(context).ImplicitCastCost(source, target) >= 0;
 }
 
-void CanCastImplicitlyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CanCastImplicitlyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
 	bool can_cast_implicitly = CanCastImplicitly(context, args.data[0].GetType(), args.data[1].GetType());
 	auto v = Value::BOOLEAN(can_cast_implicitly);
@@ -32,8 +30,6 @@ unique_ptr<Expression> BindCanCastImplicitlyExpression(FunctionBindExpressionInp
 	    Value::BOOLEAN(CanCastImplicitly(input.context, source_type, target_type)));
 }
 
-} // namespace
-
 ScalarFunction CanCastImplicitlyFun::GetFunction() {
 	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::BOOLEAN, CanCastImplicitlyFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;

package/src/duckdb/extension/core_functions/scalar/generic/cast_to_type.cpp

@@ -3,9 +3,7 @@
 
 namespace duckdb {
 
-namespace {
-
-void CastToTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CastToTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	throw InternalException("CastToType function cannot be executed directly");
 }
 
@@ -21,7 +19,6 @@ unique_ptr<Expression> BindCastToTypeFunction(FunctionBindExpressionInput &input
 	return BoundCastExpression::AddCastToType(input.context, std::move(input.children[0]), return_type);
 }
 
-} // namespace
 ScalarFunction CastToTypeFun::GetFunction() {
 	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, CastToTypeFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;

package/src/duckdb/extension/core_functions/scalar/generic/current_setting.cpp

@@ -7,7 +7,6 @@
 #include "duckdb/catalog/catalog.hpp"
 namespace duckdb {
 
-namespace {
 struct CurrentSettingBindData : public FunctionData {
 	explicit CurrentSettingBindData(Value value_p) : value(std::move(value_p)) {
 	}
@@ -25,7 +24,7 @@ public:
 	}
 };
 
-void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<CurrentSettingBindData>();
 	result.Reference(info.value);
@@ -51,20 +50,15 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	auto key = StringUtil::Lower(StringValue::Get(key_val));
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
-		auto extension_name = Catalog::AutoloadExtensionByConfigName(context, key);
+		Catalog::AutoloadExtensionByConfigName(context, key);
 		// If autoloader didn't throw, the config is now available
-		if (!context.TryGetCurrentSetting(key, val)) {
-			throw InternalException("Extension %s did not provide the '%s' config setting",
-			                        extension_name.ToStdString(), key);
-		}
+		context.TryGetCurrentSetting(key, val);
 	}
 
 	bound_function.return_type = val.type();
 	return make_uniq<CurrentSettingBindData>(val);
 }
 
-} // namespace
-
 ScalarFunction CurrentSettingFun::GetFunction() {
 	auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::ANY, CurrentSettingFunction, CurrentSettingBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;

package/src/duckdb/extension/core_functions/scalar/generic/least.cpp

@@ -6,7 +6,6 @@
 
 namespace duckdb {
 
-namespace {
 struct LeastOp {
 	using OP = LessThan;
 
@@ -109,7 +108,7 @@ struct SortKeyLeastGreatest {
 };
 
 template <class T, class OP, class BASE_OP = StandardLeastGreatest<false>>
-void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	if (args.ColumnCount() == 1) {
 		// single input: nop
 		result.Reference(args.data[0]);
@@ -244,14 +243,12 @@ ScalarFunction GetLeastGreatestFunction() {
 }
 
 template <class OP>
-ScalarFunctionSet GetLeastGreatestFunctions() {
+static ScalarFunctionSet GetLeastGreatestFunctions() {
 	ScalarFunctionSet fun_set;
 	fun_set.AddFunction(GetLeastGreatestFunction<OP>());
 	return fun_set;
 }
 
-} // namespace
-
 ScalarFunctionSet LeastFun::GetFunctions() {
 	return GetLeastGreatestFunctions<LeastOp>();
 }

package/src/duckdb/extension/core_functions/scalar/generic/stats.cpp

@@ -3,7 +3,6 @@
 
 namespace duckdb {
 
-namespace {
 struct StatsBindData : public FunctionData {
 	explicit StatsBindData(string stats_p = string()) : stats(std::move(stats_p)) {
 	}
@@ -21,7 +20,7 @@ public:
 	}
 };
 
-void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<StatsBindData>();
 	if (info.stats.empty()) {
@@ -36,7 +35,7 @@ unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound
 	return make_uniq<StatsBindData>();
 }
 
-unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
 	auto &info = bind_data->Cast<StatsBindData>();
@@ -44,8 +43,6 @@ unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionS
 	return nullptr;
 }
 
-} // namespace
-
 ScalarFunction StatsFun::GetFunction() {
 	ScalarFunction stats({LogicalType::ANY}, LogicalType::VARCHAR, StatsFunction, StatsBind, nullptr,
 	                     StatsPropagateStats);

package/src/duckdb/extension/core_functions/scalar/generic/system_functions.cpp

@@ -11,22 +11,20 @@
 
 namespace duckdb {
 
-namespace {
-
 // current_query
-void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(state.GetContext().GetCurrentQuery());
 	result.Reference(val);
 }
 
 // current_schema
-void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(ClientData::Get(state.GetContext()).catalog_search_path->GetDefault().schema);
 	result.Reference(val);
 }
 
 // current_database
-void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(DatabaseManager::GetDefaultDatabase(state.GetContext()));
 	result.Reference(val);
 }
@@ -47,8 +45,8 @@ public:
 	}
 };
 
-unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->return_type.id() != LogicalTypeId::BOOLEAN) {
 		throw BinderException("current_schemas requires a boolean input");
 	}
@@ -73,14 +71,14 @@ unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFuncti
 }
 
 // current_schemas
-void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<CurrentSchemasBindData>();
 	result.Reference(info.result);
 }
 
 // in_search_path
-void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
 	auto &search_path = ClientData::Get(context).catalog_search_path;
 	BinaryExecutor::Execute<string_t, string_t, bool>(
@@ -90,7 +88,7 @@ void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &resu
 }
 
 // txid_current
-void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
+static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
 	auto &catalog = Catalog::GetCatalog(context, DatabaseManager::GetDefaultDatabase(context));
 	auto &transaction = DuckTransaction::Get(context, catalog);
@@ -99,13 +97,11 @@ void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &resu
 }
 
 // version
-void VersionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+static void VersionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto val = Value(DuckDB::LibraryVersion());
 	result.Reference(val);
 }
 
-} // namespace
-
 ScalarFunction CurrentQueryFun::GetFunction() {
 	ScalarFunction current_query({}, LogicalType::VARCHAR, CurrentQueryFunction);
 	current_query.stability = FunctionStability::VOLATILE;

package/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp

@@ -4,9 +4,7 @@
 
 namespace duckdb {
 
-namespace {
-
-void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	Value v(args.data[0].GetType().ToString());
 	result.Reference(v);
 }
@@ -21,8 +19,6 @@ unique_ptr<Expression> BindTypeOfFunctionExpression(FunctionBindExpressionInput
 	return make_uniq<BoundConstantExpression>(Value(return_type.ToString()));
 }
 
-} // namespace
-
 ScalarFunction TypeOfFun::GetFunction() {
 	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;