duckdb 1.3.2 → 1.3.3-dev4.0

package/src/duckdb/src/common/enums/expression_type.cpp

@@ -79,6 +79,8 @@ string ExpressionTypeToString(ExpressionType type) {
 		return "LAG";
 	case ExpressionType::WINDOW_NTILE:
 		return "NTILE";
+	case ExpressionType::WINDOW_FILL:
+		return "FILL";
 	case ExpressionType::FUNCTION:
 		return "FUNCTION";
 	case ExpressionType::CASE_EXPR:

package/src/duckdb/src/common/enums/logical_operator_type.cpp

@@ -70,6 +70,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "DELETE";
 	case LogicalOperatorType::LOGICAL_UPDATE:
 		return "UPDATE";
+	case LogicalOperatorType::LOGICAL_MERGE_INTO:
+		return "MERGE_INTO";
 	case LogicalOperatorType::LOGICAL_PREPARE:
 		return "PREPARE";
 	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:

package/src/duckdb/src/common/enums/metric_type.cpp

@@ -40,6 +40,7 @@ profiler_settings_t MetricsUtils::GetOptimizerMetrics() {
         MetricsType::OPTIMIZER_MATERIALIZED_CTE,
         MetricsType::OPTIMIZER_SUM_REWRITER,
         MetricsType::OPTIMIZER_LATE_MATERIALIZATION,
+        MetricsType::OPTIMIZER_CTE_INLINING,
     };
 }
 
@@ -112,6 +113,8 @@ MetricsType MetricsUtils::GetOptimizerMetricByType(OptimizerType type) {
             return MetricsType::OPTIMIZER_SUM_REWRITER;
         case OptimizerType::LATE_MATERIALIZATION:
             return MetricsType::OPTIMIZER_LATE_MATERIALIZATION;
+        case OptimizerType::CTE_INLINING:
+            return MetricsType::OPTIMIZER_CTE_INLINING;
        default:
             throw InternalException("OptimizerType %s cannot be converted to a MetricsType", EnumUtil::ToString(type));
     };
@@ -173,6 +176,8 @@ OptimizerType MetricsUtils::GetOptimizerTypeByMetric(MetricsType type) {
             return OptimizerType::SUM_REWRITER;
         case MetricsType::OPTIMIZER_LATE_MATERIALIZATION:
             return OptimizerType::LATE_MATERIALIZATION;
+        case MetricsType::OPTIMIZER_CTE_INLINING:
+            return OptimizerType::CTE_INLINING;
     default:
             return OptimizerType::INVALID;
     };
@@ -207,6 +212,7 @@ bool MetricsUtils::IsOptimizerMetric(MetricsType type) {
         case MetricsType::OPTIMIZER_MATERIALIZED_CTE:
         case MetricsType::OPTIMIZER_SUM_REWRITER:
         case MetricsType::OPTIMIZER_LATE_MATERIALIZATION:
+        case MetricsType::OPTIMIZER_CTE_INLINING:
             return true;
         default:
             return false;

package/src/duckdb/src/common/enums/optimizer_type.cpp

@@ -39,6 +39,7 @@ static const DefaultOptimizerType internal_optimizer_types[] = {
     {"materialized_cte", OptimizerType::MATERIALIZED_CTE},
     {"sum_rewriter", OptimizerType::SUM_REWRITER},
     {"late_materialization", OptimizerType::LATE_MATERIALIZATION},
+    {"cte_inlining", OptimizerType::CTE_INLINING},
     {nullptr, OptimizerType::INVALID}};
 
 string OptimizerTypeToString(OptimizerType type) {

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -83,6 +83,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "DELETE";
 	case PhysicalOperatorType::UPDATE:
 		return "UPDATE";
+	case PhysicalOperatorType::MERGE_INTO:
+		return "MERGE_INTO";
 	case PhysicalOperatorType::EMPTY_RESULT:
 		return "EMPTY_RESULT";
 	case PhysicalOperatorType::CREATE_TABLE:

package/src/duckdb/src/common/enums/statement_type.cpp

@@ -65,6 +65,8 @@ string StatementTypeToString(StatementType type) {
 		return "MULTI";
 	case StatementType::UPDATE_EXTENSIONS_STATEMENT:
 		return "UPDATE_EXTENSIONS";
+	case StatementType::MERGE_INTO_STATEMENT:
+		return "MERGE_INTO";
 	case StatementType::INVALID_STATEMENT:
 		break;
 	}

package/src/duckdb/src/common/error_data.cpp

@@ -91,6 +91,17 @@ const ExceptionType &ErrorData::Type() const {
 	return this->type;
 }
 
+void ErrorData::Merge(const ErrorData &other) {
+	if (!other.HasError()) {
+		return;
+	}
+	if (!HasError()) {
+		*this = other;
+		return;
+	}
+	final_message += "\n\n" + other.Message();
+}
+
 bool ErrorData::operator==(const ErrorData &other) const {
 	if (initialized != other.initialized) {
 		return false;

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

@@ -6,6 +6,7 @@
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
+#include "duckdb/common/types/string.hpp"
 
 namespace duckdb {
 
@@ -15,6 +16,9 @@ ExceptionFormatValue::ExceptionFormatValue(double dbl_val)
 ExceptionFormatValue::ExceptionFormatValue(int64_t int_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(int_val) {
 }
+ExceptionFormatValue::ExceptionFormatValue(idx_t uint_val)
+    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(Hugeint::Convert(uint_val)) {
+}
 ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
 }
@@ -24,6 +28,9 @@ ExceptionFormatValue::ExceptionFormatValue(uhugeint_t uhuge_val)
 ExceptionFormatValue::ExceptionFormatValue(string str_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(std::move(str_val)) {
 }
+ExceptionFormatValue::ExceptionFormatValue(String str_val)
+    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(str_val.ToStdString()) {
+}
 
 template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value) {
@@ -46,7 +53,10 @@ template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value) {
 	return ExceptionFormatValue(std::move(value));
 }
-
+template <>
+ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(String value) {
+	return ExceptionFormatValue(std::move(value));
+}
 template <>
 ExceptionFormatValue
 ExceptionFormatValue::CreateFormatValue(SQLString value) { // NOLINT: templating requires us to copy value here
@@ -68,6 +78,10 @@ ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value) {
 	return ExceptionFormatValue(string(value));
 }
 template <>
+ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(idx_t value) {
+	return ExceptionFormatValue(value);
+}
+template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
 	return ExceptionFormatValue(value);
 }

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

@@ -103,6 +103,10 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Copy() const {
 	return shared_ptr<ExtraTypeInfo>(new ExtraTypeInfo(*this));
 }
 
+shared_ptr<ExtraTypeInfo> ExtraTypeInfo::DeepCopy() const {
+	return Copy();
+}
+
 bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
 	if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO ||
 	    type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
@@ -202,6 +206,10 @@ shared_ptr<ExtraTypeInfo> ListTypeInfo::Copy() const {
 	return make_shared_ptr<ListTypeInfo>(*this);
 }
 
+shared_ptr<ExtraTypeInfo> ListTypeInfo::DeepCopy() const {
+	return make_shared_ptr<ListTypeInfo>(child_type.DeepCopy());
+}
+
 //===--------------------------------------------------------------------===//
 // Struct Type Info
 //===--------------------------------------------------------------------===//
@@ -221,6 +229,14 @@ shared_ptr<ExtraTypeInfo> StructTypeInfo::Copy() const {
 	return make_shared_ptr<StructTypeInfo>(*this);
 }
 
+shared_ptr<ExtraTypeInfo> StructTypeInfo::DeepCopy() const {
+	child_list_t<LogicalType> copied_child_types;
+	for (const auto &child_type : child_types) {
+		copied_child_types.emplace_back(child_type.first, child_type.second.DeepCopy());
+	}
+	return make_shared_ptr<StructTypeInfo>(std::move(copied_child_types));
+}
+
 //===--------------------------------------------------------------------===//
 // Aggregate State Type Info
 //===--------------------------------------------------------------------===//
@@ -423,6 +439,10 @@ shared_ptr<ExtraTypeInfo> ArrayTypeInfo::Copy() const {
 	return make_shared_ptr<ArrayTypeInfo>(*this);
 }
 
+shared_ptr<ExtraTypeInfo> ArrayTypeInfo::DeepCopy() const {
+	return make_shared_ptr<ArrayTypeInfo>(child_type.DeepCopy(), size);
+}
+
 //===--------------------------------------------------------------------===//
 // Any Type Info
 //===--------------------------------------------------------------------===//
@@ -442,6 +462,10 @@ shared_ptr<ExtraTypeInfo> AnyTypeInfo::Copy() const {
 	return make_shared_ptr<AnyTypeInfo>(*this);
 }
 
+shared_ptr<ExtraTypeInfo> AnyTypeInfo::DeepCopy() const {
+	return make_shared_ptr<AnyTypeInfo>(target_type.DeepCopy(), cast_score);
+}
+
 //===--------------------------------------------------------------------===//
 // Integer Literal Type Info
 //===--------------------------------------------------------------------===//
@@ -464,4 +488,23 @@ shared_ptr<ExtraTypeInfo> IntegerLiteralTypeInfo::Copy() const {
 	return make_shared_ptr<IntegerLiteralTypeInfo>(*this);
 }
 
+//===--------------------------------------------------------------------===//
+// Template Type Info
+//===--------------------------------------------------------------------===//
+TemplateTypeInfo::TemplateTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::TEMPLATE_TYPE_INFO) {
+}
+
+TemplateTypeInfo::TemplateTypeInfo(string name_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::TEMPLATE_TYPE_INFO), name(std::move(name_p)) {
+}
+
+bool TemplateTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
+	auto &other = other_p->Cast<TemplateTypeInfo>();
+	return name == other.name;
+}
+
+shared_ptr<ExtraTypeInfo> TemplateTypeInfo::Copy() const {
+	return make_shared_ptr<TemplateTypeInfo>(*this);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/file_buffer.cpp

@@ -4,8 +4,9 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/helper.hpp"
-#include "duckdb/storage/storage_info.hpp"
+#include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/storage_info.hpp"
 
 #include <cstring>
 
@@ -32,10 +33,11 @@ void FileBuffer::Init() {
 	internal_size = 0;
 }
 
-FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p) : allocator(source.allocator), type(type_p) {
+FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p, idx_t block_header_size)
+    : allocator(source.allocator), type(type_p) {
 	// take over the structures of the source buffer
-	buffer = source.buffer;
-	size = source.size;
+	buffer = source.internal_buffer + block_header_size;
+	size = source.internal_size - block_header_size;
 	internal_buffer = source.internal_buffer;
 	internal_size = source.internal_size;
 
@@ -61,6 +63,7 @@ void FileBuffer::ReallocBuffer(idx_t new_size) {
 	if (!new_buffer) {
 		throw std::bad_alloc();
 	}
+
 	internal_buffer = new_buffer;
 	internal_size = new_size;
 
@@ -100,14 +103,14 @@ void FileBuffer::Resize(BlockManager &block_manager) {
 	ResizeInternal(block_manager.GetBlockSize(), block_manager.GetBlockHeaderSize());
 }
 
-void FileBuffer::Read(FileHandle &handle, uint64_t location) {
+void FileBuffer::Read(QueryContext context, FileHandle &handle, uint64_t location) {
 	D_ASSERT(type != FileBufferType::TINY_BUFFER);
-	handle.Read(internal_buffer, internal_size, location);
+	handle.Read(context, internal_buffer, internal_size, location);
 }
 
-void FileBuffer::Write(FileHandle &handle, uint64_t location) {
+void FileBuffer::Write(QueryContext context, FileHandle &handle, const uint64_t location) {
 	D_ASSERT(type != FileBufferType::TINY_BUFFER);
-	handle.Write(internal_buffer, internal_size, location);
+	handle.Write(context, internal_buffer, internal_size, location);
 }
 
 void FileBuffer::Clear() {

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

@@ -14,10 +14,10 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/common/windows_util.hpp"
 #include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 #include <cstdint>
 #include <cstdio>
-#include "duckdb/logging/file_system_logger.hpp"
 
 #ifndef _WIN32
 #include <dirent.h>
@@ -61,6 +61,8 @@ constexpr FileOpenFlags FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS;
 constexpr FileOpenFlags FileFlags::FILE_FLAGS_PARALLEL_ACCESS;
 constexpr FileOpenFlags FileFlags::FILE_FLAGS_EXCLUSIVE_CREATE;
 constexpr FileOpenFlags FileFlags::FILE_FLAGS_NULL_IF_EXISTS;
+constexpr FileOpenFlags FileFlags::FILE_FLAGS_MULTI_CLIENT_ACCESS;
+constexpr FileOpenFlags FileFlags::FILE_FLAGS_DISABLE_LOGGING;
 
 void FileOpenFlags::Verify() {
 #ifdef DEBUG
@@ -331,6 +333,17 @@ string FileSystem::ExtractBaseName(const string &path) {
 	return vec[0];
 }
 
+string FileSystem::ExtractExtension(const string &path) {
+	if (path.empty()) {
+		return string();
+	}
+	auto vec = StringUtil::Split(ExtractName(path), ".");
+	if (vec.size() < 2) {
+		return string();
+	}
+	return vec.back();
+}
+
 string FileSystem::GetHomeDirectory(optional_ptr<FileOpener> opener) {
 	// read the home_directory setting first, if it is set
 	if (opener) {
@@ -406,11 +419,6 @@ void FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t
 	throw NotImplementedException("%s: Read (with location) is not implemented!", GetName());
 }
 
-bool FileSystem::Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) {
-	// This is not a required method. Derived FileSystems may optionally override/implement.
-	return false;
-}
-
 void FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
 	throw NotImplementedException("%s: Write (with location) is not implemented!", GetName());
 }
@@ -423,11 +431,16 @@ int64_t FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
 	throw NotImplementedException("%s: Write is not implemented!", GetName());
 }
 
+bool FileSystem::Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) {
+	// This is not a required method. Derived FileSystems may optionally override/implement.
+	return false;
+}
+
 int64_t FileSystem::GetFileSize(FileHandle &handle) {
 	throw NotImplementedException("%s: GetFileSize is not implemented!", GetName());
 }
 
-time_t FileSystem::GetLastModifiedTime(FileHandle &handle) {
+timestamp_t FileSystem::GetLastModifiedTime(FileHandle &handle) {
 	throw NotImplementedException("%s: GetLastModifiedTime is not implemented!", GetName());
 }
 
@@ -603,6 +616,10 @@ void FileSystem::SetDisabledFileSystems(const vector<string> &names) {
 	throw NotImplementedException("%s: Can't disable file systems on a non-virtual file system", GetName());
 }
 
+bool FileSystem::SubSystemIsDisabled(const string &name) {
+	throw NotImplementedException("%s: Non-virtual file system does not have subsystems", GetName());
+}
+
 vector<string> FileSystem::ListSubSystems() {
 	throw NotImplementedException("%s: Can't list sub systems on a non-virtual file system", GetName());
 }
@@ -620,7 +637,7 @@ static string LookupExtensionForPattern(const string &pattern) {
 	return "";
 }
 
-vector<OpenFileInfo> FileSystem::GlobFiles(const string &pattern, ClientContext &context, FileGlobOptions options) {
+vector<OpenFileInfo> FileSystem::GlobFiles(const string &pattern, ClientContext &context, const FileGlobInput &input) {
 	auto result = Glob(pattern);
 	if (result.empty()) {
 		string required_extension = LookupExtensionForPattern(pattern);
@@ -642,9 +659,23 @@ vector<OpenFileInfo> FileSystem::GlobFiles(const string &pattern, ClientContext
 				throw InternalException("Extension load \"%s\" did not throw but somehow the extension was not loaded",
 				                        required_extension);
 			}
-			return GlobFiles(pattern, context, options);
+			return GlobFiles(pattern, context, input);
+		}
+		if (input.behavior == FileGlobOptions::FALLBACK_GLOB && !HasGlob(pattern)) {
+			// if we have no glob in the pattern and we have an extension, we try to glob
+			if (!HasGlob(pattern)) {
+				if (input.extension.empty()) {
+					throw InternalException("FALLBACK_GLOB requires an extension to be specified");
+				}
+				string new_pattern = JoinPath(JoinPath(pattern, "**"), "*." + input.extension);
+				result = GlobFiles(new_pattern, context, FileGlobOptions::ALLOW_EMPTY);
+				if (!result.empty()) {
+					// we found files by globbing the target as if it was a directory - return them
+					return result;
+				}
+			}
 		}
-		if (options == FileGlobOptions::DISALLOW_EMPTY) {
+		if (input.behavior == FileGlobOptions::FALLBACK_GLOB || input.behavior == FileGlobOptions::DISALLOW_EMPTY) {
 			throw IOException("No files found that match the pattern \"%s\"", pattern);
 		}
 	}
@@ -671,7 +702,7 @@ bool FileSystem::IsManuallySet() {
 	return false;
 }
 
-unique_ptr<FileHandle> FileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
+unique_ptr<FileHandle> FileSystem::OpenCompressedFile(QueryContext context, unique_ptr<FileHandle> handle, bool write) {
 	throw NotImplementedException("%s: OpenCompressedFile is not implemented!", GetName());
 }
 
@@ -691,6 +722,14 @@ int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
 	return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
 }
 
+int64_t FileHandle::Read(QueryContext context, void *buffer, idx_t nr_bytes) {
+	if (context.GetClientContext() != nullptr) {
+		context.GetClientContext()->client_data->profiler->AddBytesRead(nr_bytes);
+	}
+
+	return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
+}
+
 bool FileHandle::Trim(idx_t offset_bytes, idx_t length_bytes) {
 	return file_system.Trim(*this, offset_bytes, length_bytes);
 }
@@ -703,7 +742,19 @@ void FileHandle::Read(void *buffer, idx_t nr_bytes, idx_t location) {
 	file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
 }
 
-void FileHandle::Write(void *buffer, idx_t nr_bytes, idx_t location) {
+void FileHandle::Read(QueryContext context, void *buffer, idx_t nr_bytes, idx_t location) {
+	if (context.GetClientContext() != nullptr) {
+		context.GetClientContext()->client_data->profiler->AddBytesRead(nr_bytes);
+	}
+
+	file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
+}
+
+void FileHandle::Write(QueryContext context, void *buffer, idx_t nr_bytes, idx_t location) {
+	if (context.GetClientContext() != nullptr) {
+		context.GetClientContext()->client_data->profiler->AddBytesWritten(nr_bytes);
+	}
+
 	file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
 }
 
@@ -745,6 +796,20 @@ string FileHandle::ReadLine() {
 	}
 }
 
+string FileHandle::ReadLine(QueryContext context) {
+	string result;
+	char buffer[1];
+	while (true) {
+		auto tuples_read = UnsafeNumericCast<idx_t>(Read(context, buffer, 1));
+		if (tuples_read == 0 || buffer[0] == '\n') {
+			return result;
+		}
+		if (buffer[0] != '\r') {
+			result += buffer[0];
+		}
+	}
+}
+
 bool FileHandle::OnDiskFile() {
 	return file_system.OnDiskFile(*this);
 }
@@ -766,11 +831,16 @@ FileType FileHandle::GetType() {
 }
 
 void FileHandle::TryAddLogger(FileOpener &opener) {
+	if (flags.DisableLogging()) {
+		return;
+	}
+
 	auto context = opener.TryGetClientContext();
 	if (context && Logger::Get(*context).ShouldLog(FileSystemLogType::NAME, FileSystemLogType::LEVEL)) {
 		logger = context->logger;
 		return;
 	}
+
 	auto database = opener.TryGetDatabase();
 	if (database && Logger::Get(*database).ShouldLog(FileSystemLogType::NAME, FileSystemLogType::LEVEL)) {
 		logger = database->GetLogManager().GlobalLoggerReference();

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

@@ -7,6 +7,7 @@
 #include "miniz_wrapper.hpp"
 
 #include "duckdb/common/limits.hpp"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 
@@ -53,10 +54,10 @@ namespace duckdb {
 
  */
 
-static idx_t GZipConsumeString(FileHandle &input) {
+static idx_t GZipConsumeString(QueryContext context, FileHandle &input) {
 	idx_t size = 1; // terminator
 	char buffer[1];
-	while (input.Read(buffer, 1) == 1) {
+	while (input.Read(context, buffer, 1) == 1) {
 		if (buffer[0] == '\0') {
 			break;
 		}
@@ -75,7 +76,7 @@ struct MiniZStreamWrapper : public StreamWrapper {
 	idx_t total_size;
 
 public:
-	void Initialize(CompressedFile &file, bool write) override;
+	void Initialize(QueryContext context, CompressedFile &file, bool write) override;
 
 	bool Read(StreamData &stream_data) override;
 	void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer, int64_t nr_bytes) override;
@@ -96,7 +97,7 @@ MiniZStreamWrapper::~MiniZStreamWrapper() {
 	}
 }
 
-void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
+void MiniZStreamWrapper::Initialize(QueryContext context, CompressedFile &file, bool write) {
 	Close();
 	this->file = &file;
 	mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
@@ -119,20 +120,20 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 		}
 	} else {
 		idx_t data_start = GZIP_HEADER_MINSIZE;
-		auto read_count = file.child_handle->Read(gzip_hdr, GZIP_HEADER_MINSIZE);
+		auto read_count = file.child_handle->Read(context, gzip_hdr, GZIP_HEADER_MINSIZE);
 		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, NumericCast<idx_t>(read_count), &file);
 		// Skip over the extra field if necessary
 		if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
 			uint8_t gzip_xlen[2];
 			file.child_handle->Seek(data_start);
-			file.child_handle->Read(gzip_xlen, 2);
+			file.child_handle->Read(context, gzip_xlen, 2);
 			auto xlen = NumericCast<idx_t>((uint8_t)gzip_xlen[0] | (uint8_t)gzip_xlen[1] << 8);
 			data_start += xlen + 2;
 		}
 		// Skip over the file name if necessary
 		if (gzip_hdr[3] & GZIP_FLAG_NAME) {
 			file.child_handle->Seek(data_start);
-			data_start += GZipConsumeString(*file.child_handle);
+			data_start += GZipConsumeString(context, *file.child_handle);
 		}
 		file.child_handle->Seek(data_start);
 		// stream is now set to beginning of payload data
@@ -296,9 +297,9 @@ void MiniZStreamWrapper::Close() {
 
 class GZipFile : public CompressedFile {
 public:
-	GZipFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
+	GZipFile(QueryContext context, unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
 	    : CompressedFile(gzip_fs, std::move(child_handle_p), path) {
-		Initialize(write);
+		Initialize(context, write);
 	}
 	FileCompressionType GetFileCompressionType() override {
 		return FileCompressionType::GZIP;
@@ -407,9 +408,10 @@ string GZipFileSystem::UncompressGZIPString(const char *data, idx_t size) {
 	return decompressed;
 }
 
-unique_ptr<FileHandle> GZipFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
+unique_ptr<FileHandle> GZipFileSystem::OpenCompressedFile(QueryContext context, unique_ptr<FileHandle> handle,
+                                                          bool write) {
 	auto path = handle->path;
-	return make_uniq<GZipFile>(std::move(handle), path, write);
+	return make_uniq<GZipFile>(context, std::move(handle), path, write);
 }
 
 unique_ptr<StreamWrapper> GZipFileSystem::CreateStream() {