duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -0,0 +1,243 @@
+#include "duckdb/function/scalar/regexp.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/function/scalar/string_functions.hpp"
+#include "re2/re2.h"
+
+namespace duckdb {
+
+using regexp_util::CreateStringPiece;
+using regexp_util::Extract;
+using regexp_util::ParseRegexOptions;
+using regexp_util::TryParseConstantPattern;
+
+unique_ptr<FunctionLocalState>
+RegexpExtractAll::InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr, FunctionData *bind_data) {
+	auto &info = (RegexpBaseBindData &)*bind_data;
+	if (info.constant_pattern) {
+		return make_unique<RegexLocalState>(info, true);
+	}
+	return nullptr;
+}
+
+// Forwards startpos automatically
+bool ExtractAll(duckdb_re2::StringPiece &input, duckdb_re2::RE2 &pattern, idx_t *startpos,
+                duckdb_re2::StringPiece *groups, int ngroups) {
+
+	D_ASSERT(pattern.ok());
+	D_ASSERT(pattern.NumberOfCapturingGroups() == ngroups);
+
+	if (!pattern.Match(input, *startpos, input.size(), pattern.Anchored(), groups, ngroups + 1)) {
+		return false;
+	}
+	idx_t consumed = static_cast<size_t>(groups[0].end() - (input.begin() + *startpos));
+	if (!consumed) {
+		// Empty match found, have to manually forward the input
+		// to avoid an infinite loop
+		// FIXME: support unicode characters
+		consumed++;
+		while (*startpos + consumed < input.length() && !LengthFun::IsCharacter(input[*startpos + consumed])) {
+			consumed++;
+		}
+	}
+	*startpos += consumed;
+	return true;
+}
+
+void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_t group, RegexStringPieceArgs &args,
+                        Vector &result, idx_t row) {
+	auto input = CreateStringPiece(string);
+
+	auto &child_vector = ListVector::GetEntry(result);
+	auto list_content = FlatVector::GetData<string_t>(child_vector);
+	auto &child_validity = FlatVector::Validity(child_vector);
+
+	auto current_list_size = ListVector::GetListSize(result);
+	auto current_list_capacity = ListVector::GetListCapacity(result);
+
+	auto result_data = FlatVector::GetData<list_entry_t>(result);
+	auto &list_entry = result_data[row];
+	list_entry.offset = current_list_size;
+
+	if (group < 0) {
+		list_entry.length = 0;
+		return;
+	}
+	// If the requested group index is out of bounds
+	// we want to throw only if there is a match
+	bool throw_on_group_found = (idx_t)group > args.size;
+
+	idx_t startpos = 0;
+	for (idx_t iteration = 0; ExtractAll(input, pattern, &startpos, args.group_buffer, args.size); iteration++) {
+		if (!iteration && throw_on_group_found) {
+			throw InvalidInputException("Pattern has %d groups. Cannot access group %d", args.size, group);
+		}
+
+		// Make sure we have enough room for the new entries
+		if (current_list_size + 1 >= current_list_capacity) {
+			ListVector::Reserve(result, current_list_capacity * 2);
+			current_list_capacity = ListVector::GetListCapacity(result);
+			list_content = FlatVector::GetData<string_t>(child_vector);
+		}
+
+		// Write the captured groups into the list-child vector
+		auto &match_group = args.group_buffer[group];
+
+		idx_t child_idx = current_list_size;
+		if (match_group.empty()) {
+			// This group was not matched
+			list_content[child_idx] = string_t(string.GetDataUnsafe(), 0);
+			if (match_group.begin() == nullptr) {
+				// This group is optional
+				child_validity.SetInvalid(child_idx);
+			}
+		} else {
+			// Every group is a substring of the original, we can find out the offset using the pointer
+			// the 'match_group' address is guaranteed to be bigger than that of the source
+			D_ASSERT((const char *)match_group.begin() >= string.GetDataUnsafe());
+			idx_t offset = match_group.begin() - string.GetDataUnsafe();
+			list_content[child_idx] = string_t(string.GetDataUnsafe() + offset, match_group.size());
+		}
+		current_list_size++;
+		if (startpos > input.size()) {
+			// Empty match found at the end of the string
+			break;
+		}
+	}
+	list_entry.length = current_list_size - list_entry.offset;
+	ListVector::SetListSize(result, current_list_size);
+}
+
+int32_t GetGroupIndex(DataChunk &args, idx_t row, int32_t &result) {
+	if (args.ColumnCount() < 3) {
+		result = 0;
+		return true;
+	}
+	UnifiedVectorFormat format;
+	args.data[2].ToUnifiedFormat(args.size(), format);
+	idx_t index = format.sel->get_index(row);
+	if (!format.validity.RowIsValid(index)) {
+		return false;
+	}
+	result = ((int32_t *)format.data)[index];
+	return true;
+}
+
+duckdb_re2::RE2 &GetPattern(const RegexpBaseBindData &info, ExpressionState &state,
+                            unique_ptr<duckdb_re2::RE2> &pattern_p) {
+	if (info.constant_pattern) {
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		return lstate.constant_pattern;
+	}
+	D_ASSERT(pattern_p);
+	return *pattern_p;
+}
+
+RegexStringPieceArgs &GetGroupsBuffer(const RegexpBaseBindData &info, ExpressionState &state,
+                                      unique_ptr<RegexStringPieceArgs> &groups_p) {
+	if (info.constant_pattern) {
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		return lstate.group_buffer;
+	}
+	D_ASSERT(groups_p);
+	return *groups_p;
+}
+
+void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	const auto &info = (RegexpBaseBindData &)*func_expr.bind_info;
+
+	auto &strings = args.data[0];
+	auto &patterns = args.data[1];
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto &output_child = ListVector::GetEntry(result);
+
+	UnifiedVectorFormat strings_data;
+	strings.ToUnifiedFormat(args.size(), strings_data);
+
+	UnifiedVectorFormat pattern_data;
+	patterns.ToUnifiedFormat(args.size(), pattern_data);
+
+	ListVector::Reserve(result, STANDARD_VECTOR_SIZE);
+	// Reference the 'strings' StringBuffer, because we won't need to allocate new data
+	// for the result, all returned strings are substrings of the originals
+	output_child.SetAuxiliary(strings.GetAuxiliary());
+
+	// Avoid doing extra work if all the inputs are constant
+	idx_t tuple_count = args.AllConstant() ? 1 : args.size();
+
+	unique_ptr<RegexStringPieceArgs> non_const_args;
+	unique_ptr<duckdb_re2::RE2> stored_re;
+	if (!info.constant_pattern) {
+		non_const_args = make_unique<RegexStringPieceArgs>();
+	} else {
+		// Verify that the constant pattern is valid
+		auto &re = GetPattern(info, state, stored_re);
+		auto group_count_p = re.NumberOfCapturingGroups();
+		if (group_count_p == -1) {
+			throw InvalidInputException("Pattern failed to parse, error: '%s'", re.error());
+		}
+	}
+
+	for (idx_t row = 0; row < tuple_count; row++) {
+		bool pattern_valid = true;
+		if (!info.constant_pattern) {
+			// Check if the pattern is NULL or not,
+			// and compile the pattern if it's not constant
+			auto pattern_idx = pattern_data.sel->get_index(row);
+			if (!pattern_data.validity.RowIsValid(pattern_idx)) {
+				pattern_valid = false;
+			} else {
+				auto &pattern_p = ((string_t *)pattern_data.data)[pattern_idx];
+				auto pattern_strpiece = CreateStringPiece(pattern_p);
+				stored_re = make_unique<duckdb_re2::RE2>(pattern_strpiece, info.options);
+
+				// Increase the size of the args buffer if needed
+				auto group_count_p = stored_re->NumberOfCapturingGroups();
+				if (group_count_p == -1) {
+					throw InvalidInputException("Pattern failed to parse, error: '%s'", stored_re->error());
+				}
+				non_const_args->SetSize(group_count_p);
+			}
+		}
+
+		auto string_idx = strings_data.sel->get_index(row);
+		int32_t group_index;
+		if (!pattern_valid || !strings_data.validity.RowIsValid(string_idx) || !GetGroupIndex(args, row, group_index)) {
+			// If something is NULL, the result is NULL
+			// FIXME: do we even need 'SPECIAL_HANDLING'?
+			auto result_data = FlatVector::GetData<list_entry_t>(result);
+			auto &result_validity = FlatVector::Validity(result);
+			result_data[row].length = 0;
+			result_data[row].offset = ListVector::GetListSize(result);
+			result_validity.SetInvalid(row);
+			continue;
+		}
+
+		auto &re = GetPattern(info, state, stored_re);
+		auto &groups = GetGroupsBuffer(info, state, non_const_args);
+		auto &string = ((string_t *)strings_data.data)[string_idx];
+		ExtractSingleTuple(string, re, group_index, groups, result, row);
+	}
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+unique_ptr<FunctionData> RegexpExtractAll::Bind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(arguments.size() >= 2);
+
+	duckdb_re2::RE2::Options options;
+
+	string constant_string;
+	bool constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
+
+	if (arguments.size() >= 4) {
+		ParseRegexOptions(context, *arguments[3], options);
+	}
+	return make_unique<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern, "");
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp

@@ -0,0 +1,79 @@
+#include "duckdb/function/scalar/regexp.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+
+namespace duckdb {
+
+namespace regexp_util {
+
+bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string) {
+	if (!expr.IsFoldable()) {
+		return false;
+	}
+	Value pattern_str = ExpressionExecutor::EvaluateScalar(context, expr);
+	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
+		constant_string = StringValue::Get(pattern_str);
+		return true;
+	}
+	return false;
+}
+
+void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace) {
+	for (idx_t i = 0; i < options.size(); i++) {
+		switch (options[i]) {
+		case 'c':
+			// case-sensitive matching
+			result.set_case_sensitive(true);
+			break;
+		case 'i':
+			// case-insensitive matching
+			result.set_case_sensitive(false);
+			break;
+		case 'l':
+			// literal matching
+			result.set_literal(true);
+			break;
+		case 'm':
+		case 'n':
+		case 'p':
+			// newline-sensitive matching
+			result.set_dot_nl(false);
+			break;
+		case 's':
+			// non-newline-sensitive matching
+			result.set_dot_nl(true);
+			break;
+		case 'g':
+			// global replace, only available for regexp_replace
+			if (global_replace) {
+				*global_replace = true;
+			} else {
+				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
+			}
+			break;
+		case ' ':
+		case '\t':
+		case '\n':
+			// ignore whitespace
+			break;
+		default:
+			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
+		}
+	}
+}
+
+void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace) {
+	if (expr.HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	if (!expr.IsFoldable()) {
+		throw InvalidInputException("Regex options field must be a constant");
+	}
+	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
+	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
+	}
+}
+
+} // namespace regexp_util
+
+} // namespace duckdb

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

@@ -12,6 +12,11 @@
 
 namespace duckdb {
 
+using regexp_util::CreateStringPiece;
+using regexp_util::Extract;
+using regexp_util::ParseRegexOptions;
+using regexp_util::TryParseConstantPattern;
+
 static bool RegexOptionsEquals(const duckdb_re2::RE2::Options &opt_a, const duckdb_re2::RE2::Options &opt_b) {
 	return opt_a.case_sensitive() == opt_b.case_sensitive();
 }
@@ -32,10 +37,6 @@ bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
 	       RegexOptionsEquals(options, other.options);
 }
 
-static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
-	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
-}
-
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                    FunctionData *bind_data) {
 	auto &info = (RegexpBaseBindData &)*bind_data;
@@ -45,75 +46,6 @@ unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const
 	return nullptr;
 }
 
-static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
-	for (idx_t i = 0; i < options.size(); i++) {
-		switch (options[i]) {
-		case 'c':
-			// case-sensitive matching
-			result.set_case_sensitive(true);
-			break;
-		case 'i':
-			// case-insensitive matching
-			result.set_case_sensitive(false);
-			break;
-		case 'l':
-			// literal matching
-			result.set_literal(true);
-			break;
-		case 'm':
-		case 'n':
-		case 'p':
-			// newline-sensitive matching
-			result.set_dot_nl(false);
-			break;
-		case 's':
-			// non-newline-sensitive matching
-			result.set_dot_nl(true);
-			break;
-		case 'g':
-			// global replace, only available for regexp_replace
-			if (global_replace) {
-				*global_replace = true;
-			} else {
-				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
-			}
-			break;
-		case ' ':
-		case '\t':
-		case '\n':
-			// ignore whitespace
-			break;
-		default:
-			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
-		}
-	}
-}
-
-void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr) {
-	if (expr.HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!expr.IsFoldable()) {
-		throw InvalidInputException("Regex options field must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
-	}
-}
-
-static bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string) {
-	if (!expr.IsFoldable()) {
-		return false;
-	}
-	Value pattern_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-		constant_string = StringValue::Get(pattern_str);
-		return true;
-	}
-	return false;
-}
-
 //===--------------------------------------------------------------------===//
 // Regexp Matches
 //===--------------------------------------------------------------------===//
@@ -321,13 +253,6 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	                                          std::move(group_string));
 }
 
-inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,
-                               const duckdb_re2::StringPiece &rewrite) {
-	std::string extracted;
-	RE2::Extract(input.GetString(), re, rewrite, &extracted);
-	return StringVector::AddString(result, extracted.c_str(), extracted.size());
-}
-
 static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
@@ -391,10 +316,26 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
 
+	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
+	regexp_extract_all.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::LIST(LogicalType::VARCHAR),
+	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
+	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract_all.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::LIST(LogicalType::VARCHAR),
+	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
+	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract_all.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR},
+	                   LogicalType::LIST(LogicalType::VARCHAR), RegexpExtractAll::Execute, RegexpExtractAll::Bind,
+	                   nullptr, nullptr, RegexpExtractAll::InitLocalState, LogicalType::INVALID,
+	                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+
 	set.AddFunction(regexp_full_match);
 	set.AddFunction(regexp_partial_match);
 	set.AddFunction(regexp_replace);
 	set.AddFunction(regexp_extract);
+	set.AddFunction(regexp_extract_all);
 }
 
 } // namespace duckdb

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

@@ -4,7 +4,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "utf8proc.hpp"
 #include "duckdb/common/types/blob.hpp"
@@ -307,12 +307,8 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
 	// we only care about the stats of the first child (i.e. the string)
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = SubstringFunctionASCII;
 	}
 	return nullptr;

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

@@ -45,11 +45,13 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	// blob functions
 	Register<Base64Fun>();
 	Register<EncodeFun>();
+	Register<HexFun>();
 
 	// bit functions
 	Register<GetBitFun>();
 	Register<SetBitFun>();
 	Register<BitPositionFun>();
+	Register<BitStringFun>();
 
 	// uuid functions
 	Register<UUIDFun>();

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

@@ -3,7 +3,7 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 
 namespace duckdb {
 
@@ -96,21 +96,16 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	}
 
 	bound_function.return_type = return_type;
-	return make_unique<StructExtractBindData>(key, key_index, return_type);
+	return make_unique<StructExtractBindData>(std::move(key), key_index, std::move(return_type));
 }
 
 static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &struct_stats = (StructStatistics &)*child_stats[0];
+
 	auto &info = (StructExtractBindData &)*bind_data;
-	if (info.index >= struct_stats.child_stats.size() || !struct_stats.child_stats[info.index]) {
-		return nullptr;
-	}
-	return struct_stats.child_stats[info.index]->Copy();
+	auto struct_child_stats = StructStats::GetChildStats(child_stats[0]);
+	return struct_child_stats[info.index].ToUnique();
 }
 
 ScalarFunction StructExtractFun::GetFunction() {

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

@@ -3,7 +3,7 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
@@ -74,29 +74,26 @@ static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarF
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(std::move(new_struct_children));
+	bound_function.return_type = LogicalType::STRUCT(new_struct_children);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
 unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	if (child_stats.empty() || !child_stats[0]) {
-		return nullptr;
-	}
-	auto &existing_struct_stats = (StructStatistics &)*child_stats[0];
-	auto new_struct_stats = make_unique<StructStatistics>(expr.return_type);
+	auto new_struct_stats = StructStats::CreateUnknown(expr.return_type);
 
-	for (idx_t i = 0; i < existing_struct_stats.child_stats.size(); i++) {
-		new_struct_stats->child_stats[i] =
-		    existing_struct_stats.child_stats[i] ? existing_struct_stats.child_stats[i]->Copy() : nullptr;
+	auto existing_count = StructType::GetChildCount(child_stats[0].GetType());
+	auto existing_stats = StructStats::GetChildStats(child_stats[0]);
+	for (idx_t i = 0; i < existing_count; i++) {
+		StructStats::SetChildStats(new_struct_stats, i, existing_stats[i]);
 	}
-
-	auto offset = new_struct_stats->child_stats.size() - child_stats.size();
+	auto new_count = StructType::GetChildCount(expr.return_type);
+	auto offset = new_count - child_stats.size();
 	for (idx_t i = 1; i < child_stats.size(); i++) {
-		new_struct_stats->child_stats[offset + i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+		StructStats::SetChildStats(new_struct_stats, offset + i, child_stats[i]);
 	}
-	return std::move(new_struct_stats);
+	return new_struct_stats.ToUnique();
 }
 
 void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -3,7 +3,7 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
@@ -54,19 +54,18 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
+	bound_function.return_type = LogicalType::STRUCT(struct_children);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
 unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	auto struct_stats = make_unique<StructStatistics>(expr.return_type);
-	D_ASSERT(child_stats.size() == struct_stats->child_stats.size());
-	for (idx_t i = 0; i < struct_stats->child_stats.size(); i++) {
-		struct_stats->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
+	for (idx_t i = 0; i < child_stats.size(); i++) {
+		StructStats::SetChildStats(struct_stats, i, child_stats[i]);
 	}
-	return std::move(struct_stats);
+	return struct_stats.ToUnique();
 }
 
 void StructPackFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -101,6 +101,9 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 	} else if (format == "tiM") {
 		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
 		return LogicalType::INTERVAL;
+	} else if (format == "tin") {
+		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTH_DAY_NANO);
+		return LogicalType::INTERVAL;
 	} else if (format == "+l") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
@@ -114,14 +117,14 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		idx_t fixed_size = std::stoi(parameters);
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(std::move(child_type));
+		return LogicalType::LIST(child_type);
 	} else if (format == "+s") {
 		child_list_t<LogicalType> child_types;
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			auto child_type = GetArrowLogicalType(*schema.children[type_idx], arrow_convert_data, col_idx);
 			child_types.push_back({schema.children[type_idx]->name, child_type});
 		}
-		return LogicalType::STRUCT(std::move(child_types));
+		return LogicalType::STRUCT(child_types);
 
 	} else if (format == "+m") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);