duckdb 0.7.2-dev0.0 → 0.7.2-dev1034.0

package/src/duckdb/src/main/capi/pending-c.cpp

@@ -9,14 +9,16 @@ using duckdb::PendingQueryResult;
 using duckdb::PendingStatementWrapper;
 using duckdb::PreparedStatementWrapper;
 
-duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
+                                              duckdb_pending_result *out_result, bool allow_streaming) {
 	if (!prepared_statement || !out_result) {
 		return DuckDBError;
 	}
 	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
 	auto result = new PendingStatementWrapper();
+	result->allow_streaming = allow_streaming;
 	try {
-		result->statement = wrapper->statement->PendingQuery(wrapper->values, false);
+		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
 	} catch (const duckdb::Exception &ex) {
 		result->statement = make_unique<PendingQueryResult>(duckdb::PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -28,6 +30,15 @@ duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statemen
 	return return_value;
 }
 
+duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, false);
+}
+
+duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                               duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, true);
+}
+
 void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
 	if (!pending_result || !*pending_result) {
 		return;
@@ -90,7 +101,9 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	if (!wrapper->statement) {
 		return DuckDBError;
 	}
-	auto result = wrapper->statement->Execute();
+
+	std::unique_ptr<duckdb::QueryResult> result;
+	result = wrapper->statement->Execute();
 	wrapper->statement.reset();
 	return duckdb_translate_result(std::move(result), out_result);
 }

package/src/duckdb/src/main/capi/result-c.cpp

@@ -292,6 +292,10 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		// already used as a new result set
 		return false;
 	}
+	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING) {
+		// already used as a streaming result
+		return false;
+	}
 	// materialize as deprecated result set
 	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
 	auto column_count = result_data->result->ColumnCount();
@@ -413,6 +417,10 @@ idx_t duckdb_row_count(duckdb_result *result) {
 		return 0;
 	}
 	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
+		// We can't know the row count beforehand
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.RowCount();
 }
@@ -463,7 +471,10 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return 0;
 	}
-	D_ASSERT(result_data.result->type == duckdb::QueryResultType::MATERIALIZED_RESULT);
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// Can't know beforehand how many chunks are returned.
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.Collection().ChunkCount();
 }
@@ -476,6 +487,10 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return nullptr;
 	}
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// This API is only supported for materialized query results
+		return nullptr;
+	}
 	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	auto &collection = materialized.Collection();
@@ -487,3 +502,14 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	collection.FetchChunk(chunk_idx, *chunk);
 	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
 }
+
+bool duckdb_result_is_streaming(duckdb_result result) {
+	if (!result.internal_data) {
+		return false;
+	}
+	if (duckdb_result_error(&result) != nullptr) {
+		return false;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
+}

package/src/duckdb/src/main/capi/stream-c.cpp

@@ -0,0 +1,25 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/allocator.hpp"
+
+duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result) {
+	if (!result.internal_data) {
+		return nullptr;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
+		return nullptr;
+	}
+	if (result_data.result->type != duckdb::QueryResultType::STREAM_RESULT) {
+		// We can only fetch from a StreamQueryResult
+		return nullptr;
+	}
+	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING;
+	auto &streaming = (duckdb::StreamQueryResult &)*result_data.result;
+	if (!streaming.IsOpen()) {
+		return nullptr;
+	}
+	// FetchRaw ? Do we care about flattening them?
+	auto chunk = streaming.Fetch();
+	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
+}

package/src/duckdb/src/main/client_context.cpp

@@ -1,52 +1,52 @@
 #include "duckdb/main/client_context.hpp"
 
-#include "duckdb/main/client_context_file_opener.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/http_state.hpp"
+#include "duckdb/common/preserved_error.hpp"
+#include "duckdb/common/progress_bar/progress_bar.hpp"
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/common/serializer/buffered_file_writer.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
+#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
+#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/main/appender.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/client_context_file_opener.hpp"
+#include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/error_manager.hpp"
 #include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/client_data.hpp"
+#include "duckdb/main/query_profiler.hpp"
 #include "duckdb/main/query_result.hpp"
+#include "duckdb/main/relation.hpp"
 #include "duckdb/main/stream_query_result.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parser/parser.hpp"
+#include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/parser/parsed_data/create_function_info.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/drop_statement.hpp"
+#include "duckdb/parser/statement/execute_statement.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
+#include "duckdb/parser/statement/prepare_statement.hpp"
+#include "duckdb/parser/statement/relation_statement.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/planner/operator/logical_execute.hpp"
 #include "duckdb/planner/planner.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/statement/relation_statement.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
 #include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
-#include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/database_manager.hpp"
+#include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/common/http_stats.hpp"
-#include "duckdb/main/attached_database.hpp"
+#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {
 
@@ -156,8 +156,8 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu
 PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction) {
 	client_data->profiler->EndQuery();
 
-	if (client_data->http_stats) {
-		client_data->http_stats->Reset();
+	if (client_data->http_state) {
+		client_data->http_state->Reset();
 	}
 
 	// Notify any registered state of query end
@@ -209,6 +209,7 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 }
 
 void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
+	client_data->http_state = make_unique<HTTPState>();
 	if (!active_query) {
 		// no query currently active
 		return;
@@ -717,10 +718,6 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 	auto &profiler = QueryProfiler::Get(*this);
 	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
 
-	if (IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get())) {
-		client_data->http_stats = make_unique<HTTPStats>();
-	}
-
 	bool invalidate_query = true;
 	try {
 		if (statement) {
@@ -813,12 +810,14 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 
 	unique_ptr<QueryResult> result;
 	QueryResult *last_result = nullptr;
+	bool last_had_result = false;
 	for (idx_t i = 0; i < statements.size(); i++) {
 		auto &statement = statements[i];
 		bool is_last_statement = i + 1 == statements.size();
 		PendingQueryParameters parameters;
 		parameters.allow_stream_result = allow_stream_result && is_last_statement;
 		auto pending_query = PendingQueryInternal(*lock, std::move(statement), parameters);
+		auto has_result = pending_query->properties.return_type == StatementReturnType::QUERY_RESULT;
 		unique_ptr<QueryResult> current_result;
 		if (pending_query->HasError()) {
 			current_result = make_unique<MaterializedQueryResult>(pending_query->GetErrorObject());
@@ -826,12 +825,17 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 			current_result = ExecutePendingQueryInternal(*lock, *pending_query);
 		}
 		// now append the result to the list of results
-		if (!last_result) {
+		if (!last_result || !last_had_result) {
 			// first result of the query
 			result = std::move(current_result);
 			last_result = result.get();
+			last_had_result = has_result;
 		} else {
 			// later results; attach to the result chain
+			// but only if there is a result
+			if (!has_result) {
+				continue;
+			}
 			last_result->next = std::move(current_result);
 			last_result = last_result->next.get();
 		}

package/src/duckdb/src/main/client_data.cpp

@@ -1,15 +1,16 @@
 #include "duckdb/main/client_data.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_context_file_opener.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/common/http_stats.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
+
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/common/http_state.hpp"
+#include "duckdb/common/random_engine.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/client_context_file_opener.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/query_profiler.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/main/config.cpp

@@ -9,6 +9,9 @@
 #include "duckdb/common/thread.hpp"
 #endif
 
+#include <cstdio>
+#include <inttypes.h>
+
 namespace duckdb {
 
 #define DUCKDB_GLOBAL(_PARAM)                                                                                          \
@@ -214,9 +217,75 @@ void DBConfig::SetDefaultMaxMemory() {
 	}
 }
 
+idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
+	static constexpr const char *CPU_MAX = "/sys/fs/cgroup/cpu.max";
+	static constexpr const char *CFS_QUOTA = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
+	static constexpr const char *CFS_PERIOD = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
+
+	int64_t quota, period;
+	char byte_buffer[1000];
+	unique_ptr<FileHandle> handle;
+	int64_t read_bytes;
+
+	if (fs.FileExists(CPU_MAX)) {
+		// cgroup v2
+		// https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html
+		handle =
+		    fs.OpenFile(CPU_MAX, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK, FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 " %" SCNd64 "", &quota, &period) != 2) {
+			return physical_cores;
+		}
+	} else if (fs.FileExists(CFS_QUOTA) && fs.FileExists(CFS_PERIOD)) {
+		// cgroup v1
+		// https://www.kernel.org/doc/html/latest/scheduler/sched-bwc.html#management
+
+		// Read the quota, this indicates how many microseconds the CPU can be utilized by this cgroup per period
+		handle = fs.OpenFile(CFS_QUOTA, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
+		                     FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 "", &quota) != 1) {
+			return physical_cores;
+		}
+
+		// Read the time period, a cgroup can utilize the CPU up to quota microseconds every period
+		handle = fs.OpenFile(CFS_PERIOD, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
+		                     FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 "", &period) != 1) {
+			return physical_cores;
+		}
+	} else {
+		// No cgroup quota
+		return physical_cores;
+	}
+	if (quota > 0 && period > 0) {
+		return idx_t(std::ceil((double)quota / (double)period));
+	} else {
+		return physical_cores;
+	}
+}
+
+idx_t GetSystemMaxThreadsInternal(FileSystem &fs) {
+#ifndef DUCKDB_NO_THREADS
+	idx_t physical_cores = std::thread::hardware_concurrency();
+#ifdef __linux__
+	auto cores_available_per_period = CGroupBandwidthQuota(physical_cores, fs);
+	return MaxValue<idx_t>(cores_available_per_period, 1);
+#else
+	return physical_cores;
+#endif
+#else
+	return 1;
+#endif
+}
+
 void DBConfig::SetDefaultMaxThreads() {
 #ifndef DUCKDB_NO_THREADS
-	options.maximum_threads = std::thread::hardware_concurrency();
+	options.maximum_threads = GetSystemMaxThreadsInternal(*file_system);
 #else
 	options.maximum_threads = 1;
 #endif

package/src/duckdb/src/main/database.cpp

@@ -115,6 +115,15 @@ ConnectionManager &ConnectionManager::Get(DatabaseInstance &db) {
 	return db.GetConnectionManager();
 }
 
+ClientContext *ConnectionManager::GetConnection(DatabaseInstance *db) {
+	for (auto &conn : connections) {
+		if (conn.first->db.get() == db) {
+			return conn.first;
+		}
+	}
+	return nullptr;
+}
+
 ConnectionManager &ConnectionManager::Get(ClientContext &context) {
 	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
 }
@@ -191,8 +200,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	db_manager = make_unique<DatabaseManager>(*this);
-	buffer_manager =
-	    make_unique<BufferManager>(*this, config.options.temporary_directory, config.options.maximum_memory);
+	buffer_manager = make_unique<BufferManager>(*this, config.options.temporary_directory);
 	scheduler = make_unique<TaskScheduler>(*this);
 	object_cache = make_unique<ObjectCache>();
 	connection_manager = make_unique<ConnectionManager>();
@@ -271,6 +279,10 @@ BufferManager &DatabaseInstance::GetBufferManager() {
 	return *buffer_manager;
 }
 
+BufferPool &DatabaseInstance::GetBufferPool() {
+	return *config.buffer_pool;
+}
+
 DatabaseManager &DatabaseManager::Get(DatabaseInstance &db) {
 	return db.GetDatabaseManager();
 }
@@ -340,6 +352,11 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	if (!config.default_allocator) {
 		config.default_allocator = Allocator::DefaultAllocatorReference();
 	}
+	if (new_config.buffer_pool) {
+		config.buffer_pool = std::move(new_config.buffer_pool);
+	} else {
+		config.buffer_pool = make_shared<BufferPool>(config.options.maximum_memory);
+	}
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -206,8 +206,13 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		if (exact_match) {
 			message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
 		}
-		throw IOException("Failed to download extension \"%s\" at URL \"%s%s\"\n%s", extension_name, url_base,
-		                  url_local_part, message);
+		if (res.error() == duckdb_httplib::Error::Success) {
+			throw HTTPException(res.value(), "Failed to download extension \"%s\" at URL \"%s%s\"\n%s", extension_name,
+			                    url_base, url_local_part, message);
+		} else {
+			throw IOException("Failed to download extension \"%s\" at URL \"%s%s\"\n%s (ERROR %s)", extension_name,
+			                  url_base, url_local_part, message, to_string(res.error()));
+		}
 	}
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
 	std::ofstream out(temp_path, std::ios::binary);

package/src/duckdb/src/main/prepared_statement.cpp

@@ -23,6 +23,10 @@ const string &PreparedStatement::GetError() {
 	return error.Message();
 }
 
+PreservedError &PreparedStatement::GetErrorObject() {
+	return error;
+}
+
 bool PreparedStatement::HasError() const {
 	return !success;
 }

package/src/duckdb/src/main/query_profiler.cpp

@@ -1,21 +1,23 @@
 #include "duckdb/main/query_profiler.hpp"
-#include "duckdb/common/to_string.hpp"
+
 #include "duckdb/common/fstream.hpp"
+#include "duckdb/common/http_state.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-#include "duckdb/common/http_stats.hpp"
+#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/limits.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/execution/operator/helper/physical_execute.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
-#include <utility>
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+
 #include <algorithm>
+#include <utility>
 
 namespace duckdb {
 
@@ -377,15 +379,15 @@ void QueryProfiler::QueryTreeToStream(std::ostream &ss) const {
 		return;
 	}
 
-	if (context.client_data->http_stats && !context.client_data->http_stats->IsEmpty()) {
+	if (context.client_data->http_state && !context.client_data->http_state->IsEmpty()) {
 		string read =
-		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_received);
+		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_received);
 		string written =
-		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_sent);
-		string head = "#HEAD: " + to_string(context.client_data->http_stats->head_count);
-		string get = "#GET: " + to_string(context.client_data->http_stats->get_count);
-		string put = "#PUT: " + to_string(context.client_data->http_stats->put_count);
-		string post = "#POST: " + to_string(context.client_data->http_stats->post_count);
+		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_sent);
+		string head = "#HEAD: " + to_string(context.client_data->http_state->head_count);
+		string get = "#GET: " + to_string(context.client_data->http_state->get_count);
+		string put = "#PUT: " + to_string(context.client_data->http_state->put_count);
+		string post = "#POST: " + to_string(context.client_data->http_state->post_count);
 
 		constexpr idx_t TOTAL_BOX_WIDTH = 39;
 		ss << "┌─────────────────────────────────────┐\n";

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -7,15 +7,15 @@
 
 namespace duckdb {
 
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)) {
+ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type)
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_unique<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select));
+	ExplainStatement explain(std::move(select), type);
 	return binder.Bind((SQLStatement &)explain);
 }
 

package/src/duckdb/src/main/relation.cpp

@@ -25,6 +25,7 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/main/relation/join_relation.hpp"
 #include "duckdb/main/relation/value_relation.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 namespace duckdb {
 
@@ -303,8 +304,8 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 	return Query(sql);
 }
 
-unique_ptr<QueryResult> Relation::Explain() {
-	auto explain = make_shared<ExplainRelation>(shared_from_this());
+unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
+	auto explain = make_shared<ExplainRelation>(shared_from_this(), type);
 	return explain->Execute();
 }
 

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -57,6 +57,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		analyzer.VisitOperator(*op.children[0]);
 		return;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (everything_referenced) {

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -424,7 +424,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 			parent_expr =
 			    make_unique<BoundColumnRefExpression>(parent_expr->alias, parent_expr->return_type, it->first);
 			parent_cond.comparison =
-			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisionExpression(child_cond.comparison);
+			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisonExpression(child_cond.comparison);
 			break;
 		}
 	}

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -604,7 +604,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 
 		// create the ExpressionValueInformation
 		ExpressionValueInformation info;
-		info.comparison_type = left_is_scalar ? FlipComparisionExpression(comparison.type) : comparison.type;
+		info.comparison_type = left_is_scalar ? FlipComparisonExpression(comparison.type) : comparison.type;
 		info.constant = constant_value;
 
 		// get the current bucket of constant values

package/src/duckdb/src/optimizer/filter_pullup.cpp

@@ -14,6 +14,7 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 		return PullupJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
@@ -31,7 +32,8 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 
 unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	auto &join = (LogicalJoin &)*op;
 
 	switch (join.join_type) {

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -23,6 +23,7 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 		return PushdownCrossProduct(std::move(op));
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		return PushdownJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_PROJECTION:
@@ -48,7 +49,8 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	auto &join = (LogicalJoin &)*op;
 	unordered_set<idx_t> left_bindings, right_bindings;
 	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
@@ -105,13 +107,7 @@ void FilterPushdown::GenerateFilters() {
 	});
 }
 
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(std::move(child));
-	}
-	// now push any existing filters
+unique_ptr<LogicalOperator> FilterPushdown::PushFinalFilters(unique_ptr<LogicalOperator> op) {
 	if (filters.empty()) {
 		// no filters to push
 		return op;
@@ -124,6 +120,16 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	return std::move(filter);
 }
 
+unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
+	// unhandled type, first perform filter pushdown in its children
+	for (auto &child : op->children) {
+		FilterPushdown pushdown(optimizer);
+		child = pushdown.Rewrite(std::move(child));
+	}
+	// now push any existing filters
+	return PushFinalFilters(std::move(op));
+}
+
 void FilterPushdown::Filter::ExtractBindings() {
 	bindings.clear();
 	LogicalJoin::GetExpressionBindings(*filter, bindings);