duckdb 0.7.2-dev1734.0 → 0.7.2-dev1867.0

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

@@ -1,3 +1,4 @@
+#include "duckdb/common/bit_utils.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/blob.hpp"
@@ -7,6 +8,58 @@
 
 namespace duckdb {
 
+static void WriteHexBytes(uint64_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size * 4;
+
+	for (; offset >= 4; offset -= 4) {
+		uint8_t byte = (x >> (offset - 4)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+}
+
+static void WriteHugeIntHexBytes(hugeint_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size * 4;
+	auto upper = x.upper;
+	auto lower = x.lower;
+
+	for (; offset >= 68; offset -= 4) {
+		uint8_t byte = (upper >> (offset - 68)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+
+	for (; offset >= 4; offset -= 4) {
+		uint8_t byte = (lower >> (offset - 4)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+}
+
+static void WriteBinBytes(uint64_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size;
+	for (; offset >= 1; offset -= 1) {
+		*output = ((x >> (offset - 1)) & 0x01) + '0';
+		output++;
+	}
+}
+
+static void WriteHugeIntBinBytes(hugeint_t x, char *&output, idx_t buffer_size) {
+	auto upper = x.upper;
+	auto lower = x.lower;
+	idx_t offset = buffer_size;
+
+	for (; offset >= 65; offset -= 1) {
+		*output = ((upper >> (offset - 65)) & 0x01) + '0';
+		output++;
+	}
+
+	for (; offset >= 1; offset -= 1) {
+		*output = ((lower >> (offset - 1)) & 0x01) + '0';
+		output++;
+	}
+}
+
 struct HexStrOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -29,6 +82,149 @@ struct HexStrOperator {
 	}
 };
 
+struct HexIntegralOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		idx_t num_bits_to_check = 64 - num_leading_zero;
+		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
+
+		idx_t buffer_size = (num_bits_to_check + 3) / 4;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHexBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct HexHugeIntOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHugeIntHexBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+template <class INPUT, class OP>
+static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 1);
+	auto &input = args.data[0];
+	idx_t count = args.size();
+	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
+}
+
+struct BinaryStrOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		auto data = input.GetDataUnsafe();
+		auto size = input.GetSize();
+
+		// Allocate empty space
+		auto target = StringVector::EmptyString(result, size * 8);
+		auto output = target.GetDataWriteable();
+
+		for (idx_t i = 0; i < size; ++i) {
+			uint8_t byte = data[i];
+			for (idx_t i = 8; i >= 1; --i) {
+				*output = ((byte >> (i - 1)) & 0x01) + '0';
+				output++;
+			}
+		}
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct BinaryIntegralOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		idx_t num_bits_to_check = 64 - num_leading_zero;
+		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
+
+		idx_t buffer_size = num_bits_to_check;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteBinBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct BinaryHugeIntOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHugeIntBinBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
 struct FromHexOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -66,103 +262,65 @@ struct FromHexOperator {
 	}
 };
 
-struct HexIntegralOperator {
+struct FromBinaryOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		// Sufficient space for maximum length
-		char buffer[sizeof(INPUT_TYPE) * 2];
-		char *ptr = buffer;
-		idx_t buffer_size = 0;
-
-		bool seen_non_zero = false;
-		for (idx_t offset = sizeof(INPUT_TYPE) * 8; offset >= 4; offset -= 4) {
-			uint8_t byte = (input >> (offset - 4)) & 0x0F;
-			if (byte == 0 && !seen_non_zero && offset > 4) {
-				continue;
-			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+		auto data = input.GetDataUnsafe();
+		auto size = input.GetSize();
+
+		if (size > NumericLimits<uint32_t>::Maximum()) {
+			throw InvalidInputException("Binary input length larger than 2^32 are not supported");
 		}
 
+		D_ASSERT(size <= NumericLimits<uint32_t>::Maximum());
+		auto buffer_size = (size + 7) / 8;
+
 		// Allocate empty space
 		auto target = StringVector::EmptyString(result, buffer_size);
 		auto output = target.GetDataWriteable();
-		memcpy(output, buffer, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
 
-struct HexHugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		char buffer[sizeof(INPUT_TYPE) * 2];
-		char *ptr = buffer;
-		idx_t buffer_size = 0;
-
-		uint64_t lower = input.lower;
-		int64_t upper = input.upper;
-
-		bool seen_non_zero = false;
-		for (idx_t offset = 64; offset >= 4; offset -= 4) {
-			uint8_t byte = (upper >> (offset - 4)) & 0x0F;
-
-			if (byte == 0 && !seen_non_zero) {
-				continue;
+		// Treated as a single byte
+		idx_t i = 0;
+		if (size % 8 != 0) {
+			uint8_t byte = 0;
+			for (idx_t j = size % 8; j > 0; --j) {
+				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
+				i++;
 			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+			*output = byte;
+			output++;
 		}
 
-		for (idx_t offset = 64; offset >= 4; offset -= 4) {
-			uint8_t byte = (lower >> (offset - 4)) & 0x0F;
-
-			// at least one byte space
-			if (byte == 0 && !seen_non_zero && offset > 4) {
-				continue;
+		while (i < size) {
+			uint8_t byte = 0;
+			for (idx_t j = 8; j > 0; --j) {
+				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
+				i++;
 			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+			*output = byte;
+			output++;
 		}
 
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-		memcpy(output, buffer, buffer_size);
-
 		target.Finalize();
 		return target;
 	}
 };
 
-static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+template <class INPUT, class OP>
+static void ToBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	auto &input = args.data[0];
 	idx_t count = args.size();
+	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
+}
 
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::VARCHAR:
-		UnaryExecutor::ExecuteString<string_t, string_t, HexStrOperator>(input, result, count);
-		break;
-	case PhysicalType::INT64:
-		UnaryExecutor::ExecuteString<int64_t, string_t, HexIntegralOperator>(input, result, count);
-		break;
-	case PhysicalType::INT128:
-		UnaryExecutor::ExecuteString<hugeint_t, string_t, HexHugeIntOperator>(input, result, count);
-		break;
-	case PhysicalType::UINT64:
-		UnaryExecutor::ExecuteString<uint64_t, string_t, HexIntegralOperator>(input, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
+static void FromBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 1);
+	D_ASSERT(args.data[0].GetType().InternalType() == PhysicalType::VARCHAR);
+	auto &input = args.data[0];
+	idx_t count = args.size();
+
+	UnaryExecutor::ExecuteString<string_t, string_t, FromBinaryOperator>(input, result, count);
 }
 
 static void FromHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -178,13 +336,17 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet to_hex("to_hex");
 	ScalarFunctionSet from_hex("from_hex");
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction<int64_t, HexIntegralOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction<uint64_t, HexIntegralOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction<hugeint_t, HexHugeIntOperator>));
 
 	from_hex.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction));
 
@@ -196,6 +358,27 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 	from_hex.name = "unhex";
 	set.AddFunction(to_hex);
 	set.AddFunction(from_hex);
+
+	ScalarFunctionSet to_binary("to_binary");
+	ScalarFunctionSet from_binary("from_binary");
+	to_binary.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
+	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
+	                                     ToBinaryFunction<uint64_t, BinaryIntegralOperator>));
+	to_binary.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToBinaryFunction<int64_t, BinaryIntegralOperator>));
+	to_binary.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR,
+	                                     ToBinaryFunction<hugeint_t, BinaryHugeIntOperator>));
+
+	from_binary.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction));
+
+	set.AddFunction(to_binary);
+	set.AddFunction(from_binary);
+
+	to_binary.name = "bin";
+	from_binary.name = "unbin";
+	set.AddFunction(to_binary);
+	set.AddFunction(from_binary);
 }
 
 } // namespace duckdb

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

@@ -218,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);
@@ -227,52 +324,62 @@ 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_uniq<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
 	                                        std::move(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);
-		                                                      });
-	}
-}
-
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(ScalarFunction(
@@ -315,6 +422,16 @@ 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(

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

@@ -39,6 +39,7 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<CHR>();
 	Register<MismatchesFun>();
 	Register<LevenshteinFun>();
+	Register<DamerauLevenshteinFun>();
 	Register<JaccardFun>();
 	Register<JaroWinklerFun>();
 

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

@@ -8,10 +8,10 @@
 namespace duckdb {
 
 struct CheckpointBindData : public FunctionData {
-	explicit CheckpointBindData(AttachedDatabase *db) : db(db) {
+	explicit CheckpointBindData(optional_ptr<AttachedDatabase> db) : db(db) {
 	}
 
-	AttachedDatabase *db;
+	optional_ptr<AttachedDatabase> db;
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
@@ -29,7 +29,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	return_types.emplace_back(LogicalType::BOOLEAN);
 	names.emplace_back("Success");
 
-	AttachedDatabase *db;
+	optional_ptr<AttachedDatabase> db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
 		auto &db_name = StringValue::Get(input.inputs[0]);
@@ -46,7 +46,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 template <bool FORCE>
 static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<CheckpointBindData>();
-	auto &transaction_manager = TransactionManager::Get(*bind_data.db);
+	auto &transaction_manager = TransactionManager::Get(*bind_data.db.get_mutable());
 	transaction_manager.Checkpoint(context, FORCE);
 }