duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -34,13 +34,13 @@ static inline void AssertInSupportedRange(idx_t input_size, int64_t offset, int6
 	}
 }
 
-static string_t SubstringEmptyString(Vector &result) {
+string_t SubstringEmptyString(Vector &result) {
 	auto result_string = StringVector::EmptyString(result, 0);
 	result_string.Finalize();
 	return result_string;
 }
 
-static string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
+string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
 	auto result_string = StringVector::EmptyString(result, UnsafeNumericCast<idx_t>(length));
 	auto result_data = result_string.GetDataWriteable();
 	memcpy(result_data, input_data + offset, UnsafeNumericCast<size_t>(length));
@@ -49,7 +49,7 @@ static string_t SubstringSlice(Vector &result, const char *input_data, int64_t o
 }
 
 // compute start and end characters from the given input size and offset/length
-static bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
+bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
 	if (length == 0) {
 		return false;
 	}
@@ -250,8 +250,6 @@ string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64
 	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
 }
 
-namespace {
-
 struct SubstringUnicodeOp {
 	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
 		return SubstringUnicode(result, input, offset, length);
@@ -265,7 +263,7 @@ struct SubstringGraphemeOp {
 };
 
 template <class OP>
-void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input_vector = args.data[0];
 	auto &offset_vector = args.data[1];
 	if (args.ColumnCount() == 3) {
@@ -284,7 +282,7 @@ void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	}
 }
 
-void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
+static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input_vector = args.data[0];
 	auto &offset_vector = args.data[1];
 	if (args.ColumnCount() == 3) {
@@ -303,7 +301,7 @@ void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &res
 	}
 }
 
-unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	// can only propagate stats if the children have stats
@@ -314,8 +312,6 @@ unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, Funct
 	return nullptr;
 }
 
-} // namespace
-
 ScalarFunctionSet SubstringFun::GetFunctions() {
 	ScalarFunctionSet substr("substring");
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},

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

@@ -5,7 +5,14 @@
 
 namespace duckdb {
 
-namespace {
+static bool SuffixFunction(const string_t &str, const string_t &suffix);
+
+struct SuffixOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return SuffixFunction(left, right);
+	}
+};
 
 static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 	auto suffix_size = suffix.GetSize();
@@ -26,15 +33,6 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 	return true;
 }
 
-struct SuffixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return SuffixFunction(left, right);
-	}
-};
-
-} // namespace
-
 ScalarFunction SuffixFun::GetFunction() {
 	return ScalarFunction("suffix",                                     // name of the function
 	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list

package/src/duckdb/src/function/scalar/struct/remap_struct.cpp

@@ -9,8 +9,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct RemapColumnInfo {
 	optional_idx index;
 	optional_idx default_index;
@@ -38,12 +36,13 @@ public:
 	}
 };
 
-void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                 const vector<RemapColumnInfo> &remap_info);
+static void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                        const vector<RemapColumnInfo> &remap_info);
 
-void RemapChildVectors(const Vector &result, const vector<reference<Vector>> &input_vectors,
-                       const vector<reference<Vector>> &result_vectors, const vector<RemapColumnInfo> &remap_info,
-                       Vector &default_vector, const bool has_top_level_null, idx_t count) {
+static void RemapChildVectors(const Vector &result, const vector<reference<Vector>> &input_vectors,
+                              const vector<reference<Vector>> &result_vectors,
+                              const vector<RemapColumnInfo> &remap_info, Vector &default_vector,
+                              const bool has_top_level_null, idx_t count) {
 	// set up the correct vector references
 	for (idx_t i = 0; i < remap_info.size(); i++) {
 		auto &remap = remap_info[i];
@@ -77,8 +76,8 @@ void RemapChildVectors(const Vector &result, const vector<reference<Vector>> &in
 	}
 }
 
-void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-              const vector<RemapColumnInfo> &remap_info) {
+static void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                     const vector<RemapColumnInfo> &remap_info) {
 	auto &input_key_vector = MapVector::GetKeys(input);
 	auto &input_value_vector = MapVector::GetValues(input);
 
@@ -133,8 +132,8 @@ void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_t resul
 	RemapChildVectors(result, input_vectors, result_vectors, remap_info, default_vector, has_top_level_null, list_size);
 }
 
-void RemapList(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-               const vector<RemapColumnInfo> &remap_info) {
+static void RemapList(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                      const vector<RemapColumnInfo> &remap_info) {
 	auto &input_vector = ListVector::GetEntry(input);
 	auto &result_vector = ListVector::GetEntry(result);
 	auto list_size = ListVector::GetListSize(input);
@@ -182,8 +181,8 @@ void RemapList(Vector &input, Vector &default_vector, Vector &result, idx_t resu
 	RemapChildVectors(result, input_vectors, result_vectors, remap_info, default_vector, has_top_level_null, list_size);
 }
 
-void RemapStruct(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                 const vector<RemapColumnInfo> &remap_info) {
+static void RemapStruct(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                        const vector<RemapColumnInfo> &remap_info) {
 	auto &input_child_vectors = StructVector::GetEntries(input);
 	auto &result_child_vectors = StructVector::GetEntries(result);
 	if (result_child_vectors.size() != remap_info.size()) {
@@ -227,8 +226,8 @@ void RemapStruct(Vector &input, Vector &default_vector, Vector &result, idx_t re
 	                  result_size);
 }
 
-void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                 const vector<RemapColumnInfo> &remap_info) {
+static void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                        const vector<RemapColumnInfo> &remap_info) {
 	auto &source_type = input.GetType();
 	D_ASSERT(source_type.IsNested());
 	switch (source_type.id()) {
@@ -243,7 +242,7 @@ void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t re
 	}
 }
 
-void RemapStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void RemapStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<RemapStructBindData>();
 
@@ -540,8 +539,8 @@ struct RemapEntry {
 	}
 };
 
-unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFunction &bound_function,
-                                         vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() == 4);
 	for (idx_t arg_idx = 0; arg_idx < 3; arg_idx++) {
 		auto &arg = arguments[arg_idx];
@@ -622,8 +621,6 @@ unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFunction
 	return make_uniq<RemapStructBindData>(std::move(remap));
 }
 
-} // namespace
-
 ScalarFunction RemapStructFun::GetFunction() {
 	ScalarFunction remap("remap_struct",
 	                     {LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalTypeId::ANY},

package/src/duckdb/src/function/scalar/struct/struct_concat.cpp

@@ -84,7 +84,7 @@ static unique_ptr<FunctionData> StructConcatBind(ClientContext &context, ScalarF
 	return nullptr;
 }
 
-static unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
 	const auto &expr = input.expr;
 
 	auto &arg_stats = input.child_stats;

package/src/duckdb/src/function/scalar/struct/struct_pack.cpp

@@ -60,7 +60,7 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-static unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
@@ -71,7 +71,7 @@ static unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, Functi
 }
 
 template <bool IS_STRUCT_PACK>
-static ScalarFunction GetStructPackFunction() {
+ScalarFunction GetStructPackFunction() {
 	ScalarFunction fun(IS_STRUCT_PACK ? "struct_pack" : "row", {}, LogicalTypeId::STRUCT, StructPackFunction,
 	                   StructPackBind<IS_STRUCT_PACK>, nullptr, StructPackStats);
 	fun.varargs = LogicalType::ANY;

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -11,8 +11,6 @@
 
 namespace duckdb {
 
-namespace {
-
 // aggregate state export
 struct ExportAggregateBindData : public FunctionData {
 	AggregateFunction aggr;
@@ -54,8 +52,8 @@ struct CombineState : public FunctionLocalState {
 	}
 };
 
-unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                FunctionData *bind_data_p) {
+static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                       FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<CombineState>(bind_data.state_size);
 }
@@ -74,13 +72,13 @@ struct FinalizeState : public FunctionLocalState {
 	}
 };
 
-unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                 FunctionData *bind_data_p) {
+static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                        FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<FinalizeState>(bind_data.state_size);
 }
 
-void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
+static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
 	local_state.allocator.Reset();
@@ -121,7 +119,7 @@ void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &
 	}
 }
 
-void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
+static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
 	local_state.allocator.Reset();
@@ -183,8 +181,8 @@ void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &r
 	}
 }
 
-unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
 
 	// grab the aggregate type and bind the aggregate again
 
@@ -255,8 +253,8 @@ unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFuncti
 	return make_uniq<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size(bound_aggr));
 }
 
-void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                             idx_t offset) {
+static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+                                    idx_t offset) {
 	D_ASSERT(offset == 0);
 	auto &bind_data = aggr_input_data.bind_data->Cast<ExportAggregateFunctionBindData>();
 	auto state_size = bind_data.aggregate->function.state_size(bind_data.aggregate->function);
@@ -268,26 +266,39 @@ void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data,
 	}
 }
 
-void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                   const AggregateFunction &function) {
+ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
+	D_ASSERT(aggregate_p->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
+	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
+}
+
+unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
+	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
+}
+
+bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
+	return aggregate->Equals(*other.aggregate);
+}
+
+static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                          const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
 
-unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer, AggregateFunction &function) {
+static unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
+                                                                AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                const ScalarFunction &function) {
+static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                       const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
 
-unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-} // namespace
-
 unique_ptr<BoundAggregateExpression>
 ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
 	auto &bound_function = child_aggregate->function;
@@ -330,20 +341,6 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	                                           child_aggregate->aggr_type);
 }
 
-ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
-	D_ASSERT(aggregate_p->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
-}
-
-unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
-	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
-}
-
-bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
-	return aggregate->Equals(*other.aggregate);
-}
-
 ScalarFunction FinalizeFun::GetFunction() {
 	auto result = ScalarFunction("finalize", {LogicalTypeId::AGGREGATE_STATE}, LogicalTypeId::INVALID,
 	                             AggregateStateFinalize, BindAggregateState, nullptr, nullptr, InitFinalizeState);

package/src/duckdb/src/function/scalar/system/current_connection_id.cpp

@@ -7,8 +7,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct CurrentConnectionIdData : FunctionData {
 	explicit CurrentConnectionIdData(Value connection_id_p) : connection_id(std::move(connection_id_p)) {
 	}
@@ -27,14 +25,12 @@ unique_ptr<FunctionData> CurrentConnectionIdBind(ClientContext &context, ScalarF
 	return make_uniq<CurrentConnectionIdData>(Value::UBIGINT(context.GetConnectionId()));
 }
 
-void CurrentConnectionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CurrentConnectionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<CurrentConnectionIdData>();
 	result.Reference(info.connection_id);
 }
 
-} // namespace
-
 ScalarFunction CurrentConnectionId::GetFunction() {
 	return ScalarFunction({}, LogicalType::UBIGINT, CurrentConnectionIdFunction, CurrentConnectionIdBind, nullptr,
 	                      nullptr, nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE);

package/src/duckdb/src/function/scalar/system/current_query_id.cpp

@@ -7,8 +7,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct CurrentQueryIdData : FunctionData {
 	explicit CurrentQueryIdData(Value query_id_p) : query_id(std::move(query_id_p)) {
 	}
@@ -33,14 +31,12 @@ unique_ptr<FunctionData> CurrentQueryIdBind(ClientContext &context, ScalarFuncti
 	return make_uniq<CurrentQueryIdData>(query_id);
 }
 
-void CurrentQueryIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CurrentQueryIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<CurrentQueryIdData>();
 	result.Reference(info.query_id);
 }
 
-} // namespace
-
 ScalarFunction CurrentQueryId::GetFunction() {
 	return ScalarFunction({}, LogicalType::UBIGINT, CurrentQueryIdFunction, CurrentQueryIdBind, nullptr, nullptr,
 	                      nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE);

package/src/duckdb/src/function/scalar/system/current_transaction_id.cpp

@@ -8,8 +8,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct CurrentTransactionIdData : FunctionData {
 	explicit CurrentTransactionIdData(Value transaction_id_p) : transaction_id(std::move(transaction_id_p)) {
 	}
@@ -34,14 +32,12 @@ unique_ptr<FunctionData> CurrentTransactionIdBind(ClientContext &context, Scalar
 	return make_uniq<CurrentTransactionIdData>(transaction_id);
 }
 
-void CurrentTransactionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void CurrentTransactionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<CurrentTransactionIdData>();
 	result.Reference(info.transaction_id);
 }
 
-} // namespace
-
 ScalarFunction CurrentTransactionId::GetFunction() {
 	return ScalarFunction({}, LogicalType::UBIGINT, CurrentTransactionIdFunction, CurrentTransactionIdBind, nullptr,
 	                      nullptr, nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE);

package/src/duckdb/src/function/scalar/system/parse_log_message.cpp

@@ -12,8 +12,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct ParseLogMessageData : FunctionData {
 	explicit ParseLogMessageData(const LogType &log_type_p) : log_type(log_type_p) {
 	}
@@ -61,7 +59,7 @@ unique_ptr<FunctionData> ParseLogMessageBind(ClientContext &context, ScalarFunct
 	return make_uniq<ParseLogMessageData>(*lookup);
 }
 
-void ParseLogMessageFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ParseLogMessageFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<ParseLogMessageData>();
 
@@ -74,8 +72,6 @@ void ParseLogMessageFunction(DataChunk &args, ExpressionState &state, Vector &re
 	}
 }
 
-} // namespace
-
 ScalarFunction ParseLogMessage::GetFunction() {
 	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::ANY, ParseLogMessageFunction,
 	                      ParseLogMessageBind, nullptr, nullptr, nullptr, LogicalType(LogicalTypeId::INVALID));

package/src/duckdb/src/function/scalar/system/write_log.cpp

@@ -2,13 +2,11 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/logging/log_manager.hpp"
+
 #include "utf8proc.hpp"
 
 namespace duckdb {
 
-namespace {
-
 struct WriteLogBindData : FunctionData {
 	//! Config
 	bool disable_logging = false;
@@ -45,7 +43,7 @@ public:
 	}
 };
 
-void ThrowIfNotConstant(const Expression &arg) {
+static void ThrowIfNotConstant(const Expression &arg) {
 	if (!arg.IsFoldable()) {
 		throw BinderException("write_log: argument '%s' must be constant", arg.alias);
 	}
@@ -112,14 +110,20 @@ unique_ptr<FunctionData> WriteLogBind(ClientContext &context, ScalarFunction &bo
 }
 
 template <class T>
-void WriteLogValues(T &LogSource, LogLevel level, const string_t *data, const SelectionVector *sel, idx_t size,
-                    const string &type) {
-	for (idx_t i = 0; i < size; i++) {
-		DUCKDB_LOG_INTERNAL(LogSource, type.c_str(), level, data[sel->get_index(i)]);
+static void WriteLogValues(T &LogSource, LogLevel level, const string_t *data, const SelectionVector *sel, idx_t size,
+                           const string &type) {
+	if (!type.empty()) {
+		for (idx_t i = 0; i < size; i++) {
+			DUCKDB_LOG_INTERNAL(LogSource, type.c_str(), level, data[sel->get_index(i)]);
+		}
+	} else {
+		for (idx_t i = 0; i < size; i++) {
+			DUCKDB_LOG_INTERNAL(LogSource, type.c_str(), level, data[sel->get_index(i)]);
+		}
 	}
 }
 
-void WriteLogFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void WriteLogFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() >= 1);
 
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
@@ -154,8 +158,6 @@ void WriteLogFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	}
 }
 
-} // namespace
-
 ScalarFunctionSet WriteLogFun::GetFunctions() {
 	ScalarFunctionSet set("write_log");
 

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -29,14 +29,17 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() const {
 	return std::move(result);
 }
 
-void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &root_expr) {
-	ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(
-	    *root_expr, [&](ColumnRefExpression &col_ref) {
-		    auto &col_names = col_ref.column_names;
-		    if (col_names.size() == 2 && col_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
-			    col_names.erase(col_names.begin());
-		    }
-	    });
+void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
+	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
+		auto &col_names = col_ref.column_names;
+		if (col_names.size() == 2 && col_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
+			col_names.erase(col_names.begin());
+		}
+	} else {
+		ParsedExpressionIterator::EnumerateChildren(
+		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveQualificationRecursive(child); });
+	}
 }
 
 string ScalarMacroFunction::ToSQL() const {

package/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp

@@ -4,14 +4,15 @@
 
 namespace duckdb {
 
-ArrowArrayScanState::ArrowArrayScanState(ClientContext &context) : context(context) {
+ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state, ClientContext &context)
+    : state(state), context(context) {
 	arrow_dictionary = nullptr;
 }
 
 ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) {
 	auto it = children.find(child_idx);
 	if (it == children.end()) {
-		auto child_p = make_uniq<ArrowArrayScanState>(context);
+		auto child_p = make_uniq<ArrowArrayScanState>(state, context);
 		auto &child = *child_p;
 		child.owned_data = owned_data;
 		children.emplace(child_idx, std::move(child_p));

package/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp

@@ -8,27 +8,15 @@
 
 namespace duckdb {
 
-void ArrowTableSchema::AddColumn(idx_t index, shared_ptr<ArrowType> type, const string &name) {
+void ArrowTableType::AddColumn(idx_t index, shared_ptr<ArrowType> type) {
 	D_ASSERT(arrow_convert_data.find(index) == arrow_convert_data.end());
-	if (index >= types.size()) {
-		types.resize(index + 1);
-		column_names.resize(index + 1);
-	}
-	types[index] = type->GetDuckType(true);
-	column_names[index] = name;
 	arrow_convert_data.emplace(std::make_pair(index, std::move(type)));
 }
 
-const arrow_column_map_t &ArrowTableSchema::GetColumns() const {
+const arrow_column_map_t &ArrowTableType::GetColumns() const {
 	return arrow_convert_data;
 }
-vector<LogicalType> &ArrowTableSchema::GetTypes() {
-	return types;
-}
 
-vector<string> &ArrowTableSchema::GetNames() {
-	return column_names;
-}
 void ArrowType::SetDictionary(unique_ptr<ArrowType> dictionary) {
 	D_ASSERT(!this->dictionary_type);
 	dictionary_type = std::move(dictionary);
@@ -184,9 +172,6 @@ unique_ptr<ArrowType> ArrowType::GetTypeFromFormat(string &format) {
 	} else if (format == "Z") {
 		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
 		return make_uniq<ArrowType>(LogicalType::BLOB, std::move(type_info));
-	} else if (format == "vz") {
-		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::VIEW);
-		return make_uniq<ArrowType>(LogicalType::BLOB, std::move(type_info));
 	} else if (format[0] == 'w') {
 		string parameters = format.substr(format.find(':') + 1);
 		auto fixed_size = NumericCast<idx_t>(std::stoi(parameters));
@@ -392,16 +377,6 @@ bool ArrowType::HasExtension() const {
 	return extension_data.get() != nullptr;
 }
 
-ArrowArrayPhysicalType ArrowType::GetPhysicalType() const {
-	if (HasDictionary()) {
-		return ArrowArrayPhysicalType::DICTIONARY_ENCODED;
-	}
-	if (RunEndEncoded()) {
-		return ArrowArrayPhysicalType::RUN_END_ENCODED;
-	}
-	return ArrowArrayPhysicalType::DEFAULT;
-}
-
 unique_ptr<ArrowType> ArrowType::GetTypeFromSchema(DBConfig &config, ArrowSchema &schema) {
 	auto format = string(schema.format);
 	// Let's first figure out if this type is an extension type