duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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();
 }
@@ -27,93 +32,20 @@ RegexpBaseBindData::~RegexpBaseBindData() {
 }
 
 bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (RegexpBaseBindData &)other_p;
+	auto &other = other_p.Cast<RegexpBaseBindData>();
 	return constant_pattern == other.constant_pattern && constant_string == other.constant_string &&
 	       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;
+	auto &info = bind_data->Cast<RegexpBaseBindData>();
 	if (info.constant_pattern) {
-		return make_unique<RegexLocalState>(info);
+		return make_uniq<RegexLocalState>(info);
 	}
 	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
 //===--------------------------------------------------------------------===//
@@ -121,7 +53,7 @@ RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, s
                                              bool constant_pattern)
     : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern) {
 	if (constant_pattern) {
-		auto pattern = make_unique<RE2>(constant_string, options);
+		auto pattern = make_uniq<RE2>(constant_string, options);
 		if (!pattern->ok()) {
 			throw Exception(pattern->error());
 		}
@@ -140,8 +72,8 @@ RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, s
 }
 
 unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
-	return make_unique<RegexpMatchesBindData>(options, constant_string, constant_pattern, range_min, range_max,
-	                                          range_success);
+	return make_uniq<RegexpMatchesBindData>(options, constant_string, constant_pattern, range_min, range_max,
+	                                        range_success);
 }
 
 unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
@@ -157,7 +89,7 @@ unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunctio
 	string constant_string;
 	bool constant_pattern;
 	constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
-	return make_unique<RegexpMatchesBindData>(options, std::move(constant_string), constant_pattern);
+	return make_uniq<RegexpMatchesBindData>(options, std::move(constant_string), constant_pattern);
 }
 
 struct RegexPartialMatch {
@@ -177,11 +109,11 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
 
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
 
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
 			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
 		});
@@ -209,7 +141,7 @@ RegexpReplaceBindData::RegexpReplaceBindData(duckdb_re2::RE2::Options options, s
 }
 
 unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
-	auto copy = make_unique<RegexpReplaceBindData>(options, constant_string, constant_pattern, global_replace);
+	auto copy = make_uniq<RegexpReplaceBindData>(options, constant_string, constant_pattern, global_replace);
 	return std::move(copy);
 }
 
@@ -220,7 +152,7 @@ bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
 
 static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
-	auto data = make_unique<RegexpReplaceBindData>();
+	auto data = make_uniq<RegexpReplaceBindData>();
 
 	data->constant_pattern = TryParseConstantPattern(context, *arguments[1], data->constant_string);
 	if (arguments.size() == 4) {
@@ -231,15 +163,15 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 }
 
 static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpReplaceBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpReplaceBindData>();
 
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
 	auto &replaces = args.data[2];
 
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		BinaryExecutor::Execute<string_t, string_t, string_t>(
 		    strings, replaces, result, args.size(), [&](string_t input, string_t replace) {
 			    std::string sstring = input.GetString();
@@ -278,7 +210,7 @@ RegexpExtractBindData::RegexpExtractBindData(duckdb_re2::RE2::Options options, s
 }
 
 unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
-	return make_unique<RegexpExtractBindData>(options, constant_string, constant_pattern, group_string);
+	return make_uniq<RegexpExtractBindData>(options, constant_string, constant_pattern, group_string);
 }
 
 bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
@@ -286,6 +218,103 @@ bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
 	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
 }
 
+static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = func_expr.bind_info->Cast<RegexpExtractBindData>();
+
+	auto &strings = args.data[0];
+	auto &patterns = args.data[1];
+	if (info.constant_pattern) {
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
+		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
+			return Extract(input, result, lstate.constant_pattern, info.rewrite);
+		});
+	} else {
+		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
+		                                                      [&](string_t input, string_t pattern) {
+			                                                      RE2 re(CreateStringPiece(pattern), info.options);
+			                                                      return Extract(input, result, re, info.rewrite);
+		                                                      });
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Regexp Extract Struct
+//===--------------------------------------------------------------------===//
+static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
+
+	const auto count = args.size();
+	auto &input = args.data[0];
+
+	auto &child_entries = StructVector::GetEntries(result);
+	const auto groupSize = child_entries.size();
+	// Reference the 'input' StringBuffer, because we won't need to allocate new data
+	// for the result, all returned strings are substrings of the originals
+	for (auto &child_entry : child_entries) {
+		child_entry->SetAuxiliary(input.GetAuxiliary());
+	}
+
+	vector<RE2::Arg> argv(groupSize);
+	vector<RE2::Arg *> groups(groupSize);
+	vector<duckdb_re2::StringPiece> ws(groupSize);
+	for (size_t i = 0; i < groupSize; ++i) {
+		groups[i] = &argv[i];
+		argv[i] = &ws[i];
+	}
+
+	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+
+		if (ConstantVector::IsNull(input)) {
+			ConstantVector::SetNull(result, true);
+		} else {
+			ConstantVector::SetNull(result, false);
+			auto idata = ConstantVector::GetData<string_t>(input);
+			auto str = CreateStringPiece(idata[0]);
+			auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+			for (size_t col = 0; col < child_entries.size(); ++col) {
+				auto &child_entry = child_entries[col];
+				ConstantVector::SetNull(*child_entry, false);
+				auto &extracted = ws[col];
+				auto cdata = ConstantVector::GetData<string_t>(*child_entry);
+				cdata[0] = string_t(extracted.data(), match ? extracted.size() : 0);
+			}
+		}
+	} else {
+		UnifiedVectorFormat iunified;
+		input.ToUnifiedFormat(count, iunified);
+
+		const auto &ivalidity = iunified.validity;
+		auto idata = (const string_t *)iunified.data;
+
+		// Start with a valid flat vector
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+
+		// Start with valid children
+		for (size_t col = 0; col < child_entries.size(); ++col) {
+			auto &child_entry = child_entries[col];
+			child_entry->SetVectorType(VectorType::FLAT_VECTOR);
+		}
+
+		for (idx_t i = 0; i < count; ++i) {
+			const auto idx = iunified.sel->get_index(i);
+			if (ivalidity.RowIsValid(idx)) {
+				auto str = CreateStringPiece(idata[idx]);
+				auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+				for (size_t col = 0; col < child_entries.size(); ++col) {
+					auto &child_entry = child_entries[col];
+					auto cdata = FlatVector::GetData<string_t>(*child_entry);
+					auto &extracted = ws[col];
+					cdata[i] = string_t(extracted.data(), match ? extracted.size() : 0);
+				}
+			} else {
+				FlatVector::SetNull(result, i, true);
+			}
+		}
+	}
+}
+
 static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() >= 2);
@@ -295,57 +324,60 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	string constant_string;
 	bool constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
 
-	string group_string = "";
+	if (arguments.size() >= 4) {
+		ParseRegexOptions(context, *arguments[3], options);
+	}
+
+	string group_string = "\\0";
 	if (arguments.size() >= 3) {
 		if (arguments[2]->HasParameter()) {
 			throw ParameterNotResolvedException();
 		}
 		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Group index field field must be a constant!");
+			throw InvalidInputException("Group specification field must be a constant!");
 		}
 		Value group = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
-		if (!group.IsNull()) {
+		if (group.IsNull()) {
+			group_string = "";
+		} else if (group.type().id() == LogicalTypeId::LIST) {
+			if (!constant_pattern) {
+				throw BinderException("%s with LIST requires a constant pattern", bound_function.name);
+			}
+			auto &list_children = ListValue::GetChildren(group);
+			if (list_children.empty()) {
+				throw BinderException("%s requires non-empty lists of capture names", bound_function.name);
+			}
+			case_insensitive_set_t name_collision_set;
+			child_list_t<LogicalType> struct_children;
+			for (const auto &child : list_children) {
+				if (child.IsNull()) {
+					throw BinderException("NULL group name in %s", bound_function.name);
+				}
+				const auto group_name = child.ToString();
+				if (name_collision_set.find(group_name) != name_collision_set.end()) {
+					throw BinderException("Duplicate group name \"%s\" in %s", group_name, bound_function.name);
+				}
+				name_collision_set.insert(group_name);
+				struct_children.emplace_back(make_pair(group_name, LogicalType::VARCHAR));
+			}
+			bound_function.return_type = LogicalType::STRUCT(struct_children);
+
+			duckdb_re2::StringPiece constant_piece(constant_string.c_str(), constant_string.size());
+			RE2 constant_pattern(constant_piece, options);
+			if (size_t(constant_pattern.NumberOfCapturingGroups()) < list_children.size()) {
+				throw BinderException("Not enough group names in %s", bound_function.name);
+			}
+		} else {
 			auto group_idx = group.GetValue<int32_t>();
 			if (group_idx < 0 || group_idx > 9) {
 				throw InvalidInputException("Group index must be between 0 and 9!");
 			}
 			group_string = "\\" + to_string(group_idx);
 		}
-	} else {
-		group_string = "\\0";
 	}
-	if (arguments.size() >= 4) {
-		ParseRegexOptions(context, *arguments[3], options);
-	}
-	return make_unique<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
-	                                          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;
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
-			return Extract(input, result, lstate.constant_pattern, info.rewrite);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
-		                                                      [&](string_t input, string_t pattern) {
-			                                                      RE2 re(CreateStringPiece(pattern), info.options);
-			                                                      return Extract(input, result, re, info.rewrite);
-		                                                      });
-	}
+	return make_uniq<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
+	                                        std::move(group_string));
 }
 
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
@@ -390,11 +422,37 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...])
+	regexp_extract.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
+	    RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
+	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...], <options>)
+	regexp_extract.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR), LogicalType::VARCHAR},
+	    LogicalType::VARCHAR, RegexExtractStructFunction, 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/string_split.cpp

@@ -159,11 +159,11 @@ static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
 	if (info.constant_pattern) {
 		// fast path: pre-compiled regex
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		StringSplitExecutor<ConstantRegexpStringSplit>(args, state, result, &lstate.constant_pattern);
 	} else {
 		// slow path: have to re-compile regex for every row

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

@@ -39,12 +39,14 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<CHR>();
 	Register<MismatchesFun>();
 	Register<LevenshteinFun>();
+	Register<DamerauLevenshteinFun>();
 	Register<JaccardFun>();
 	Register<JaroWinklerFun>();
 
 	// blob functions
 	Register<Base64Fun>();
 	Register<EncodeFun>();
+	Register<HexFun>();
 
 	// bit functions
 	Register<GetBitFun>();

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 {
 
@@ -18,7 +18,7 @@ struct StructExtractBindData : public FunctionData {
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StructExtractBindData>(key, index, type);
+		return make_uniq<StructExtractBindData>(key, index, type);
 	}
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = (const StructExtractBindData &)other_p;
@@ -27,8 +27,8 @@ public:
 };
 
 static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StructExtractBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StructExtractBindData>();
 
 	// this should be guaranteed by the binder
 	auto &vec = args.data[0];
@@ -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_uniq<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 &info = bind_data->Cast<StructExtractBindData>();
+	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));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
+	bound_function.return_type = LogicalType::STRUCT(new_struct_children);
+	return make_uniq<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,15 +3,15 @@
 #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 {
 
 static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 #ifdef DEBUG
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (VariableReturnBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<VariableReturnBindData>();
 	// this should never happen if the binder below is sane
 	D_ASSERT(args.ColumnCount() == StructType::GetChildTypes(info.stype).size());
 #endif
@@ -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));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
+	bound_function.return_type = LogicalType::STRUCT(struct_children);
+	return make_uniq<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) {