duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/common/exception.cpp

@@ -2,6 +2,9 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/exception/list.hpp"
+#include "duckdb/parser/tableref.hpp"
+#include "duckdb/planner/expression.hpp"
 
 #ifdef DUCKDB_CRASH_ON_ASSERT
 #include "duckdb/common/printer.hpp"
@@ -14,21 +17,28 @@
 
 namespace duckdb {
 
-Exception::Exception(const string &msg) : std::exception(), type(ExceptionType::INVALID), raw_message_(msg) {
-	exception_message_ = msg;
+Exception::Exception(ExceptionType exception_type, const string &message)
+    : std::runtime_error(ToJSON(exception_type, message)) {
 }
 
-Exception::Exception(ExceptionType exception_type, const string &message)
-    : std::exception(), type(exception_type), raw_message_(message) {
-	exception_message_ = ExceptionTypeToString(exception_type) + " Error: " + message;
+Exception::Exception(ExceptionType exception_type, const string &message,
+                     const unordered_map<string, string> &extra_info)
+    : std::runtime_error(ToJSON(exception_type, message, extra_info)) {
 }
 
-const char *Exception::what() const noexcept {
-	return exception_message_.c_str();
+string Exception::ToJSON(ExceptionType type, const string &message) {
+	unordered_map<string, string> extra_info;
+	return ToJSON(type, message, extra_info);
 }
 
-const string &Exception::RawMessage() const {
-	return raw_message_;
+string Exception::ToJSON(ExceptionType type, const string &message, const unordered_map<string, string> &extra_info) {
+#ifdef DUCKDB_DEBUG_STACKTRACE
+	auto extended_extra_info = extra_info;
+	extended_extra_info["stack_trace"] = Exception::GetStackTrace();
+	return StringUtil::ToJSONMap(type, message, extended_extra_info);
+#else
+	return StringUtil::ToJSONMap(type, message, extra_info);
+#endif
 }
 
 bool Exception::UncaughtException() {
@@ -39,6 +49,30 @@ bool Exception::UncaughtException() {
 #endif
 }
 
+bool Exception::InvalidatesTransaction(ExceptionType exception_type) {
+	switch (exception_type) {
+	case ExceptionType::BINDER:
+	case ExceptionType::CATALOG:
+	case ExceptionType::CONNECTION:
+	case ExceptionType::PARAMETER_NOT_ALLOWED:
+	case ExceptionType::PARSER:
+	case ExceptionType::PERMISSION:
+		return false;
+	default:
+		return true;
+	}
+}
+
+bool Exception::InvalidatesDatabase(ExceptionType exception_type) {
+	switch (exception_type) {
+	case ExceptionType::INTERNAL:
+	case ExceptionType::FATAL:
+		return true;
+	default:
+		return false;
+	}
+}
+
 string Exception::GetStackTrace(int max_depth) {
 #ifdef DUCKDB_DEBUG_STACKTRACE
 	string result;
@@ -125,7 +159,8 @@ static constexpr ExceptionEntry EXCEPTION_MAP[] = {{ExceptionType::INVALID, "Inv
                                                    {ExceptionType::DEPENDENCY, "Dependency"},
                                                    {ExceptionType::MISSING_EXTENSION, "Missing Extension"},
                                                    {ExceptionType::HTTP, "HTTP"},
-                                                   {ExceptionType::AUTOLOAD, "Extension Autoloading"}};
+                                                   {ExceptionType::AUTOLOAD, "Extension Autoloading"},
+                                                   {ExceptionType::SEQUENCE, "Sequence"}};
 
 string Exception::ExceptionTypeToString(ExceptionType type) {
 	for (auto &e : EXCEPTION_MAP) {
@@ -145,121 +180,49 @@ ExceptionType Exception::StringToExceptionType(const string &type) {
 	return ExceptionType::INVALID;
 }
 
-const HTTPException &Exception::AsHTTPException() const {
-	D_ASSERT(type == ExceptionType::HTTP);
-	const auto &e = static_cast<const HTTPException *>(this);
-	D_ASSERT(e->GetStatusCode() != 0);
-	D_ASSERT(e->GetHeaders().size() > 0);
-	return *e;
-}
-
-void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message,
-                                       const std::shared_ptr<Exception> &original) {
-	switch (type) {
-	case ExceptionType::OUT_OF_RANGE:
-		throw OutOfRangeException(message);
-	case ExceptionType::CONVERSION:
-		throw ConversionException(message); // FIXME: make a separation between Conversion/Cast exception?
-	case ExceptionType::INVALID_TYPE:
-		throw InvalidTypeException(message);
-	case ExceptionType::MISMATCH_TYPE:
-		throw TypeMismatchException(message);
-	case ExceptionType::TRANSACTION:
-		throw TransactionException(message);
-	case ExceptionType::NOT_IMPLEMENTED:
-		throw NotImplementedException(message);
-	case ExceptionType::CATALOG:
-		throw CatalogException(message);
-	case ExceptionType::CONNECTION:
-		throw ConnectionException(message);
-	case ExceptionType::PARSER:
-		throw ParserException(message);
-	case ExceptionType::PERMISSION:
-		throw PermissionException(message);
-	case ExceptionType::SYNTAX:
-		throw SyntaxException(message);
-	case ExceptionType::CONSTRAINT:
-		throw ConstraintException(message);
-	case ExceptionType::BINDER:
-		throw BinderException(message);
-	case ExceptionType::IO:
-		throw IOException(message);
-	case ExceptionType::SERIALIZATION:
-		throw SerializationException(message);
-	case ExceptionType::INTERRUPT:
-		throw InterruptException();
-	case ExceptionType::INTERNAL:
-		throw InternalException(message);
-	case ExceptionType::INVALID_INPUT:
-		throw InvalidInputException(message);
-	case ExceptionType::OUT_OF_MEMORY:
-		throw OutOfMemoryException(message);
-	case ExceptionType::PARAMETER_NOT_ALLOWED:
-		throw ParameterNotAllowedException(message);
-	case ExceptionType::PARAMETER_NOT_RESOLVED:
-		throw ParameterNotResolvedException();
-	case ExceptionType::FATAL:
-		throw FatalException(message);
-	case ExceptionType::DEPENDENCY:
-		throw DependencyException(message);
-	case ExceptionType::HTTP: {
-		original->AsHTTPException().Throw();
-	}
-	case ExceptionType::MISSING_EXTENSION:
-		throw MissingExtensionException(message);
-	default:
-		throw Exception(type, message);
-	}
+unordered_map<string, string> Exception::InitializeExtraInfo(const Expression &expr) {
+	return InitializeExtraInfo(expr.query_location);
 }
 
-StandardException::StandardException(ExceptionType exception_type, const string &message)
-    : Exception(exception_type, message) {
-}
-
-CastException::CastException(const PhysicalType orig_type, const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + TypeIdToString(orig_type) + " can't be cast as " + TypeIdToString(new_type)) {
+unordered_map<string, string> Exception::InitializeExtraInfo(const ParsedExpression &expr) {
+	return InitializeExtraInfo(expr.query_location);
 }
 
-CastException::CastException(const LogicalType &orig_type, const LogicalType &new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + orig_type.ToString() + " can't be cast as " + new_type.ToString()) {
+unordered_map<string, string> Exception::InitializeExtraInfo(const QueryErrorContext &error_context) {
+	return InitializeExtraInfo(error_context.query_location);
 }
 
-CastException::CastException(const string &msg) : Exception(ExceptionType::CONVERSION, msg) {
+unordered_map<string, string> Exception::InitializeExtraInfo(const TableRef &ref) {
+	return InitializeExtraInfo(ref.query_location);
 }
 
-ValueOutOfRangeException::ValueOutOfRangeException(const int64_t value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " +
-                                               to_string((intmax_t)value) +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
+unordered_map<string, string> Exception::InitializeExtraInfo(optional_idx error_location) {
+	unordered_map<string, string> result;
+	SetQueryLocation(error_location, result);
+	return result;
 }
 
-ValueOutOfRangeException::ValueOutOfRangeException(const double value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " + to_string(value) +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
+unordered_map<string, string> Exception::InitializeExtraInfo(const string &subtype, optional_idx error_location) {
+	unordered_map<string, string> result;
+	result["error_subtype"] = subtype;
+	SetQueryLocation(error_location, result);
+	return result;
 }
 
-ValueOutOfRangeException::ValueOutOfRangeException(const hugeint_t value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " + value.ToString() +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
+void Exception::SetQueryLocation(optional_idx error_location, unordered_map<string, string> &extra_info) {
+	if (error_location.IsValid()) {
+		extra_info["position"] = to_string(error_location.GetIndex());
+	}
 }
 
-ValueOutOfRangeException::ValueOutOfRangeException(const PhysicalType var_type, const idx_t length)
-    : Exception(ExceptionType::OUT_OF_RANGE,
-                "The value is too long to fit into type " + TypeIdToString(var_type) + "(" + to_string(length) + ")") {
+ConversionException::ConversionException(const PhysicalType orig_type, const PhysicalType new_type)
+    : Exception(ExceptionType::CONVERSION,
+                "Type " + TypeIdToString(orig_type) + " can't be cast as " + TypeIdToString(new_type)) {
 }
 
-ValueOutOfRangeException::ValueOutOfRangeException(const string &msg) : Exception(ExceptionType::OUT_OF_RANGE, msg) {
+ConversionException::ConversionException(const LogicalType &orig_type, const LogicalType &new_type)
+    : Exception(ExceptionType::CONVERSION,
+                "Type " + orig_type.ToString() + " can't be cast as " + new_type.ToString()) {
 }
 
 ConversionException::ConversionException(const string &msg) : Exception(ExceptionType::CONVERSION, msg) {
@@ -298,16 +261,38 @@ NotImplementedException::NotImplementedException(const string &msg) : Exception(
 OutOfRangeException::OutOfRangeException(const string &msg) : Exception(ExceptionType::OUT_OF_RANGE, msg) {
 }
 
-CatalogException::CatalogException(const string &msg) : StandardException(ExceptionType::CATALOG, msg) {
+OutOfRangeException::OutOfRangeException(const int64_t value, const PhysicalType orig_type, const PhysicalType new_type)
+    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " +
+                                                 to_string((intmax_t)value) +
+                                                 " can't be cast because the value is out of range "
+                                                 "for the destination type " +
+                                                 TypeIdToString(new_type)) {
 }
 
-ConnectionException::ConnectionException(const string &msg) : StandardException(ExceptionType::CONNECTION, msg) {
+OutOfRangeException::OutOfRangeException(const double value, const PhysicalType orig_type, const PhysicalType new_type)
+    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " + to_string(value) +
+                                                 " can't be cast because the value is out of range "
+                                                 "for the destination type " +
+                                                 TypeIdToString(new_type)) {
 }
 
-ParserException::ParserException(const string &msg) : StandardException(ExceptionType::PARSER, msg) {
+OutOfRangeException::OutOfRangeException(const hugeint_t value, const PhysicalType orig_type,
+                                         const PhysicalType new_type)
+    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " + value.ToString() +
+                                                 " can't be cast because the value is out of range "
+                                                 "for the destination type " +
+                                                 TypeIdToString(new_type)) {
+}
+
+OutOfRangeException::OutOfRangeException(const PhysicalType var_type, const idx_t length)
+    : Exception(ExceptionType::OUT_OF_RANGE,
+                "The value is too long to fit into type " + TypeIdToString(var_type) + "(" + to_string(length) + ")") {
 }
 
-PermissionException::PermissionException(const string &msg) : StandardException(ExceptionType::PERMISSION, msg) {
+ConnectionException::ConnectionException(const string &msg) : Exception(ExceptionType::CONNECTION, msg) {
+}
+
+PermissionException::PermissionException(const string &msg) : Exception(ExceptionType::PERMISSION, msg) {
 }
 
 SyntaxException::SyntaxException(const string &msg) : Exception(ExceptionType::SYNTAX, msg) {
@@ -319,27 +304,27 @@ ConstraintException::ConstraintException(const string &msg) : Exception(Exceptio
 DependencyException::DependencyException(const string &msg) : Exception(ExceptionType::DEPENDENCY, msg) {
 }
 
-BinderException::BinderException(const string &msg) : StandardException(ExceptionType::BINDER, msg) {
+IOException::IOException(const string &msg) : Exception(ExceptionType::IO, msg) {
 }
 
-IOException::IOException(const string &msg) : Exception(ExceptionType::IO, msg) {
+IOException::IOException(const string &msg, const unordered_map<string, string> &extra_info)
+    : Exception(ExceptionType::IO, msg, extra_info) {
 }
 
 MissingExtensionException::MissingExtensionException(const string &msg)
     : Exception(ExceptionType::MISSING_EXTENSION, msg) {
 }
 
-AutoloadException::AutoloadException(const string &extension_name, Exception &e)
+AutoloadException::AutoloadException(const string &extension_name, const string &message)
     : Exception(ExceptionType::AUTOLOAD,
                 "An error occurred while trying to automatically install the required extension '" + extension_name +
-                    "':\n" + e.RawMessage()),
-      wrapped_exception(e) {
+                    "':\n" + message) {
 }
 
 SerializationException::SerializationException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
 }
 
-SequenceException::SequenceException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
+SequenceException::SequenceException(const string &msg) : Exception(ExceptionType::SEQUENCE, msg) {
 }
 
 InterruptException::InterruptException() : Exception(ExceptionType::INTERRUPT, "Interrupted!") {
@@ -348,7 +333,7 @@ InterruptException::InterruptException() : Exception(ExceptionType::INTERRUPT, "
 FatalException::FatalException(ExceptionType type, const string &msg) : Exception(type, msg) {
 }
 
-InternalException::InternalException(const string &msg) : FatalException(ExceptionType::INTERNAL, msg) {
+InternalException::InternalException(const string &msg) : Exception(ExceptionType::INTERNAL, msg) {
 #ifdef DUCKDB_CRASH_ON_ASSERT
 	Printer::Print("ABORT THROWN BY INTERNAL EXCEPTION: " + msg);
 	abort();
@@ -358,11 +343,15 @@ InternalException::InternalException(const string &msg) : FatalException(Excepti
 InvalidInputException::InvalidInputException(const string &msg) : Exception(ExceptionType::INVALID_INPUT, msg) {
 }
 
+InvalidInputException::InvalidInputException(const string &msg, const unordered_map<string, string> &extra_info)
+    : Exception(ExceptionType::INVALID_INPUT, msg, extra_info) {
+}
+
 OutOfMemoryException::OutOfMemoryException(const string &msg) : Exception(ExceptionType::OUT_OF_MEMORY, msg) {
 }
 
 ParameterNotAllowedException::ParameterNotAllowedException(const string &msg)
-    : StandardException(ExceptionType::PARAMETER_NOT_ALLOWED, msg) {
+    : Exception(ExceptionType::PARAMETER_NOT_ALLOWED, msg) {
 }
 
 ParameterNotResolvedException::ParameterNotResolvedException()

package/src/duckdb/src/common/exception_format_value.cpp

@@ -3,6 +3,7 @@
 #include "fmt/format.h"
 #include "fmt/printf.h"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
@@ -16,6 +17,9 @@ ExceptionFormatValue::ExceptionFormatValue(int64_t int_val)
 ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
 }
+ExceptionFormatValue::ExceptionFormatValue(uhugeint_t uhuge_val)
+    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Uhugeint::ToString(uhuge_val)) {
+}
 ExceptionFormatValue::ExceptionFormatValue(string str_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(std::move(str_val)) {
 }
@@ -66,6 +70,10 @@ template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
 	return ExceptionFormatValue(value);
 }
+template <>
+ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(uhugeint_t value) {
+	return ExceptionFormatValue(value);
+}
 
 string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionFormatValue> &values) {
 	try {
@@ -88,7 +96,7 @@ string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionForm
 	} catch (std::exception &ex) { // LCOV_EXCL_START
 		// work-around for oss-fuzz limiting memory which causes issues here
 		if (StringUtil::Contains(ex.what(), "fuzz mode")) {
-			throw Exception(msg);
+			throw InvalidInputException(msg);
 		}
 		throw InternalException(std::string("Primary exception: ") + msg +
 		                        "\nSecondary exception in ExceptionFormatValue: " + ex.what());

package/src/duckdb/src/common/extra_type_info.cpp

@@ -134,6 +134,11 @@ UserTypeInfo::UserTypeInfo(string name_p)
     : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) {
 }
 
+UserTypeInfo::UserTypeInfo(string catalog_p, string schema_p, string name_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
+      user_type_name(std::move(name_p)) {
+}
+
 bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<UserTypeInfo>();
 	return other.user_type_name == user_type_name;
@@ -312,4 +317,47 @@ void EnumTypeInfo::Serialize(Serializer &serializer) const {
 	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(strings[i]); });
 }
 
+//===--------------------------------------------------------------------===//
+// ArrayTypeInfo
+//===--------------------------------------------------------------------===//
+
+ArrayTypeInfo::ArrayTypeInfo(LogicalType child_type_p, idx_t size_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::ARRAY_TYPE_INFO), child_type(std::move(child_type_p)), size(size_p) {
+}
+
+bool ArrayTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
+	auto &other = other_p->Cast<ArrayTypeInfo>();
+	return child_type == other.child_type && size == other.size;
+}
+
+//===--------------------------------------------------------------------===//
+// Any Type Info
+//===--------------------------------------------------------------------===//
+AnyTypeInfo::AnyTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::ANY_TYPE_INFO) {
+}
+
+AnyTypeInfo::AnyTypeInfo(LogicalType target_type_p, idx_t cast_score_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::ANY_TYPE_INFO), target_type(std::move(target_type_p)), cast_score(cast_score_p) {
+}
+
+bool AnyTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
+	auto &other = other_p->Cast<AnyTypeInfo>();
+	return target_type == other.target_type && cast_score == other.cast_score;
+}
+
+//===--------------------------------------------------------------------===//
+// Any Type Info
+//===--------------------------------------------------------------------===//
+IntegerLiteralTypeInfo::IntegerLiteralTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO) {
+}
+
+IntegerLiteralTypeInfo::IntegerLiteralTypeInfo(Value constant_value_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO), constant_value(std::move(constant_value_p)) {
+}
+
+bool IntegerLiteralTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
+	auto &other = other_p->Cast<IntegerLiteralTypeInfo>();
+	return constant_value == other.constant_value;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/file_system.cpp

@@ -54,10 +54,7 @@ FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
 }
 
 bool PathMatched(const string &path, const string &sub_path) {
-	if (path.rfind(sub_path, 0) == 0) {
-		return true;
-	}
-	return false;
+	return path.rfind(sub_path, 0) == 0;
 }
 
 #ifndef _WIN32
@@ -147,7 +144,15 @@ bool FileSystem::IsPathAbsolute(const string &path) {
 	if (StartsWithSingleBackslash(path)) {
 		return true;
 	}
-	// 2) A disk designator with a backslash (e.g., C:\ or C:/)
+	// 2) special "long paths" on windows
+	if (PathMatched(path, "\\\\?\\")) {
+		return true;
+	}
+	// 3) a network path
+	if (PathMatched(path, "\\\\")) {
+		return true;
+	}
+	// 4) A disk designator with a backslash (e.g., C:\ or C:/)
 	auto path_aux = path;
 	path_aux.erase(0, 1);
 	if (PathMatched(path_aux, ":\\") || PathMatched(path_aux, ":/")) {
@@ -210,7 +215,7 @@ string FileSystem::GetWorkingDirectory() {
 
 string FileSystem::JoinPath(const string &a, const string &b) {
 	// FIXME: sanitize paths
-	return a + PathSeparator(a) + b;
+	return a.empty() ? b : a + PathSeparator(a) + b;
 }
 
 string FileSystem::ConvertSeparators(const string &path) {
@@ -539,7 +544,7 @@ FileType FileHandle::GetType() {
 }
 
 bool FileSystem::IsRemoteFile(const string &path) {
-	const string prefixes[] = {"http://", "https://", "s3://"};
+	const string prefixes[] = {"http://", "https://", "s3://", "s3a://", "s3n://", "gcs://", "gs://", "r2://"};
 	for (auto &prefix : prefixes) {
 		if (StringUtil::StartsWith(path, prefix)) {
 			return true;

package/src/duckdb/src/common/gzip_file_system.cpp

@@ -68,7 +68,7 @@ struct MiniZStreamWrapper : public StreamWrapper {
 	~MiniZStreamWrapper() override;
 
 	CompressedFile *file = nullptr;
-	duckdb_miniz::mz_stream *mz_stream_ptr = nullptr;
+	unique_ptr<duckdb_miniz::mz_stream> mz_stream_ptr;
 	bool writing = false;
 	duckdb_miniz::mz_ulong crc;
 	idx_t total_size;
@@ -98,8 +98,8 @@ MiniZStreamWrapper::~MiniZStreamWrapper() {
 void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 	Close();
 	this->file = &file;
-	mz_stream_ptr = new duckdb_miniz::mz_stream();
-	memset(mz_stream_ptr, 0, sizeof(duckdb_miniz::mz_stream));
+	mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
+	memset(mz_stream_ptr.get(), 0, sizeof(duckdb_miniz::mz_stream));
 	this->writing = write;
 
 	// TODO use custom alloc/free methods in miniz to throw exceptions on OOM
@@ -111,7 +111,7 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 		MiniZStream::InitializeGZIPHeader(gzip_hdr);
 		file.child_handle->Write(gzip_hdr, GZIP_HEADER_MINSIZE);
 
-		auto ret = mz_deflateInit2((duckdb_miniz::mz_streamp)mz_stream_ptr, duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED,
+		auto ret = mz_deflateInit2(mz_stream_ptr.get(), duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED,
 		                           -MZ_DEFAULT_WINDOW_BITS, 1, 0);
 		if (ret != duckdb_miniz::MZ_OK) {
 			throw InternalException("Failed to initialize miniz");
@@ -135,7 +135,7 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 		}
 		file.child_handle->Seek(data_start);
 		// stream is now set to beginning of payload data
-		auto ret = duckdb_miniz::mz_inflateInit2((duckdb_miniz::mz_streamp)mz_stream_ptr, -MZ_DEFAULT_WINDOW_BITS);
+		auto ret = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
 		if (ret != duckdb_miniz::MZ_OK) {
 			throw InternalException("Failed to initialize miniz");
 		}
@@ -182,8 +182,8 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 			Close();
 			return true;
 		}
-		duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
-		auto sta = duckdb_miniz::mz_inflateInit2((duckdb_miniz::mz_streamp)mz_stream_ptr, -MZ_DEFAULT_WINDOW_BITS);
+		duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
+		auto sta = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
 		if (sta != duckdb_miniz::MZ_OK) {
 			throw InternalException("Failed to initialize miniz");
 		}
@@ -195,7 +195,7 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 	mz_stream_ptr->avail_in = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
 	mz_stream_ptr->next_out = data_ptr_cast(sd.out_buff_end);
 	mz_stream_ptr->avail_out = (uint32_t)((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
-	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
+	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
 	if (ret != duckdb_miniz::MZ_OK && ret != duckdb_miniz::MZ_STREAM_END) {
 		throw IOException("Failed to decode gzip stream: %s", duckdb_miniz::mz_error(ret));
 	}
@@ -228,7 +228,7 @@ void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t
 		mz_stream_ptr->next_out = sd.out_buff_start;
 		mz_stream_ptr->avail_out = output_remaining;
 
-		auto res = mz_deflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
+		auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
 		if (res != duckdb_miniz::MZ_OK) {
 			D_ASSERT(res != duckdb_miniz::MZ_STREAM_END);
 			throw InternalException("Failed to compress GZIP block");
@@ -254,7 +254,7 @@ void MiniZStreamWrapper::FlushStream() {
 		mz_stream_ptr->next_out = sd.out_buff_start;
 		mz_stream_ptr->avail_out = output_remaining;
 
-		auto res = mz_deflate(mz_stream_ptr, duckdb_miniz::MZ_FINISH);
+		auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_FINISH);
 		sd.out_buff_start += (output_remaining - mz_stream_ptr->avail_out);
 		if (sd.out_buff_start > sd.out_buff.get()) {
 			file->child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
@@ -282,11 +282,10 @@ void MiniZStreamWrapper::Close() {
 		MiniZStream::InitializeGZIPFooter(gzip_footer, crc, total_size);
 		file->child_handle->Write(gzip_footer, MiniZStream::GZIP_FOOTER_SIZE);
 
-		duckdb_miniz::mz_deflateEnd(mz_stream_ptr);
+		duckdb_miniz::mz_deflateEnd(mz_stream_ptr.get());
 	} else {
-		duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
+		duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
 	}
-	delete mz_stream_ptr;
 	mz_stream_ptr = nullptr;
 	file = nullptr;
 }
@@ -321,8 +320,8 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 	// decompress file
 	auto body_ptr = in.data();
 
-	auto mz_stream_ptr = new duckdb_miniz::mz_stream();
-	memset(mz_stream_ptr, 0, sizeof(duckdb_miniz::mz_stream));
+	auto mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
+	memset(mz_stream_ptr.get(), 0, sizeof(duckdb_miniz::mz_stream));
 
 	uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
 
@@ -349,7 +348,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 	}
 
 	// stream is now set to beginning of payload data
-	auto status = duckdb_miniz::mz_inflateInit2(mz_stream_ptr, -MZ_DEFAULT_WINDOW_BITS);
+	auto status = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
 	if (status != duckdb_miniz::MZ_OK) {
 		throw InternalException("Failed to initialize miniz");
 	}
@@ -364,13 +363,14 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 	while (status == duckdb_miniz::MZ_OK) {
 		mz_stream_ptr->next_out = decompress_buffer;
 		mz_stream_ptr->avail_out = sizeof(decompress_buffer);
-		status = mz_inflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
+		status = mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
 		if (status != duckdb_miniz::MZ_STREAM_END && status != duckdb_miniz::MZ_OK) {
 			throw IOException("Failed to uncompress");
 		}
 		decompressed.append(char_ptr_cast(decompress_buffer), mz_stream_ptr->total_out - decompressed.size());
 	}
-	duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
+	duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
+
 	if (decompressed.empty()) {
 		throw IOException("Failed to uncompress");
 	}

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/hive_partitioning.hpp"
 
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/filter_combiner.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
@@ -65,7 +66,7 @@ static void ConvertKnownColRefToConstants(unique_ptr<Expression> &expr,
 //  - http(s)://domain(:port)/lala/kasdl/var1=value1/?not-a-var=not-a-value
 //  - folder/folder/folder/../var1=value1/etc/.//var2=value2
 const string &HivePartitioning::RegexString() {
-	static string REGEX = "[\\/\\\\]([^\\/\\?\\\\]+)=([^\\/\\n\\?\\\\]+)";
+	static string REGEX = "[\\/\\\\]([^\\/\\?\\\\]+)=([^\\/\\n\\?\\\\]*)";
 	return REGEX;
 }
 
@@ -261,6 +262,9 @@ static void GetHivePartitionValuesTypeSwitch(Vector &input, vector<HivePartition
 	case PhysicalType::UINT64:
 		TemplatedGetHivePartitionValues<uint64_t>(input, keys, col_idx, count);
 		break;
+	case PhysicalType::UINT128:
+		TemplatedGetHivePartitionValues<uhugeint_t>(input, keys, col_idx, count);
+		break;
 	case PhysicalType::FLOAT:
 		TemplatedGetHivePartitionValues<float>(input, keys, col_idx, count);
 		break;