duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp

@@ -17,6 +17,8 @@
 
 namespace duckdb {
 
+enum class SampleType : uint8_t { BLOCKING_SAMPLE = 0, RESERVOIR_SAMPLE = 1, RESERVOIR_PERCENTAGE_SAMPLE = 2 };
+
 class BaseReservoirSampling {
 public:
 	explicit BaseReservoirSampling(int64_t seed);
@@ -29,8 +31,6 @@ public:
 	void ReplaceElement(double with_weight = -1);
 	//! The random generator
 	RandomEngine random;
-	//! Priority queue of [random element, index] for each of the elements in the sample
-	std::priority_queue<std::pair<double, idx_t>> reservoir_weights;
 	//! The next element to sample
 	idx_t next_index_to_sample;
 	//! The reservoir threshold of the current min entry
@@ -43,11 +43,26 @@ public:
 	//! when collecting a sample in parallel, we want to know how many values each thread has seen
 	//! so we can collect the samples from the thread local states in a uniform manner
 	idx_t num_entries_seen_total;
+	//! Priority queue of [random element, index] for each of the elements in the sample
+	std::priority_queue<std::pair<double, idx_t>> reservoir_weights;
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<BaseReservoirSampling> Deserialize(Deserializer &deserializer);
 };
 
 class BlockingSample {
 public:
-	explicit BlockingSample(int64_t seed) : base_reservoir_sample(seed), random(base_reservoir_sample.random) {
+	static constexpr const SampleType TYPE = SampleType::BLOCKING_SAMPLE;
+
+	unique_ptr<BaseReservoirSampling> base_reservoir_sample;
+	//! The sample type
+	SampleType type;
+	//! has the sample been destroyed due to updates to the referenced table
+	bool destroyed;
+
+public:
+	explicit BlockingSample(int64_t seed) : old_base_reservoir_sample(seed), random(old_base_reservoir_sample.random) {
+		base_reservoir_sample = nullptr;
 	}
 	virtual ~BlockingSample() {
 	}
@@ -59,20 +74,49 @@ public:
 	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
 	//! sample is completely built.
 	virtual unique_ptr<DataChunk> GetChunk() = 0;
-	BaseReservoirSampling base_reservoir_sample;
+	BaseReservoirSampling old_base_reservoir_sample;
 
 	virtual void Serialize(Serializer &serializer) const;
 	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
 
-protected:
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE && TARGET::TYPE != SampleType::BLOCKING_SAMPLE) {
+			throw InternalException("Failed to cast sample to type - sample type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE && TARGET::TYPE != SampleType::BLOCKING_SAMPLE) {
+			throw InternalException("Failed to cast sample to type - sample type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 	//! The reservoir sampling
 	RandomEngine &random;
 };
 
+class ReservoirChunk {
+public:
+	ReservoirChunk() {
+	}
+
+	DataChunk chunk;
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ReservoirChunk> Deserialize(Deserializer &deserializer);
+};
+
 //! The reservoir sample class maintains a streaming sample of fixed size "sample_count"
 class ReservoirSample : public BlockingSample {
 public:
-	ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed);
+	static constexpr const SampleType TYPE = SampleType::RESERVOIR_SAMPLE;
+
+public:
+	ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed = 1);
+	explicit ReservoirSample(idx_t sample_count, int64_t seed = 1);
 
 	//! Add a chunk of data to the sample
 	void AddToReservoir(DataChunk &input) override;
@@ -81,6 +125,8 @@ public:
 	//! sample is completely built.
 	unique_ptr<DataChunk> GetChunk() override;
 	void Finalize() override;
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
 
 private:
 	//! Replace a single element of the input
@@ -96,8 +142,10 @@ public:
 	//! when explicit number used, sample_count = number
 	idx_t sample_count;
 	bool reservoir_initialized;
+
 	//! The current reservoir
-	unique_ptr<DataChunk> reservoir_chunk;
+	unique_ptr<DataChunk> reservoir_data_chunk;
+	unique_ptr<ReservoirChunk> reservoir_chunk;
 };
 
 //! The reservoir sample sample_size class maintains a streaming sample of variable size
@@ -105,7 +153,11 @@ class ReservoirSamplePercentage : public BlockingSample {
 	constexpr static idx_t RESERVOIR_THRESHOLD = 100000;
 
 public:
-	ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed);
+	static constexpr const SampleType TYPE = SampleType::RESERVOIR_PERCENTAGE_SAMPLE;
+
+public:
+	ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed = -1);
+	explicit ReservoirSamplePercentage(double percentage, int64_t seed = -1);
 
 	//! Add a chunk of data to the sample
 	void AddToReservoir(DataChunk &input) override;
@@ -115,6 +167,9 @@ public:
 	unique_ptr<DataChunk> GetChunk() override;
 	void Finalize() override;
 
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
+
 private:
 	Allocator &allocator;
 	//! The sample_size to sample

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

@@ -78,11 +78,6 @@ struct TableFunctionData : public FunctionData {
 	DUCKDB_API bool Equals(const FunctionData &other) const override;
 };
 
-struct PyTableFunctionData : public TableFunctionData {
-	//! External dependencies of this table function
-	unique_ptr<ExternalDependency> external_dependency;
-};
-
 struct FunctionParameters {
 	vector<Value> values;
 	named_parameter_map_t named_parameters;

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

@@ -50,14 +50,17 @@ public:
 
 	DUCKDB_API unique_ptr<Expression> BindScalarFunction(const string &schema, const string &name,
 	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
-	                                                     bool is_operator = false, Binder *binder = nullptr);
+	                                                     bool is_operator = false,
+	                                                     optional_ptr<Binder> binder = nullptr);
 	DUCKDB_API unique_ptr<Expression> BindScalarFunction(ScalarFunctionCatalogEntry &function,
 	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
-	                                                     bool is_operator = false, Binder *binder = nullptr);
+	                                                     bool is_operator = false,
+	                                                     optional_ptr<Binder> binder = nullptr);
 
 	DUCKDB_API unique_ptr<BoundFunctionExpression> BindScalarFunction(ScalarFunction bound_function,
 	                                                                  vector<unique_ptr<Expression>> children,
-	                                                                  bool is_operator = false);
+	                                                                  bool is_operator = false,
+	                                                                  optional_ptr<Binder> binder = nullptr);
 
 	DUCKDB_API unique_ptr<BoundAggregateExpression>
 	BindAggregateFunction(AggregateFunction bound_function, vector<unique_ptr<Expression>> children,

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

@@ -17,12 +17,35 @@ class ClientContext;
 class TableRef;
 
 struct ReplacementScanData {
+public:
 	virtual ~ReplacementScanData() {
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
+struct ReplacementScanInput {
+public:
+	ReplacementScanInput(TableRef &ref, const string &table_name) : ref(ref), table_name(table_name) {
+	}
+
+public:
+	TableRef &ref;
+	const string &table_name;
 };
 
-typedef unique_ptr<TableRef> (*replacement_scan_t)(ClientContext &context, const string &table_name,
-                                                   ReplacementScanData *data);
+typedef unique_ptr<TableRef> (*replacement_scan_t)(ClientContext &context, ReplacementScanInput &input,
+                                                   optional_ptr<ReplacementScanData> data);
 
 //! Replacement table scans are automatically attempted when a table name cannot be found in the schema
 //! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan

package/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp

@@ -140,7 +140,7 @@ struct RegexLocalState : public FunctionLocalState {
 		if (extract_all) {
 			auto group_count_p = constant_pattern.NumberOfCapturingGroups();
 			if (group_count_p != -1) {
-				group_buffer.Init(group_count_p);
+				group_buffer.Init(NumericCast<idx_t>(group_count_p));
 			}
 		}
 		D_ASSERT(info.constant_pattern);

package/src/duckdb/src/include/duckdb/function/scalar/sequence_functions.hpp

@@ -16,12 +16,11 @@
 namespace duckdb {
 
 struct NextvalBindData : public FunctionData {
-	explicit NextvalBindData(optional_ptr<SequenceCatalogEntry> sequence)
-	    : sequence(sequence), create_info(sequence ? sequence->GetInfo() : nullptr) {
+	explicit NextvalBindData(SequenceCatalogEntry &sequence) : sequence(sequence), create_info(sequence.GetInfo()) {
 	}
 
 	//! The sequence to use for the nextval computation; only if the sequence is a constant
-	optional_ptr<SequenceCatalogEntry> sequence;
+	SequenceCatalogEntry &sequence;
 
 	//! The CreateInfo for the above sequence, if it exists
 	unique_ptr<CreateInfo> create_info;
@@ -32,7 +31,7 @@ struct NextvalBindData : public FunctionData {
 
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = other_p.Cast<NextvalBindData>();
-		return sequence == other.sequence;
+		return RefersToSameObject(sequence, other.sequence);
 	}
 };
 

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -161,6 +161,11 @@ public:
 
 	DUCKDB_API bool Parse(string_t str, ParseResult &result) const;
 
+	DUCKDB_API bool Parse(const char *data, size_t size, ParseResult &result) const;
+
+	DUCKDB_API bool TryParseDate(const char *data, size_t size, date_t &result) const;
+	DUCKDB_API bool TryParseTimestamp(const char *data, size_t size, timestamp_t &result) const;
+
 	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message) const;
 	DUCKDB_API bool TryParseTime(string_t str, dtime_t &result, string &error_message) const;
 	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message) const;

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -78,7 +78,7 @@ struct LengthFun {
 				return length;
 			}
 		}
-		return input_length;
+		return UnsafeNumericCast<TR>(input_length);
 	}
 };
 

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

@@ -51,6 +51,15 @@ struct FunctionStatisticsInput {
 	unique_ptr<Expression> *expr_ptr;
 };
 
+struct FunctionModifiedDatabasesInput {
+	FunctionModifiedDatabasesInput(optional_ptr<FunctionData> bind_data_p, unordered_set<string> &modified_databases_p)
+	    : bind_data(bind_data_p), modified_databases(modified_databases_p) {
+	}
+
+	optional_ptr<FunctionData> bind_data;
+	unordered_set<string> &modified_databases;
+};
+
 //! The scalar function type
 typedef std::function<void(DataChunk &, ExpressionState &, Vector &)> scalar_function_t;
 //! The type to bind the scalar function and to create the function data
@@ -66,6 +75,8 @@ typedef void (*dependency_function_t)(BoundFunctionExpression &expr, LogicalDepe
 typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, FunctionStatisticsInput &input);
 //! The type to bind lambda-specific parameter types
 typedef LogicalType (*bind_lambda_function_t)(const idx_t parameter_idx, const LogicalType &list_child_type);
+//! The type to bind lambda-specific parameter types
+typedef void (*get_modified_databases_t)(FunctionModifiedDatabasesInput &input);
 
 typedef void (*function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                      const ScalarFunction &function);
@@ -102,6 +113,8 @@ public:
 	function_statistics_t statistics;
 	//! The lambda bind function (if any)
 	bind_lambda_function_t bind_lambda;
+	//! Gets the modified databases (if any)
+	get_modified_databases_t get_modified_databases;
 
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;

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

@@ -46,10 +46,12 @@ typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(uintptr_
                                                                         ArrowStreamParameters &parameters);
 typedef void (*stream_factory_get_schema_t)(ArrowArrayStream *stream_factory_ptr, ArrowSchema &schema);
 
-struct ArrowScanFunctionData : public PyTableFunctionData {
+struct ArrowScanFunctionData : public TableFunctionData {
 public:
-	ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p)
-	    : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p) {
+	ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p,
+	                      shared_ptr<DependencyItem> dependency = nullptr)
+	    : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p),
+	      dependency(std::move(dependency)) {
 	}
 	vector<LogicalType> all_types;
 	atomic<idx_t> lines_read;
@@ -59,6 +61,8 @@ public:
 	uintptr_t stream_factory_ptr;
 	//! Pointer to the scanner factory produce
 	stream_factory_produce_t scanner_producer;
+	//! The (optional) dependency of this function (used in Python for example)
+	shared_ptr<DependencyItem> dependency;
 	//! Arrow table data
 	ArrowTableType arrow_table;
 };

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

@@ -56,6 +56,8 @@ struct WriteCSVData : public BaseCSVData {
 	idx_t flush_size = 4096ULL * 8ULL;
 	//! For each byte whether or not the CSV file requires quotes when containing the byte
 	unsafe_unique_array<bool> requires_quotes;
+	//! Expressions used to convert the input into strings
+	vector<unique_ptr<Expression>> cast_expressions;
 };
 
 struct ColumnInfo {
@@ -93,6 +95,7 @@ struct ReadCSVData : public BaseCSVData {
 	vector<unique_ptr<CSVFileScan>> union_readers;
 	//! Reader bind data
 	MultiFileReaderBindData reader_bind;
+
 	vector<ColumnInfo> column_info;
 
 	void Initialize(unique_ptr<CSVFileScan> &reader) {

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

@@ -57,6 +57,10 @@ struct DuckDBSecretsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DuckDBWhichSecretFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct DuckDBDatabasesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -25,6 +25,7 @@ class LogicalDependencyList;
 class LogicalGet;
 class TableFilterSet;
 class TableCatalogEntry;
+struct MultiFileReader;
 
 struct TableFunctionInfo {
 	DUCKDB_API virtual ~TableFunctionInfo();
@@ -83,9 +84,10 @@ struct LocalTableFunctionState {
 struct TableFunctionBindInput {
 	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
 	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       optional_ptr<TableFunctionInfo> info, optional_ptr<Binder> binder)
+	                       optional_ptr<TableFunctionInfo> info, optional_ptr<Binder> binder,
+	                       const TableFunction &table_function, const TableFunctionRef &ref)
 	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
-	      input_table_names(input_table_names), info(info), binder(binder) {
+	      input_table_names(input_table_names), info(info), binder(binder), table_function(table_function), ref(ref) {
 	}
 
 	vector<Value> &inputs;
@@ -94,6 +96,8 @@ struct TableFunctionBindInput {
 	vector<string> &input_table_names;
 	optional_ptr<TableFunctionInfo> info;
 	optional_ptr<Binder> binder;
+	const TableFunction &table_function;
+	const TableFunctionRef &ref;
 };
 
 struct TableFunctionInitInput {
@@ -198,6 +202,8 @@ typedef idx_t (*table_function_get_batch_index_t)(ClientContext &context, const
 
 typedef BindInfo (*table_function_get_bind_info_t)(const optional_ptr<FunctionData> bind_data);
 
+typedef unique_ptr<MultiFileReader> (*table_function_get_multi_file_reader_t)();
+
 typedef double (*table_function_progress_t)(ClientContext &context, const FunctionData *bind_data,
                                             const GlobalTableFunctionState *global_state);
 typedef void (*table_function_dependency_t)(LogicalDependencyList &dependencies, const FunctionData *bind_data);
@@ -212,6 +218,9 @@ typedef void (*table_function_serialize_t)(Serializer &serializer, const optiona
                                            const TableFunction &function);
 typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(Deserializer &deserializer, TableFunction &function);
 
+typedef void (*table_function_type_pushdown_t)(ClientContext &context, optional_ptr<FunctionData> bind_data,
+                                               const unordered_map<idx_t, LogicalType> &new_column_types);
+
 class TableFunction : public SimpleNamedParameterFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	DUCKDB_API
@@ -267,6 +276,10 @@ public:
 	table_function_get_batch_index_t get_batch_index;
 	//! (Optional) returns extra bind info
 	table_function_get_bind_info_t get_bind_info;
+	//! (Optional) pushes down type information to scanner, returns true if pushdown was successful
+	table_function_type_pushdown_t type_pushdown;
+	//! (Optional) allows injecting a custom MultiFileReader implementation
+	table_function_get_multi_file_reader_t get_multi_file_reader;
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;

package/src/duckdb/src/include/duckdb/logging/http_logger.hpp

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/logging/http_logger.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/fstream.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/printer.hpp"
+#include "duckdb/main/client_context.hpp"
+
+#include <functional>
+
+namespace duckdb {
+
+//! This has to be templated because we have two namespaces:
+//! 1. duckdb_httplib
+//! 2. duckdb_httplib_openssl
+//! These have essentially the same code, but we cannot convert between them
+//! We get around that by templating everything, which requires implementing everything in the header
+class HTTPLogger {
+public:
+	explicit HTTPLogger(ClientContext &context_p) : context(context_p) {
+	}
+
+public:
+	template <class REQUEST, class RESPONSE>
+	std::function<void(const REQUEST &, const RESPONSE &)> GetLogger() {
+		return [&](const REQUEST &req, const RESPONSE &res) {
+			Log(req, res);
+		};
+	}
+
+private:
+	template <class STREAM, class REQUEST, class RESPONSE>
+	static inline void TemplatedWriteRequests(STREAM &out, const REQUEST &req, const RESPONSE &res) {
+		out << "HTTP Request:\n";
+		out << "\t" << req.method << " " << req.path << "\n";
+		for (auto &entry : req.headers) {
+			out << "\t" << entry.first << ": " << entry.second << "\n";
+		}
+		out << "\nHTTP Response:\n";
+		out << "\t" << res.status << " " << res.reason << " " << req.version << "\n";
+		for (auto &entry : res.headers) {
+			out << "\t" << entry.first << ": " << entry.second << "\n";
+		}
+		out << "\n";
+	}
+
+	template <class REQUEST, class RESPONSE>
+	void Log(const REQUEST &req, const RESPONSE &res) {
+		const auto &config = ClientConfig::GetConfig(context);
+		D_ASSERT(config.enable_http_logging);
+
+		lock_guard<mutex> guard(lock);
+		if (config.http_logging_output.empty()) {
+			stringstream out;
+			TemplatedWriteRequests(out, req, res);
+			Printer::Print(out.str());
+		} else {
+			ofstream out(config.http_logging_output, ios::app);
+			TemplatedWriteRequests(out, req, res);
+			out.close();
+			// Throw an IO exception if it fails to write to the file
+			if (out.fail()) {
+				throw IOException("Failed to write HTTP log to file \"%s\": %s", config.http_logging_output,
+				                  strerror(errno));
+			}
+		}
+	}
+
+private:
+	ClientContext &context;
+	mutex lock;
+};
+
+} // namespace duckdb

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

@@ -59,9 +59,7 @@ public:
 
 	// Append functions
 	template <class T>
-	void Append(T value) {
-		throw InternalException("Undefined type for Appender::Append!");
-	}
+	void Append(T value) = delete;
 
 	DUCKDB_API void Append(const char *value, uint32_t length);
 

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

@@ -43,7 +43,7 @@ public:
 	                 const AttachInfo &info, AccessMode access_mode);
 	~AttachedDatabase() override;
 
-	void Initialize(optional_ptr<ClientContext> context = nullptr);
+	void Initialize();
 	void Close();
 
 	Catalog &ParentCatalog() override;

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

@@ -15,6 +15,7 @@
 #include "duckdb/common/optional_idx.hpp"
 #include "duckdb/execution/physical_operator_states.hpp"
 #include "duckdb/common/enums/pending_execution_result.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/main/capi/cast/generic.hpp

@@ -65,8 +65,8 @@ RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row) {
 	case DUCKDB_TYPE_BLOB:
 		return TryCastCInternal<duckdb_blob, RESULT_TYPE, FromCBlobCastWrapper>(result, col, row);
 	default: { // LCOV_EXCL_START
-		// invalid type for C to C++ conversion
-		D_ASSERT(0);
+		// Invalid type for C to C++ conversion. Internally, we set the null mask to NULL.
+		// This is a deprecated code path. Use the Vector Interface for nested and complex types.
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	} // LCOV_EXCL_STOP
 	}

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

@@ -16,9 +16,11 @@
 #include "duckdb/common/progress_bar/progress_bar.hpp"
 
 namespace duckdb {
+
 class ClientContext;
 class PhysicalResultCollector;
 class PreparedStatementData;
+class HTTPLogger;
 
 typedef std::function<unique_ptr<PhysicalResultCollector>(ClientContext &context, PreparedStatementData &data)>
     get_result_collector_t;
@@ -115,6 +117,12 @@ struct ClientConfig {
 	//! Defaults to PhysicalMaterializedCollector
 	get_result_collector_t result_collector = nullptr;
 
+	//! If HTTP logging is enabled or not.
+	bool enable_http_logging = false;
+	//! The file to save query HTTP logging information to, instead of printing it to the console
+	//! (empty = print to console)
+	string http_logging_output;
+
 public:
 	static ClientConfig &GetConfig(ClientContext &context);
 	static const ClientConfig &GetConfig(const ClientContext &context);

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

@@ -59,7 +59,7 @@ struct PendingQueryParameters {
 
 //! The ClientContext holds information relevant to the current client session
 //! during execution
-class ClientContext : public std::enable_shared_from_this<ClientContext> {
+class ClientContext : public enable_shared_from_this<ClientContext> {
 	friend class PendingQueryResult; // LockContext
 	friend class SimpleBufferedData; // ExecuteTaskInternal
 	friend class StreamQueryResult;  // LockContext
@@ -289,22 +289,4 @@ private:
 	lock_guard<mutex> client_guard;
 };
 
-class ClientContextWrapper {
-public:
-	explicit ClientContextWrapper(const shared_ptr<ClientContext> &context)
-	    : client_context(context) {
-
-	      };
-	shared_ptr<ClientContext> GetContext() {
-		auto actual_context = client_context.lock();
-		if (!actual_context) {
-			throw ConnectionException("Connection has already been closed");
-		}
-		return actual_context;
-	}
-
-private:
-	std::weak_ptr<ClientContext> client_context;
-};
-
 } // namespace duckdb

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

@@ -17,9 +17,19 @@ class ErrorData;
 class MetaTransaction;
 class PreparedStatementData;
 class SQLStatement;
+struct PendingQueryParameters;
 
 enum class RebindQueryInfo { DO_NOT_REBIND, ATTEMPT_TO_REBIND };
 
+struct PreparedStatementCallbackInfo {
+	PreparedStatementCallbackInfo(PreparedStatementData &prepared_statement, const PendingQueryParameters &parameters)
+	    : prepared_statement(prepared_statement), parameters(parameters) {
+	}
+
+	PreparedStatementData &prepared_statement;
+	const PendingQueryParameters &parameters;
+};
+
 //! ClientContextState is virtual base class for ClientContext-local (or Query-Local, using QueryEnd callback) state
 //! e.g. caches that need to live as long as a ClientContext or Query.
 class ClientContextState {
@@ -48,7 +58,7 @@ public:
 	                                          PreparedStatementMode mode) {
 		return RebindQueryInfo::DO_NOT_REBIND;
 	}
-	virtual RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementData &prepared_statement,
+	virtual RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementCallbackInfo &info,
 	                                          RebindQueryInfo current_rebind) {
 		return RebindQueryInfo::DO_NOT_REBIND;
 	}

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/client_context_wrapper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/shared_ptr.hpp"
+
+namespace duckdb {
+
+class ClientContext;
+
+class ClientContextWrapper {
+public:
+	explicit ClientContextWrapper(const shared_ptr<ClientContext> &context);
+	shared_ptr<ClientContext> GetContext();
+	shared_ptr<ClientContext> TryGetContext();
+
+private:
+	weak_ptr<ClientContext> client_context;
+};
+
+} // namespace duckdb