duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

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

@@ -10,6 +10,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct DateTrunc {
 	template <class TA, class TR, class OP>
 	static inline TR UnaryFunction(TA input) {
@@ -458,7 +460,7 @@ interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
 }
 
 template <class TA, class TR>
-static TR TruncateElement(DatePartSpecifier type, TA element) {
+TR TruncateElement(DatePartSpecifier type, TA element) {
 	if (!Value::IsFinite(element)) {
 		return Cast::template Operation<TA, TR>(element);
 	}
@@ -511,7 +513,7 @@ struct DateTruncBinaryOperator {
 };
 
 template <typename TA, typename TR>
-static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
+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);
@@ -567,7 +569,7 @@ static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector
 }
 
 template <typename TA, typename TR>
-static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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];
@@ -588,7 +590,7 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_stats) {
+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)) {
@@ -615,12 +617,12 @@ static unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &ch
 }
 
 template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 	return DateTruncStatistics<TA, TR, OP>(input.child_stats);
 }
 
 template <typename TA, typename TR>
-static function_statistics_t DateTruncStats(DatePartSpecifier type) {
+function_statistics_t DateTruncStats(DatePartSpecifier type) {
 	switch (type) {
 	case DatePartSpecifier::MILLENNIUM:
 		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillenniumOperator>;
@@ -661,8 +663,8 @@ static function_statistics_t DateTruncStats(DatePartSpecifier type) {
 	}
 }
 
-static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
+                                       vector<unique_ptr<Expression>> &arguments) {
 	if (!arguments[0]->IsFoldable()) {
 		return nullptr;
 	}
@@ -720,6 +722,8 @@ static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunc
 	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,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct EpochSecOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE sec) {
@@ -17,17 +19,12 @@ struct EpochSecOperator {
 	}
 };
 
-static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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) {
@@ -35,16 +32,12 @@ struct NormalizedIntervalOperator {
 	}
 };
 
-static void NormalizedIntervalFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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) {
@@ -52,12 +45,23 @@ struct TimeTZSortKeyOperator {
 	}
 };
 
-static void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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,7 +11,9 @@
 
 namespace duckdb {
 
-static void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
+namespace {
+
+void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 	result.Reinterpret(input.data[0]);
 }
@@ -25,7 +27,7 @@ struct MakeDateOperator {
 };
 
 template <typename T>
-static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 3);
 	auto &yyyy = input.data[0];
 	auto &mm = input.data[1];
@@ -36,7 +38,7 @@ static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &re
 }
 
 template <typename T>
-static date_t FromDateCast(T year, T month, T day) {
+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)) {
@@ -46,7 +48,7 @@ static date_t FromDateCast(T year, T month, T day) {
 }
 
 template <typename T>
-static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+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];
@@ -83,7 +85,7 @@ struct MakeTimeOperator {
 };
 
 template <typename T>
-static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
+void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 3);
 	auto &yyyy = input.data[0];
 	auto &mm = input.data[1];
@@ -112,7 +114,7 @@ struct MakeTimestampOperator {
 };
 
 template <typename T>
-static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
+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);
@@ -126,7 +128,7 @@ static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vecto
 }
 
 template <typename T>
-static void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
+void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
 	auto func = MakeTimestampOperator::Operation<T, timestamp_ns_t>;
@@ -134,6 +136,8 @@ static void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vec
 	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,6 +13,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct TimeBucket {
 
 	// Use 2000-01-03 00:00:00 (Monday) as origin when bucket_width is days, hours, ... for TimescaleDB compatibility
@@ -226,7 +228,7 @@ struct TimeBucket {
 };
 
 template <typename T>
-static void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 
 	auto &bucket_width_arg = args.data[0];
@@ -265,7 +267,7 @@ static void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 template <typename T>
-static void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 
 	auto &bucket_width_arg = args.data[0];
@@ -307,7 +309,7 @@ static void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Ve
 }
 
 template <typename T>
-static void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 
 	auto &bucket_width_arg = args.data[0];
@@ -350,6 +352,8 @@ static void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Ve
 	}
 }
 
+} // namespace
+
 ScalarFunctionSet TimeBucketFun::GetFunctions() {
 	ScalarFunctionSet time_bucket;
 	time_bucket.AddFunction(

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

@@ -11,6 +11,8 @@ 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) {
@@ -186,6 +188,8 @@ 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) {
 	}
 }
 
-unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
-                                          vector<unique_ptr<Expression>> &arguments) {
+static 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 @@ unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction
 	return nullptr;
 }
 
-unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
+static 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 @@ unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, ScalarFunc
 	return nullptr;
 }
 
-unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
+static 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,7 +10,9 @@
 
 namespace duckdb {
 
-static hugeint_t GetPreviousPowerOfTen(hugeint_t input) {
+namespace {
+
+hugeint_t GetPreviousPowerOfTen(hugeint_t input) {
 	hugeint_t power_of_ten = 1;
 	while (power_of_ten < input) {
 		power_of_ten *= 10;
@@ -60,7 +62,7 @@ hugeint_t MakeNumberNice(hugeint_t input, hugeint_t step, NiceRounding rounding)
 	}
 }
 
-static double GetPreviousPowerOfTen(double input) {
+double GetPreviousPowerOfTen(double input) {
 	double power_of_ten = 1;
 	if (input < 1) {
 		while (power_of_ten > input) {
@@ -425,7 +427,7 @@ unique_ptr<FunctionData> BindEquiWidthFunction(ClientContext &, ScalarFunction &
 }
 
 template <class T, class OP>
-static void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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];
@@ -467,7 +469,7 @@ static void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector
 	VectorOperations::DefaultCast(intermediate_result, result, args.size());
 }
 
-static void UnsupportedEquiWidth(DataChunk &args, ExpressionState &state, Vector &) {
+void UnsupportedEquiWidth(DataChunk &args, ExpressionState &state, Vector &) {
 	throw BinderException(state.expr, "Unsupported type \"%s\" for equi_width_bins", args.data[0].GetType());
 }
 
@@ -480,6 +482,8 @@ 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,11 +6,13 @@
 
 namespace duckdb {
 
+namespace {
+
 bool CanCastImplicitly(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	return CastFunctionSet::Get(context).ImplicitCastCost(source, target) >= 0;
+	return CastFunctionSet::ImplicitCastCost(context, source, target) >= 0;
 }
 
-static void CanCastImplicitlyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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);
@@ -30,6 +32,8 @@ 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,7 +3,9 @@
 
 namespace duckdb {
 
-static void CastToTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+namespace {
+
+void CastToTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	throw InternalException("CastToType function cannot be executed directly");
 }
 
@@ -19,6 +21,7 @@ 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,6 +7,7 @@
 #include "duckdb/catalog/catalog.hpp"
 namespace duckdb {
 
+namespace {
 struct CurrentSettingBindData : public FunctionData {
 	explicit CurrentSettingBindData(Value value_p) : value(std::move(value_p)) {
 	}
@@ -24,7 +25,7 @@ public:
 	}
 };
 
-static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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);
@@ -50,15 +51,20 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	auto key = StringUtil::Lower(StringValue::Get(key_val));
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
-		Catalog::AutoloadExtensionByConfigName(context, key);
+		auto extension_name = Catalog::AutoloadExtensionByConfigName(context, key);
 		// If autoloader didn't throw, the config is now available
-		context.TryGetCurrentSetting(key, val);
+		if (!context.TryGetCurrentSetting(key, val)) {
+			throw InternalException("Extension %s did not provide the '%s' config setting",
+			                        extension_name.ToStdString(), key);
+		}
 	}
 
 	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,6 +6,7 @@
 
 namespace duckdb {
 
+namespace {
 struct LeastOp {
 	using OP = LessThan;
 
@@ -108,7 +109,7 @@ struct SortKeyLeastGreatest {
 };
 
 template <class T, class OP, class BASE_OP = StandardLeastGreatest<false>>
-static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	if (args.ColumnCount() == 1) {
 		// single input: nop
 		result.Reference(args.data[0]);
@@ -243,12 +244,14 @@ ScalarFunction GetLeastGreatestFunction() {
 }
 
 template <class OP>
-static ScalarFunctionSet GetLeastGreatestFunctions() {
+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/replace_type.cpp

@@ -0,0 +1,34 @@
+#include "core_functions/scalar/generic_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/common/type_visitor.hpp"
+
+namespace duckdb {
+
+static void ReplaceTypeFunction(DataChunk &, ExpressionState &, Vector &) {
+	throw InternalException("ReplaceTypeFunction function cannot be executed directly");
+}
+
+unique_ptr<Expression> BindReplaceTypeFunction(FunctionBindExpressionInput &input) {
+	const auto &from = input.children[1]->return_type;
+	const auto &to = input.children[2]->return_type;
+	if (from.id() == LogicalTypeId::UNKNOWN || to.id() == LogicalTypeId::UNKNOWN) {
+		// parameters - unknown return type
+		throw ParameterNotResolvedException();
+	}
+	if (to.id() == LogicalTypeId::SQLNULL) {
+		throw InvalidInputException("replace_type cannot be used to replace type with NULL");
+	}
+	const auto return_type = TypeVisitor::VisitReplace(
+	    input.children[0]->return_type, [&from, &to](const LogicalType &type) { return type == from ? to : type; });
+	return BoundCastExpression::AddCastToType(input.context, std::move(input.children[0]), return_type);
+}
+
+ScalarFunction ReplaceTypeFun::GetFunction() {
+	auto fun =
+	    ScalarFunction({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ReplaceTypeFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.bind_expression = BindReplaceTypeFunction;
+	return fun;
+}
+
+} // namespace duckdb

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

@@ -3,6 +3,7 @@
 
 namespace duckdb {
 
+namespace {
 struct StatsBindData : public FunctionData {
 	explicit StatsBindData(string stats_p = string()) : stats(std::move(stats_p)) {
 	}
@@ -20,7 +21,7 @@ public:
 	}
 };
 
-static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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()) {
@@ -35,7 +36,7 @@ unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound
 	return make_uniq<StatsBindData>();
 }
 
-static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+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>();
@@ -43,6 +44,8 @@ static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, Fu
 	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,20 +11,22 @@
 
 namespace duckdb {
 
+namespace {
+
 // current_query
-static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(state.GetContext().GetCurrentQuery());
 	result.Reference(val);
 }
 
 // current_schema
-static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(ClientData::Get(state.GetContext()).catalog_search_path->GetDefault().schema);
 	result.Reference(val);
 }
 
 // current_database
-static void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	Value val(DatabaseManager::GetDefaultDatabase(state.GetContext()));
 	result.Reference(val);
 }
@@ -45,8 +47,8 @@ public:
 	}
 };
 
-static unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
+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");
 	}
@@ -71,14 +73,14 @@ static unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, Scala
 }
 
 // current_schemas
-static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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
-static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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>(
@@ -88,7 +90,7 @@ static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vecto
 }
 
 // txid_current
-static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
+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);
@@ -97,11 +99,13 @@ static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vecto
 }
 
 // version
-static void VersionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+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,7 +4,9 @@
 
 namespace duckdb {
 
-static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+namespace {
+
+void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	Value v(args.data[0].GetType().ToString());
 	result.Reference(v);
 }
@@ -19,6 +21,8 @@ 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;