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

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/exception_format_value.hpp"
 #include "duckdb/common/vector.hpp"
 
+#include <map>
 #include <stdexcept>
 
 namespace duckdb {
@@ -76,8 +77,10 @@ enum class ExceptionType {
 	PERMISSION = 34,      // insufficient permissions
 	PARAMETER_NOT_RESOLVED = 35, // parameter types could not be resolved
 	PARAMETER_NOT_ALLOWED = 36,  // parameter types not allowed
-	DEPENDENCY = 37              // dependency
+	DEPENDENCY = 37,             // dependency
+	HTTP = 38
 };
+class HTTPException;
 
 class Exception : public std::exception {
 public:
@@ -91,7 +94,12 @@ public:
 	DUCKDB_API const string &RawMessage() const;
 
 	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
-	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message);
+	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message,
+	                                                           const std::shared_ptr<Exception> &original);
+	virtual std::shared_ptr<Exception> Copy() const {
+		return make_shared<Exception>(type, raw_message_);
+	}
+	DUCKDB_API const HTTPException &AsHTTPException() const;
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
@@ -256,6 +264,8 @@ public:
 class IOException : public Exception {
 public:
 	DUCKDB_API explicit IOException(const string &msg);
+	DUCKDB_API explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
+	}
 
 	template <typename... Args>
 	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
@@ -272,6 +282,63 @@ public:
 	}
 };
 
+class HTTPException : public IOException {
+public:
+	template <typename>
+	struct ResponseShape {
+		typedef int status;
+	};
+
+	template <class RESPONSE, typename ResponseShape<decltype(RESPONSE::status)>::status = 0, typename... ARGS>
+	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
+	    : HTTPException(response.status, response.body, response.headers, response.reason, msg, params...) {
+	}
+
+	template <typename>
+	struct ResponseWrapperShape {
+		typedef int code;
+	};
+	template <class RESPONSE, typename ResponseWrapperShape<decltype(RESPONSE::code)>::code = 0, typename... ARGS>
+	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
+	    : HTTPException(response.code, response.body, response.headers, response.error, msg, params...) {
+	}
+
+	template <typename HEADERS, typename... ARGS>
+	explicit HTTPException(int status_code, string response_body, HEADERS headers, const string &reason,
+	                       const string &msg, ARGS... params)
+	    : IOException(ExceptionType::HTTP, ConstructMessage(msg, params...)), status_code(status_code), reason(reason),
+	      response_body(std::move(response_body)) {
+		this->headers.insert(headers.begin(), headers.end());
+		D_ASSERT(this->headers.size() > 0);
+	}
+
+	std::shared_ptr<Exception> Copy() const {
+		return make_shared<HTTPException>(status_code, response_body, headers, reason, RawMessage());
+	}
+
+	const std::multimap<std::string, std::string> GetHeaders() const {
+		return headers;
+	}
+	int GetStatusCode() const {
+		return status_code;
+	}
+	const string &GetResponseBody() const {
+		return response_body;
+	}
+	const string &GetReason() const {
+		return reason;
+	}
+	[[noreturn]] void Throw() const {
+		throw HTTPException(status_code, response_body, headers, reason, RawMessage());
+	}
+
+private:
+	int status_code;
+	string reason;
+	string response_body;
+	std::multimap<string, string> headers;
+};
+
 class SerializationException : public Exception {
 public:
 	DUCKDB_API explicit SerializationException(const string &msg);

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -25,7 +25,7 @@ struct IndexWriteOperation {
 
 class FieldWriter {
 public:
-	DUCKDB_API FieldWriter(Serializer &serializer);
+	DUCKDB_API explicit FieldWriter(Serializer &serializer);
 	DUCKDB_API ~FieldWriter();
 
 public:
@@ -128,11 +128,11 @@ public:
 		return *buffer;
 	}
 
-private:
 	void AddField() {
 		field_count++;
 	}
 
+private:
 	template <class T>
 	void Write(const T &element) {
 		WriteData((const_data_ptr_t)&element, sizeof(T));
@@ -152,7 +152,7 @@ DUCKDB_API void FieldWriter::Write(const string &val);
 
 class FieldDeserializer : public Deserializer {
 public:
-	FieldDeserializer(Deserializer &root);
+	explicit FieldDeserializer(Deserializer &root);
 
 public:
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
@@ -163,6 +163,14 @@ public:
 		return root;
 	}
 
+	ClientContext &GetContext() override {
+		return root.GetContext();
+	}
+
+	Catalog *GetCatalog() override {
+		return root.GetCatalog();
+	}
+
 private:
 	Deserializer &root;
 	idx_t remaining_data;
@@ -177,7 +185,7 @@ struct IndexReadOperation {
 
 class FieldReader {
 public:
-	DUCKDB_API FieldReader(Deserializer &source);
+	DUCKDB_API explicit FieldReader(Deserializer &source);
 	DUCKDB_API ~FieldReader();
 
 public:

package/src/duckdb/src/include/duckdb/common/helper.hpp

@@ -114,7 +114,7 @@ const T Load(const_data_ptr_t ptr) {
 }
 
 template <typename T>
-void Store(const T val, data_ptr_t ptr) {
+void Store(const T &val, data_ptr_t ptr) {
 	memcpy(ptr, (void *)&val, sizeof(val));
 }
 

package/src/duckdb/src/include/duckdb/common/{http_stats.hpp → http_state.hpp}

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/http_stats.hpp
+// duckdb/common/http_state.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -15,7 +15,16 @@
 
 namespace duckdb {
 
-class HTTPStats {
+struct CachedFile {
+	//! Cached Data
+	shared_ptr<char> data;
+	//! Data capacity
+	uint64_t capacity = 0;
+	//! If we finished downloading the file
+	bool finished = false;
+};
+
+class HTTPState {
 public:
 	atomic<idx_t> head_count {0};
 	atomic<idx_t> get_count {0};
@@ -23,6 +32,10 @@ public:
 	atomic<idx_t> post_count {0};
 	atomic<idx_t> total_bytes_received {0};
 	atomic<idx_t> total_bytes_sent {0};
+	//! Mutex to lock when getting the cached file(Parallel Only)
+	mutex cached_files_mutex;
+	//! In case of fully downloading the file, the cached files of this query
+	unordered_map<string, CachedFile> cached_files;
 
 	void Reset() {
 		head_count = 0;
@@ -31,13 +44,14 @@ public:
 		post_count = 0;
 		total_bytes_received = 0;
 		total_bytes_sent = 0;
+		cached_files.clear();
 	}
 
 	//! helper function to get the HTTP
-	static HTTPStats *TryGetStats(FileOpener *opener) {
+	static HTTPState *TryGetState(FileOpener *opener) {
 		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
-			return client_context->client_data->http_stats.get();
+			return client_context->client_data->http_state.get();
 		}
 		return nullptr;
 	}

package/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp

@@ -23,120 +23,122 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 struct Equals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return left == right;
 	}
 };
 struct NotEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return !Equals::Operation(left, right);
 	}
 };
 
 struct GreaterThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return left > right;
 	}
 };
 
 struct GreaterThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
-		return left >= right;
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+		return !GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
-		return GreaterThanEquals::Operation(right, left);
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+		return !GreaterThan::Operation(left, right);
 	}
 };
 
 template <>
-DUCKDB_API bool Equals::Operation(float left, float right);
+DUCKDB_API bool Equals::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool Equals::Operation(double left, double right);
+DUCKDB_API bool Equals::Operation(const double &left, const double &right);
 
 template <>
-DUCKDB_API bool GreaterThan::Operation(float left, float right);
+DUCKDB_API bool GreaterThan::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool GreaterThan::Operation(double left, double right);
+DUCKDB_API bool GreaterThan::Operation(const double &left, const double &right);
 
 template <>
-DUCKDB_API bool GreaterThanEquals::Operation(float left, float right);
+DUCKDB_API bool GreaterThanEquals::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool GreaterThanEquals::Operation(double left, double right);
+DUCKDB_API bool GreaterThanEquals::Operation(const double &left, const double &right);
 
 // Distinct semantics are from Postgres record sorting. NULL = NULL and not-NULL < NULL
 // Deferring to the non-distinct operations removes the need for further specialisation.
 // TODO: To reverse the semantics, swap left_null and right_null for comparisons
 struct DistinctFrom {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null != right_null) || (!left_null && !right_null && NotEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (left_null || right_null) {
+			return left_null != right_null;
+		}
+		return NotEquals::Operation(left, right);
 	}
 };
 
 struct NotDistinctFrom {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null && right_null) || (!left_null && !right_null && Equals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctFrom::Operation(left, right, left_null, right_null);
 	}
 };
 
 struct DistinctGreaterThan {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (left_null || right_null) {
+			return !right_null;
+		}
+		return GreaterThan::Operation(left, right);
 	}
 };
 
 struct DistinctGreaterThanNullsFirst {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(left, right, right_null, left_null);
 	}
 };
 
 struct DistinctGreaterThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return left_null || (!left_null && !right_null && GreaterThanEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctGreaterThan::Operation(right, left, right_null, left_null);
 	}
 };
 
 struct DistinctLessThan {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(right, left, right_null, left_null);
 	}
 };
 
 struct DistinctLessThanNullsFirst {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(right, left, left_null, right_null);
 	}
 };
 
 struct DistinctLessThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return right_null || (!left_null && !right_null && LessThanEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctGreaterThan::Operation(left, right, left_null, right_null);
 	}
 };
 
@@ -144,124 +146,34 @@ struct DistinctLessThanEquals {
 // Specialized Boolean Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool GreaterThan::Operation(bool left, bool right) {
+inline bool GreaterThan::Operation(const bool &left, const bool &right) {
 	return !right && left;
 }
-template <>
-inline bool LessThan::Operation(bool left, bool right) {
-	return !left && right;
-}
 //===--------------------------------------------------------------------===//
 // Specialized String Comparison Operations
 //===--------------------------------------------------------------------===//
-struct StringComparisonOperators {
-	template <bool INVERSE>
-	static inline bool EqualsOrNot(const string_t a, const string_t b) {
-		if (a.IsInlined()) {
-			// small string: compare entire string
-			if (memcmp(&a, &b, sizeof(string_t)) == 0) {
-				// entire string is equal
-				return INVERSE ? false : true;
-			}
-		} else {
-			// large string: first check prefix and length
-			if (memcmp(&a, &b, string_t::HEADER_SIZE) == 0) {
-				// prefix and length are equal: check main string
-				if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
-					// entire string is equal
-					return INVERSE ? false : true;
-				}
-			}
-		}
-		// not equal
-		return INVERSE ? true : false;
-	}
-};
-
-template <>
-inline bool Equals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<false>(left, right);
-}
-template <>
-inline bool NotEquals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<true>(left, right);
-}
-
-template <>
-inline bool NotDistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<false>(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<true>(left, right));
-}
-
-// compare up to shared length. if still the same, compare lengths
-template <class OP>
-static bool templated_string_compare_op(string_t left, string_t right) {
-	auto memcmp_res =
-	    memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), MinValue<idx_t>(left.GetSize(), right.GetSize()));
-	auto final_res = memcmp_res == 0 ? OP::Operation(left.GetSize(), right.GetSize()) : OP::Operation(memcmp_res, 0);
-	return final_res;
-}
-
-template <>
-inline bool GreaterThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThan>(left, right);
-}
-
 template <>
-inline bool GreaterThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThanEquals>(left, right);
+inline bool Equals::Operation(const string_t &left, const string_t &right) {
+	return left == right;
 }
 
 template <>
-inline bool LessThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThan>(left, right);
+inline bool GreaterThan::Operation(const string_t &left, const string_t &right) {
+	return left > right;
 }
 
-template <>
-inline bool LessThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThanEquals>(left, right);
-}
 //===--------------------------------------------------------------------===//
 // Specialized Interval Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool Equals::Operation(interval_t left, interval_t right) {
+inline bool Equals::Operation(const interval_t &left, const interval_t &right) {
 	return Interval::Equals(left, right);
 }
 template <>
-inline bool NotEquals::Operation(interval_t left, interval_t right) {
-	return !Equals::Operation(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(interval_t left, interval_t right) {
+inline bool GreaterThan::Operation(const interval_t &left, const interval_t &right) {
 	return Interval::GreaterThan(left, right);
 }
-template <>
-inline bool GreaterThanEquals::Operation(interval_t left, interval_t right) {
-	return Interval::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(interval_t left, interval_t right) {
-	return GreaterThan::Operation(right, left);
-}
-template <>
-inline bool LessThanEquals::Operation(interval_t left, interval_t right) {
-	return GreaterThanEquals::Operation(right, left);
-}
 
-template <>
-inline bool NotDistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) || (!left_null && !right_null && Interval::Equals(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) || (!left_null && !right_null && !Equals::Operation(left, right));
-}
 inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
 	return LessThan::Operation(lhs, rhs);
 }
@@ -270,27 +182,11 @@ inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
 // Specialized Hugeint Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool Equals::Operation(hugeint_t left, hugeint_t right) {
+inline bool Equals::Operation(const hugeint_t &left, const hugeint_t &right) {
 	return Hugeint::Equals(left, right);
 }
 template <>
-inline bool NotEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::NotEquals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(hugeint_t left, hugeint_t right) {
+inline bool GreaterThan::Operation(const hugeint_t &left, const hugeint_t &right) {
 	return Hugeint::GreaterThan(left, right);
 }
-template <>
-inline bool GreaterThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThan(left, right);
-}
-template <>
-inline bool LessThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThanEquals(left, right);
-}
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/multiply.hpp

@@ -56,6 +56,8 @@ template <>
 bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
 template <>
 DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+DUCKDB_API bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
 
 struct MultiplyOperatorOverflowCheck {
 	template <class TA, class TB, class TR>

package/src/duckdb/src/include/duckdb/common/optional_ptr.hpp

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/optional_ptr.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+
+template <class T>
+class optional_ptr {
+public:
+	optional_ptr() : ptr(nullptr) {
+	}
+	optional_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
+	}
+	optional_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
+	}
+
+	operator bool() const {
+		return ptr;
+	}
+	T &operator*() {
+		if (!ptr) {
+			throw InternalException("Attempting to dereference an optional pointer that is not set");
+		}
+		return *ptr;
+	}
+	T *operator->() {
+		if (!ptr) {
+			throw InternalException("Attempting to call a method on an optional pointer that is not set");
+		}
+		return ptr;
+	}
+
+private:
+	T *ptr;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/preserved_error.hpp

@@ -19,7 +19,8 @@ public:
 	DUCKDB_API PreservedError();
 	//! From std::exception
 	PreservedError(const std::exception &ex)
-	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())) {
+	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())),
+	      exception_instance(nullptr) {
 	}
 	//! From a raw string
 	DUCKDB_API explicit PreservedError(const string &raw_message);
@@ -38,6 +39,9 @@ public:
 	//! Let's us do things like 'if (error)'
 	DUCKDB_API operator bool() const;
 	DUCKDB_API bool operator==(const PreservedError &other) const;
+	DUCKDB_API const shared_ptr<Exception> &GetError() {
+		return exception_instance;
+	}
 
 private:
 	//! Whether this PreservedError contains an exception or not
@@ -48,6 +52,7 @@ private:
 	string raw_message;
 	//! The final message (stored in the preserved error for compatibility reasons with C-API)
 	string final_message;
+	std::shared_ptr<Exception> exception_instance;
 
 private:
 	DUCKDB_API static string SanitizeErrorMessage(string error);

package/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar.hpp

@@ -16,11 +16,13 @@
 
 namespace duckdb {
 
+struct ClientConfig;
 typedef unique_ptr<ProgressBarDisplay> (*progress_bar_display_create_func_t)();
 
 class ProgressBar {
 public:
 	static unique_ptr<ProgressBarDisplay> DefaultProgressBarDisplay();
+	static void SystemOverrideCheck(ClientConfig &config);
 
 	explicit ProgressBar(
 	    Executor &executor, idx_t show_progress_after,

package/src/duckdb/src/include/duckdb/common/serializer/buffered_deserializer.hpp

@@ -26,14 +26,16 @@ public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
 };
 
-class BufferentContextDeserializer : public BufferedDeserializer {
+class BufferedContextDeserializer : public BufferedDeserializer {
 public:
-	BufferentContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
+	BufferedContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
 	    : BufferedDeserializer(ptr, data_size), context(context_p) {
 	}
 
 public:
 	ClientContext &context;
+
+	ClientContext &GetContext() override;
 };
 
 } // namespace duckdb