duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -1,6 +1,5 @@
 #include "duckdb/function/table/table_scan.hpp"
 
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/mutex.hpp"
@@ -15,6 +14,7 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 namespace duckdb {
 
@@ -40,17 +40,14 @@ static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
 }
 
 struct TableScanGlobalState : public GlobalTableFunctionState {
-	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) : row_count(0) {
+	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
 		D_ASSERT(bind_data_p);
 		auto &bind_data = (const TableScanBindData &)*bind_data_p;
 		max_threads = bind_data.table->GetStorage().MaxThreads(context);
 	}
 
 	ParallelTableScanState state;
-	mutex lock;
 	idx_t max_threads;
-	//! How many rows we already scanned
-	atomic<idx_t> row_count;
 
 	vector<idx_t> projection_ids;
 	vector<LogicalType> scanned_types;
@@ -131,7 +128,6 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 			storage.Scan(transaction, output, state.scan_state);
 		}
 		if (output.size() > 0) {
-			gstate.row_count += output.size();
 			return;
 		}
 		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
@@ -147,7 +143,6 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	auto &state = (TableScanLocalState &)*local_state;
 	auto &storage = bind_data.table->GetStorage();
 
-	lock_guard<mutex> parallel_lock(parallel_state.lock);
 	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
 }
 
@@ -161,7 +156,9 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
 	}
-	auto percentage = 100 * (double(gstate.row_count) / total_rows);
+	idx_t scanned_rows = gstate.state.scan_state.processed_rows;
+	scanned_rows += gstate.state.local_state.processed_rows;
+	auto percentage = 100 * (double(scanned_rows) / total_rows);
 	if (percentage > 100) {
 		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
 		//! It means we finished this table.
@@ -171,12 +168,12 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 }
 
 idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
-                             LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
+                             LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate_p) {
 	auto &state = (TableScanLocalState &)*local_state;
-	if (state.scan_state.table_state.row_group_state.row_group) {
+	if (state.scan_state.table_state.row_group) {
 		return state.scan_state.table_state.batch_index;
 	}
-	if (state.scan_state.local_state.row_group_state.row_group) {
+	if (state.scan_state.local_state.row_group) {
 		return state.scan_state.table_state.batch_index + state.scan_state.local_state.batch_index;
 	}
 	return 0;
@@ -332,7 +329,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 				auto comparison_type = comparison->type;
 				if (comparison->left->type == ExpressionType::VALUE_CONSTANT) {
 					// the expression is on the right side, we flip them around
-					comparison_type = FlipComparisionExpression(comparison_type);
+					comparison_type = FlipComparisonExpression(comparison_type);
 				}
 				if (comparison_type == ExpressionType::COMPARE_EQUAL) {
 					// equality value

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev12"
+#define DUCKDB_VERSION "0.7.2-dev1244"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c1ee858e4a"
+#define DUCKDB_SOURCE_ID "ab5c07cb68"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -14,12 +14,12 @@ TableFunctionInfo::~TableFunctionInfo() {
 TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
                              table_function_bind_t bind, table_function_init_global_t init_global,
                              table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), init_global(init_global),
-      init_local(init_local), function(function), in_out_function(nullptr), in_out_function_final(nullptr),
-      statistics(nullptr), dependency(nullptr), cardinality(nullptr), pushdown_complex_filter(nullptr),
-      to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr), get_batch_info(nullptr),
-      serialize(nullptr), deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
-      filter_prune(false) {
+    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), bind_replace(nullptr),
+      init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
+      in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
+      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
+      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
+      filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -28,11 +28,30 @@ TableFunction::TableFunction(const vector<LogicalType> &arguments, table_functio
     : TableFunction(string(), arguments, function, bind, init_global, init_local) {
 }
 TableFunction::TableFunction()
-    : SimpleNamedParameterFunction("", {}), bind(nullptr), init_global(nullptr), init_local(nullptr), function(nullptr),
-      in_out_function(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
-      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
-      filter_pushdown(false), filter_prune(false) {
+    : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
+      init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
+      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
+      get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
+      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
+}
+
+bool TableFunction::Equal(const TableFunction &rhs) const {
+	// number of types
+	if (this->arguments.size() != rhs.arguments.size()) {
+		return false;
+	}
+	// argument types
+	for (idx_t i = 0; i < this->arguments.size(); ++i) {
+		if (this->arguments[i] != rhs.arguments[i]) {
+			return false;
+		}
+	}
+	// varargs
+	if (this->varargs != rhs.varargs) {
+		return false;
+	}
+
+	return true; // they are equal
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/catalog/catalog_transaction.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -80,6 +81,8 @@ public:
 	DUCKDB_API static Catalog &GetCatalog(ClientContext &context, const string &catalog_name);
 	//! Get the specified Catalog from the DatabaseInstance
 	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db, const string &catalog_name);
+	//! Gets the specified Catalog from the database if it exists
+	DUCKDB_API static optional_ptr<Catalog> GetCatalogEntry(ClientContext &context, const string &catalog_name);
 	//! Get the specific Catalog from the AttachedDatabase
 	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
 
@@ -205,6 +208,9 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
+	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
+	                       const string &name);
+
 	template <class T>
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext()) {

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -35,7 +35,7 @@ public:
 
 	void SetAsRoot() override;
 
-	void CommitAlter(AlterInfo &info);
+	void CommitAlter(string &column_name);
 	void CommitDrop();
 
 	TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) override;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -9,17 +9,12 @@
 #pragma once
 
 #include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/function/function_set.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 
 namespace duckdb {
 
-class Catalog;
-class Constraint;
-
-struct CreateTableFunctionInfo;
-
 //! A table function in the catalog
 class TableFunctionCatalogEntry : public StandardEntry {
 public:
@@ -31,5 +26,8 @@ public:
 
 	//! The table function
 	TableFunctionSet functions;
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
+class Catalog;
 class CatalogEntry;
 
 //! The DependencyList
@@ -21,6 +22,8 @@ class DependencyList {
 public:
 	DUCKDB_API void AddDependency(CatalogEntry *entry);
 
+	DUCKDB_API void VerifyDependencies(Catalog *catalog, const string &name);
+
 private:
 	unordered_set<CatalogEntry *> set;
 };

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -59,8 +59,9 @@ public:
 	DUCKDB_API string GetDBPath() override;
 
 private:
+	DUCKDB_API void DropSchema(CatalogTransaction transaction, DropInfo *info);
 	DUCKDB_API void DropSchema(ClientContext &context, DropInfo *info) override;
-
+	CatalogEntry *CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo *info);
 	void Verify() override;
 
 private:

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

@@ -18,6 +18,7 @@ class ColumnDataCollection;
 class ColumnDataRowCollection;
 
 enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
+enum class RenderMode { ROWS, COLUMNS };
 
 struct BoxRendererConfig {
 	// a max_width of 0 means we default to the terminal width
@@ -30,7 +31,10 @@ struct BoxRendererConfig {
 	// the max col width determines the maximum size of a single column
 	// note that the max col width is only used if the result does not fit on the screen
 	idx_t max_col_width = 20;
+	//! how to render NULL values
 	string null_value = "NULL";
+	//! Whether or not to render row-wise or column-wise
+	RenderMode render_mode = RenderMode::ROWS;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
 	const char *LTCORNER = "\342\224\214"; // "┌";
@@ -94,10 +98,12 @@ private:
 	string RenderType(const LogicalType &type);
 	ValueRenderAlignment TypeAlignment(const LogicalType &type);
 	string GetRenderValue(ColumnDataRowCollection &rows, idx_t c, idx_t r);
-
 	list<ColumnDataCollection> FetchRenderCollections(ClientContext &context, const ColumnDataCollection &result,
 	                                                  idx_t top_rows, idx_t bottom_rows);
-	vector<idx_t> ComputeRenderWidths(const vector<string> &names, const ColumnDataCollection &result,
+	list<ColumnDataCollection> PivotCollections(ClientContext &context, list<ColumnDataCollection> input,
+	                                            vector<string> &column_names, vector<LogicalType> &result_types,
+	                                            idx_t row_count);
+	vector<idx_t> ComputeRenderWidths(const vector<string> &names, const vector<LogicalType> &result_types,
 	                                  list<ColumnDataCollection> &collections, idx_t min_width, idx_t max_width,
 	                                  vector<idx_t> &column_map, idx_t &total_length);
 	void RenderHeader(const vector<string> &names, const vector<LogicalType> &result_types,

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

@@ -15,25 +15,6 @@
 
 namespace duckdb {
 
-// API versions
-// if no explicit API version is defined, the latest API version is used
-// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-// These will not be supported long-term, and will be removed in future versions.
-
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE
 using std::move;

package/src/duckdb/src/include/duckdb/common/enums/aggregate_handling.hpp

@@ -19,4 +19,6 @@ enum class AggregateHandling : uint8_t {
 	FORCE_AGGREGATES       // force aggregates: any non-aggregate select list entry will become a GROUP
 };
 
+const char *ToString(AggregateHandling value);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp

@@ -205,11 +205,10 @@ string ExpressionTypeToOperator(ExpressionType type);
 
 // Operator String to ExpressionType (e.g. + => OPERATOR_ADD)
 ExpressionType OperatorToExpressionType(const string &op);
-
 //! Negate a comparison expression, turning e.g. = into !=, or < into >=
-ExpressionType NegateComparisionExpression(ExpressionType type);
+ExpressionType NegateComparisonExpression(ExpressionType type);
 //! Flip a comparison expression, turning e.g. < into >, or = into =
-ExpressionType FlipComparisionExpression(ExpressionType type);
+ExpressionType FlipComparisonExpression(ExpressionType type);
 
 DUCKDB_API string ExpressionClassToString(ExpressionClass type);
 

package/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp

@@ -16,10 +16,13 @@ namespace duckdb {
 // Join Reference Types
 //===--------------------------------------------------------------------===//
 enum class JoinRefType : uint8_t {
-	REGULAR,   // Explicit conditions
-	NATURAL,   // Implied conditions
-	CROSS,     // No condition
-	POSITIONAL // Positional condition
+	REGULAR,    // Explicit conditions
+	NATURAL,    // Implied conditions
+	CROSS,      // No condition
+	POSITIONAL, // Positional condition
+	ASOF        // AsOf conditions
 };
 
+const char *ToString(JoinRefType value);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -49,6 +49,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_ANY_JOIN = 53,
 	LOGICAL_CROSS_PRODUCT = 54,
 	LOGICAL_POSITIONAL_JOIN = 55,
+	LOGICAL_ASOF_JOIN = 56,
 	// -----------------------------
 	// SetOps
 	// -----------------------------

package/src/duckdb/src/include/duckdb/common/enums/order_type.hpp

@@ -9,10 +9,12 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/exception.hpp"
 
 namespace duckdb {
 
 enum class OrderType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2, DESCENDING = 3 };
+
 enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/set_operation_type.hpp

@@ -13,4 +13,5 @@
 namespace duckdb {
 
 enum class SetOperationType : uint8_t { NONE = 0, UNION = 1, EXCEPT = 2, INTERSECT = 3, UNION_BY_NAME = 4 };
-}
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -44,7 +44,8 @@ enum class StatementType : uint8_t {
 	EXTENSION_STATEMENT,
 	LOGICAL_PLAN_STATEMENT,
 	ATTACH_STATEMENT,
-	DETACH_STATEMENT
+	DETACH_STATEMENT,
+	MULTI_STATEMENT
 
 };
 

package/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp

@@ -23,7 +23,8 @@ enum class TableReferenceType : uint8_t {
 	TABLE_FUNCTION = 5,  // table producing function
 	EXPRESSION_LIST = 6, // expression list
 	CTE = 7,             // Recursive CTE
-	EMPTY = 8            // placeholder for empty FROM
+	EMPTY = 8,           // placeholder for empty FROM
+	PIVOT = 9            // pivot statement
 };
 
 } // namespace duckdb

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;
 	}