duckdb 0.7.2-dev457.0 → 0.7.2-dev586.0

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -15,10 +15,11 @@ PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t es
 //===--------------------------------------------------------------------===//
 class CreateTypeGlobalState : public GlobalSinkState {
 public:
-	explicit CreateTypeGlobalState(ClientContext &context) : collection(context, {LogicalType::VARCHAR}) {
+	explicit CreateTypeGlobalState(ClientContext &context) : result(LogicalType::VARCHAR) {
 	}
-
-	ColumnDataCollection collection;
+	Vector result;
+	idx_t size = 0;
+	idx_t capacity = STANDARD_VECTOR_SIZE;
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext &context) const {
@@ -28,7 +29,7 @@ unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext
 SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                         DataChunk &input) const {
 	auto &gstate = (CreateTypeGlobalState &)gstate_p;
-	idx_t total_row_count = gstate.collection.Count() + input.size();
+	idx_t total_row_count = gstate.size + input.size();
 	if (total_row_count > NumericLimits<uint32_t>::Maximum()) {
 		throw InvalidInputException("Attempted to create ENUM of size %llu, which exceeds the maximum size of %llu",
 		                            total_row_count, NumericLimits<uint32_t>::Maximum());
@@ -36,15 +37,23 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkSta
 	UnifiedVectorFormat sdata;
 	input.data[0].ToUnifiedFormat(input.size(), sdata);
 
+	if (total_row_count > gstate.capacity) {
+		// We must resize our result vector
+		gstate.result.Resize(gstate.capacity, gstate.capacity * 2);
+		gstate.capacity *= 2;
+	}
+
+	auto src_ptr = (string_t *)sdata.data;
+	auto result_ptr = FlatVector::GetData<string_t>(gstate.result);
 	// Input vector has NULL value, we just throw an exception
 	for (idx_t i = 0; i < input.size(); i++) {
 		idx_t idx = sdata.sel->get_index(i);
 		if (!sdata.validity.RowIsValid(idx)) {
 			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
 		}
+		result_ptr[gstate.size++] =
+		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetDataUnsafe(), src_ptr[idx].GetSize());
 	}
-
-	gstate.collection.Append(input);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -72,44 +81,15 @@ void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 
 	if (IsSink()) {
 		D_ASSERT(info->type == LogicalType::INVALID);
-
 		auto &g_sink_state = (CreateTypeGlobalState &)*sink_state;
-		auto &collection = g_sink_state.collection;
-
-		idx_t total_row_count = collection.Count();
-
-		ColumnDataScanState scan_state;
-		collection.InitializeScan(scan_state);
-
-		DataChunk scan_chunk;
-		collection.InitializeScanChunk(scan_chunk);
-
-		Vector result(LogicalType::VARCHAR, total_row_count);
-		auto result_ptr = FlatVector::GetData<string_t>(result);
-
-		idx_t offset = 0;
-		while (collection.Scan(scan_state, scan_chunk)) {
-			idx_t src_row_count = scan_chunk.size();
-			auto &src_vec = scan_chunk.data[0];
-			D_ASSERT(src_vec.GetVectorType() == VectorType::FLAT_VECTOR);
-			D_ASSERT(src_vec.GetType().id() == LogicalType::VARCHAR);
-
-			auto src_ptr = FlatVector::GetData<string_t>(src_vec);
-
-			for (idx_t i = 0; i < src_row_count; i++) {
-				idx_t target_index = offset + i;
-				result_ptr[target_index] =
-				    StringVector::AddStringOrBlob(result, src_ptr[i].GetDataUnsafe(), src_ptr[i].GetSize());
-			}
-
-			offset += src_row_count;
-		}
-
-		info->type = LogicalType::ENUM(info->name, result, total_row_count);
+		info->type = LogicalType::ENUM(info->name, g_sink_state.result, g_sink_state.size);
 	}
 
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateType(context.client, info.get());
+	auto catalog_entry = catalog.CreateType(context.client, info.get());
+	D_ASSERT(catalog_entry->type == CatalogType::TYPE_ENTRY);
+	auto catalog_type = (TypeCatalogEntry *)catalog_entry;
+	LogicalType::SetCatalog(info->type, catalog_type);
 	state.finished = true;
 }
 

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

@@ -101,6 +101,9 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 	} else if (format == "tiM") {
 		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
 		return LogicalType::INTERVAL;
+	} else if (format == "tin") {
+		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTH_DAY_NANO);
+		return LogicalType::INTERVAL;
 	} else if (format == "+l") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);

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

@@ -316,6 +316,20 @@ void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalS
 	}
 }
 
+void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
+                                     int64_t nested_offset, idx_t size) {
+	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
+	auto src_ptr = (ArrowInterval *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	if (nested_offset != -1) {
+		src_ptr = (ArrowInterval *)array.buffers[1] + nested_offset + array.offset;
+	}
+	for (idx_t row = 0; row < size; row++) {
+		tgt_ptr[row].days = src_ptr[row].days;
+		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
+		tgt_ptr[row].months = src_ptr[row].months;
+	}
+}
+
 void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
@@ -509,6 +523,10 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 			IntervalConversionMonths(vector, array, scan_state, nested_offset, size);
 			break;
 		}
+		case ArrowDateTimeType::MONTH_DAY_NANO: {
+			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset, size);
+			break;
+		}
 		default:
 			throw std::runtime_error("Unsupported precision for Interval/Duration Type ");
 		}

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev457"
+#define DUCKDB_VERSION "0.7.2-dev586"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "403d0ca315"
+#define DUCKDB_SOURCE_ID "23ee8b036a"
 #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,11 @@ 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 {

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

@@ -205,6 +205,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/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/{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/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

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

@@ -14,14 +14,16 @@ namespace duckdb {
 
 class BufferedFileReader : public Deserializer {
 public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
-	                   FileOpener *opener = nullptr);
+	BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context,
+	                   FileLockType lock_type = FileLockType::READ_LOCK, FileOpener *opener = nullptr);
 
 	FileSystem &fs;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t read_data;
 	unique_ptr<FileHandle> handle;
+	ClientContext *context;
+	Catalog *catalog = nullptr;
 
 public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
@@ -35,6 +37,10 @@ public:
 	void Seek(uint64_t location);
 	uint64_t CurrentOffset();
 
+	ClientContext &GetContext() override;
+
+	Catalog *GetCatalog() override;
+
 private:
 	idx_t file_size;
 	idx_t total_read;

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector.hpp"
@@ -21,6 +22,8 @@ private:
 	uint64_t version = 0L;
 
 public:
+	bool is_query_plan = false;
+
 	virtual ~Serializer() {
 	}
 
@@ -111,6 +114,16 @@ public:
 	//! Reads [read_size] bytes into the buffer
 	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
 
+	//! Gets the context for the deserializer
+	virtual ClientContext &GetContext() {
+		throw InternalException("This deserializer does not have a client-context");
+	};
+
+	//! Gets the catalog for the deserializer
+	virtual Catalog *GetCatalog() {
+		return nullptr;
+	};
+
 	template <class T>
 	T Read() {
 		T value;

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

@@ -23,6 +23,20 @@ class Value;
 class TypeCatalogEntry;
 class Vector;
 class ClientContext;
+class FieldWriter;
+
+//! Extra Type Info Type
+enum class ExtraTypeInfoType : uint8_t {
+	INVALID_TYPE_INFO = 0,
+	GENERIC_TYPE_INFO = 1,
+	DECIMAL_TYPE_INFO = 2,
+	STRING_TYPE_INFO = 3,
+	LIST_TYPE_INFO = 4,
+	STRUCT_TYPE_INFO = 5,
+	ENUM_TYPE_INFO = 6,
+	USER_TYPE_INFO = 7,
+	AGGREGATE_STATE_TYPE_INFO = 8
+};
 
 struct hugeint_t {
 public:
@@ -297,6 +311,11 @@ struct LogicalType {
 	inline const ExtraTypeInfo *AuxInfo() const {
 		return type_info_.get();
 	}
+
+	inline shared_ptr<ExtraTypeInfo> GetAuxInfoShrPtr() const {
+		return type_info_;
+	}
+
 	inline void CopyAuxInfo(const LogicalType& other) {
 		type_info_ = other.type_info_;
 	}
@@ -324,6 +343,9 @@ struct LogicalType {
 
 	//! Serializes a LogicalType to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
+
+	DUCKDB_API void SerializeEnumType(Serializer &serializer) const;
+
 	//! Deserializes a blob back into an LogicalType
 	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
 
@@ -349,6 +371,8 @@ struct LogicalType {
 	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
 	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
 
+	DUCKDB_API static ExtraTypeInfoType GetExtraTypeInfoType(const ExtraTypeInfo &type);
+
 	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
 	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
 
@@ -441,12 +465,14 @@ struct UserType{
 struct EnumType{
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
-	DUCKDB_API static Vector &GetValuesInsertOrder(const LogicalType &type);
+	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
 	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
 	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
+	DUCKDB_API static string GetSchemaName(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
+	DUCKDB_API static void Serialize(FieldWriter& writer, const ExtraTypeInfo& type_info, bool serialize_internals);
 };
 
 struct StructType {

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_file_handle.hpp

@@ -87,6 +87,7 @@ public:
 			// we have data left to read from the file
 			// read directly into the buffer
 			auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+			file_size = file_handle->GetFileSize();
 			read_position += bytes_read;
 			if (reset_enabled) {
 				// if reset caching is enabled, we need to cache the bytes that we have read

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -32,7 +32,18 @@ enum class ArrowDateTimeType : uint8_t {
 	NANOSECONDS = 2,
 	SECONDS = 3,
 	DAYS = 4,
-	MONTHS = 5
+	MONTHS = 5,
+	MONTH_DAY_NANO = 6
+};
+
+struct ArrowInterval {
+	int32_t months;
+	int32_t days;
+	int64_t nanoseconds;
+
+	inline bool operator==(const ArrowInterval &rhs) const {
+		return this->days == rhs.days && this->months == rhs.months && this->nanoseconds == rhs.nanoseconds;
+	}
 };
 
 struct ArrowConvertData {

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -11,6 +11,8 @@
 #include "duckdb/common/enums/operator_result_type.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/function/function.hpp"
+#include "duckdb/planner/bind_context.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
 
 #include <functional>
@@ -136,6 +138,7 @@ public:
 
 typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, TableFunctionBindInput &input,
                                                           vector<LogicalType> &return_types, vector<string> &names);
+typedef unique_ptr<TableRef> (*table_function_bind_replace_t)(ClientContext &context, TableFunctionBindInput &input);
 typedef unique_ptr<GlobalTableFunctionState> (*table_function_init_global_t)(ClientContext &context,
                                                                              TableFunctionInitInput &input);
 typedef unique_ptr<LocalTableFunctionState> (*table_function_init_local_t)(ExecutionContext &context,
@@ -185,6 +188,11 @@ public:
 	//! This function is used for determining the return type of a table producing function and returning bind data
 	//! The returned FunctionData object should be constant and should not be changed during execution.
 	table_function_bind_t bind;
+	//! (Optional) Bind replace function
+	//! This function is called before the regular bind function. It allows returning a TableRef will be used to
+	//! to generate a logical plan that replaces the LogicalGet of a regularly bound TableFunction. The BindReplace can
+	//! also return a nullptr to indicate a regular bind needs to be performed instead.
+	table_function_bind_replace_t bind_replace;
 	//! (Optional) global init function
 	//! Initialize the global operator state of the function.
 	//! The global operator state is used to keep track of the progress in the table function and is shared between

package/src/duckdb/src/include/duckdb/main/client_data.hpp

@@ -20,7 +20,7 @@ class BufferedFileWriter;
 class ClientContext;
 class CatalogSearchPath;
 class FileOpener;
-class HTTPStats;
+class HTTPState;
 class QueryProfiler;
 class QueryProfilerHistory;
 class PreparedStatementData;
@@ -52,8 +52,8 @@ struct ClientData {
 	//! The file opener of the client context
 	unique_ptr<FileOpener> file_opener;
 
-	//! Statistics on HTTP traffic
-	unique_ptr<HTTPStats> http_stats;
+	//! HTTP State in this query
+	unique_ptr<HTTPState> http_state;
 
 	//! The file search path
 	string file_search_path;

package/src/duckdb/src/include/duckdb/main/connection_manager.hpp

@@ -47,6 +47,8 @@ public:
 		return result;
 	}
 
+	ClientContext *GetConnection(DatabaseInstance *db);
+
 	static ConnectionManager &Get(DatabaseInstance &db);
 	static ConnectionManager &Get(ClientContext &context);
 

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -96,6 +96,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
+    {"force_download", "httpfs"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_region", "httpfs"},

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp

@@ -59,6 +59,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
+	virtual string GetColumnName() const {
+		return "";
+	};
 
 	AlterEntryData GetAlterEntryData() const;
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -137,6 +137,9 @@ public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
 	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+	string GetColumnName() const override {
+		return removed_column;
+	};
 };
 
 //===--------------------------------------------------------------------===//
@@ -158,6 +161,9 @@ public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
 	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+	string GetColumnName() const override {
+		return column_name;
+	};
 };
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp

@@ -44,7 +44,7 @@ protected:
 	virtual void WriteMacro(ScalarMacroCatalogEntry &table);
 	virtual void WriteTableMacro(TableMacroCatalogEntry &table);
 	virtual void WriteIndex(IndexCatalogEntry &index_catalog);
-	virtual void WriteType(TypeCatalogEntry &table);
+	virtual void WriteType(TypeCatalogEntry &type);
 };
 
 class CheckpointReader {

package/src/duckdb/src/include/duckdb/storage/meta_block_reader.hpp

@@ -36,7 +36,14 @@ public:
 	//! Read content of size read_size into the buffer
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
 
+	ClientContext &GetContext() override;
+	Catalog *GetCatalog() override;
+	void SetCatalog(Catalog *catalog_p);
+	void SetContext(ClientContext *context_p);
+
 private:
 	void ReadNewBlock(block_id_t id);
+	Catalog *catalog = nullptr;
+	ClientContext *context = nullptr;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp

@@ -137,7 +137,7 @@ public:
 	//! Sets the table used for subsequent insert/delete/update commands
 	void WriteSetTable(string &schema, string &table);
 
-	void WriteAlter(AlterInfo &info);
+	void WriteAlter(data_ptr_t ptr, idx_t data_size);
 
 	void WriteInsert(DataChunk &chunk);
 	void WriteDelete(DataChunk &chunk);