duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -33,9 +33,14 @@
 #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/delete_statement.hpp"
+#include "duckdb/parser/statement/insert_statement.hpp"
+#include "duckdb/parser/statement/merge_into_statement.hpp"
+#include "duckdb/parser/statement/update_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/parser/tableref/column_data_ref.hpp"
 #include "duckdb/planner/operator/logical_execute.hpp"
 #include "duckdb/planner/planner.hpp"
 #include "duckdb/planner/pragma_handler.hpp"
@@ -44,6 +49,8 @@
 #include "duckdb/transaction/transaction_context.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/logging/log_type.hpp"
+#include "duckdb/logging/log_manager.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -210,22 +217,20 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu
 		state->QueryBegin(*this);
 	}
 
-	// Flush the old Logger
+	// Flush the old logger.
 	logger->Flush();
 
-	// Refresh the logger to ensure we are in sync with global log settings
-	LoggingContext context(LogContextScope::CONNECTION);
-	context.connection_id = connection_id;
-	context.transaction_id = transaction.ActiveTransaction().global_transaction_id;
-	context.query_id = transaction.GetActiveQuery();
-	logger = db->GetLogManager().CreateLogger(context, true);
+	// Refresh the logger to ensure we are in sync with the global log settings.
+	LoggingContext logging_context(LogContextScope::CONNECTION);
+	logging_context.connection_id = connection_id;
+	logging_context.transaction_id = transaction.ActiveTransaction().global_transaction_id;
+	logging_context.query_id = transaction.GetActiveQuery();
+	logger = db->GetLogManager().CreateLogger(logging_context, true);
 	DUCKDB_LOG(*this, QueryLogType, query);
 }
 
 ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction,
                                           optional_ptr<ErrorData> previous_error) {
-	client_data->profiler->EndQuery();
-
 	if (active_query->executor) {
 		active_query->executor->CancelTasks();
 	}
@@ -258,6 +263,8 @@ ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success,
 		error = ErrorData("Unhandled exception!");
 	} // LCOV_EXCL_STOP
 
+	client_data->profiler->EndQuery();
+
 	// Refresh the logger
 	logger->Flush();
 	LoggingContext context(LogContextScope::CONNECTION);
@@ -272,7 +279,6 @@ ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success,
 			s->QueryEnd(*this, previous_error);
 		}
 	}
-
 	return error;
 }
 
@@ -489,13 +495,15 @@ void ClientContext::CheckIfPreparedStatementIsExecutable(PreparedStatementData &
 	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
 		throw ErrorManager::InvalidatedTransaction(*this);
 	}
+
 	auto &meta_transaction = MetaTransaction::Get(*this);
 	auto &manager = DatabaseManager::Get(*this);
 	for (auto &it : statement.properties.modified_databases) {
 		auto &modified_database = it.first;
 		auto entry = manager.GetDatabase(*this, modified_database);
 		if (!entry) {
-			throw InternalException("Database \"%s\" not found", modified_database);
+			// database has been detached
+			throw InvalidInputException("Database \"%s\" not found", modified_database);
 		}
 		if (entry->IsReadOnly()) {
 			throw InvalidInputException(StringUtil::Format(
@@ -507,19 +515,21 @@ void ClientContext::CheckIfPreparedStatementIsExecutable(PreparedStatementData &
 }
 
 unique_ptr<PendingQueryResult>
-ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock, shared_ptr<PreparedStatementData> statement_p,
+ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock,
+                                                shared_ptr<PreparedStatementData> statement_data_p,
                                                 const PendingQueryParameters &parameters) {
 	D_ASSERT(active_query);
-	auto &statement = *statement_p;
-
-	BindPreparedStatementParameters(statement, parameters);
+	auto &statement_data = *statement_data_p;
+	BindPreparedStatementParameters(statement_data, parameters);
 
+	// Create the query executor.
 	active_query->executor = make_uniq<Executor>(*this);
 	auto &executor = *active_query->executor;
+
 	if (config.enable_progress_bar) {
 		progress_bar_display_create_func_t display_create_func = nullptr;
 		if (config.print_progress_bar) {
-			// If a custom display is set, use that, otherwise just use the default
+			// Use either a custom display function, or the default.
 			display_create_func =
 			    config.display_create_func ? config.display_create_func : ProgressBar::DefaultProgressBarDisplay;
 		}
@@ -528,25 +538,29 @@ ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock, shared_
 		active_query->progress_bar->Start();
 		query_progress.Restart();
 	}
-	auto stream_result = parameters.allow_stream_result && statement.properties.allow_stream_result;
 
-	get_result_collector_t get_method = PhysicalResultCollector::GetResultCollector;
+	auto stream_result = parameters.allow_stream_result && statement_data.properties.allow_stream_result;
+
+	// Decide how to get the result collector.
+	get_result_collector_t get_collector = PhysicalResultCollector::GetResultCollector;
 	auto &client_config = ClientConfig::GetConfig(*this);
-	if (!stream_result && client_config.result_collector) {
-		get_method = client_config.result_collector;
+	if (!stream_result && client_config.get_result_collector) {
+		get_collector = client_config.get_result_collector;
 	}
-	statement.is_streaming = stream_result;
-	auto collector = get_method(*this, statement);
-	D_ASSERT(collector->type == PhysicalOperatorType::RESULT_COLLECTOR);
-	executor.Initialize(std::move(collector));
+	statement_data.is_streaming = stream_result;
+
+	// Get the result collector and initialize the executor.
+	auto &collector = get_collector(*this, statement_data);
+	D_ASSERT(collector.type == PhysicalOperatorType::RESULT_COLLECTOR);
+	executor.Initialize(collector);
 
 	auto types = executor.GetTypes();
-	D_ASSERT(types == statement.types);
+	D_ASSERT(types == statement_data.types);
 	D_ASSERT(!active_query->HasOpenResult());
 
 	auto pending_result =
-	    make_uniq<PendingQueryResult>(shared_from_this(), *statement_p, std::move(types), stream_result);
-	active_query->prepared = std::move(statement_p);
+	    make_uniq<PendingQueryResult>(shared_from_this(), *statement_data_p, std::move(types), stream_result);
+	active_query->prepared = std::move(statement_data_p);
 	active_query->SetOpenResult(*pending_result);
 	return pending_result;
 }
@@ -634,13 +648,19 @@ vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(const string &qu
 }
 
 vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientContextLock &lock, const string &query) {
-	Parser parser(GetParserOptions());
-	parser.ParseQuery(query);
+	try {
+		Parser parser(GetParserOptions());
+		parser.ParseQuery(query);
 
-	PragmaHandler handler(*this);
-	handler.HandlePragmaStatements(lock, parser.statements);
+		PragmaHandler handler(*this);
+		handler.HandlePragmaStatements(lock, parser.statements);
 
-	return std::move(parser.statements);
+		return std::move(parser.statements);
+	} catch (std::exception &ex) {
+		auto error = ErrorData(ex);
+		ProcessError(error, query);
+		error.Throw();
+	}
 }
 
 void ClientContext::HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements) {
@@ -816,8 +836,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		statement = statement->Copy();
 	}
 #endif
-	// check if we are on AutoCommit. In this case we should start a transaction.
-	if (statement && config.AnyVerification()) {
+	if (statement && config.query_verification_enabled) {
 		// query verification is enabled
 		// create a copy of the statement, and use the copy
 		// this way we verify that the copy correctly copies all properties
@@ -870,6 +889,10 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
     shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	unique_ptr<PendingQueryResult> pending;
 
+	// Start the profiler.
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+
 	try {
 		BeginQueryInternal(lock, query);
 	} catch (std::exception &ex) {
@@ -881,9 +904,6 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		}
 		return ErrorResult<PendingQueryResult>(std::move(error), query);
 	}
-	// start the profiler
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
 
 	bool invalidate_query = true;
 	try {
@@ -949,10 +969,11 @@ unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement,
 unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_stream_result) {
 	auto lock = LockContext();
 
-	ErrorData error;
 	vector<unique_ptr<SQLStatement>> statements;
-	if (!ParseStatements(*lock, query, statements, error)) {
-		return ErrorResult<MaterializedQueryResult>(std::move(error), query);
+	try {
+		statements = ParseStatements(*lock, query);
+	} catch (const std::exception &ex) {
+		return ErrorResult<MaterializedQueryResult>(ErrorData(ex), query);
 	}
 	if (statements.empty()) {
 		// no statements, return empty successful result
@@ -979,6 +1000,12 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 		} else {
 			current_result = ExecutePendingQueryInternal(*lock, *pending_query);
 		}
+		if (current_result->HasError()) {
+			// Reset the interrupted flag, this was set by the task that found the error
+			// Next statements should not be bothered by that interruption
+			interrupted = false;
+			return current_result;
+		}
 		// now append the result to the list of results
 		if (!last_result || !last_had_result) {
 			// first result of the query
@@ -995,27 +1022,14 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 			last_result = last_result->next.get();
 		}
 		D_ASSERT(last_result);
-		if (last_result->HasError()) {
-			// Reset the interrupted flag, this was set by the task that found the error
-			// Next statements should not be bothered by that interruption
-			interrupted = false;
-			break;
-		}
 	}
 	return result;
 }
 
-bool ClientContext::ParseStatements(ClientContextLock &lock, const string &query,
-                                    vector<unique_ptr<SQLStatement>> &result, ErrorData &error) {
-	try {
-		InitialCleanup(lock);
-		// parse the query and transform it into a set of statements
-		result = ParseStatementsInternal(lock, query);
-		return true;
-	} catch (std::exception &ex) {
-		error = ErrorData(ex);
-		return false;
-	}
+vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(ClientContextLock &lock, const string &query) {
+	InitialCleanup(lock);
+	// parse the query and transform it into a set of statements
+	return ParseStatementsInternal(lock, query);
 }
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query, bool allow_stream_result) {
@@ -1136,6 +1150,7 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co
 	    ValidChecker::IsInvalidated(ActiveTransaction())) {
 		throw TransactionException(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
+
 	// check if we are on AutoCommit. In this case we should start a transaction
 	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
 	if (require_new_transaction) {
@@ -1196,32 +1211,86 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 	return TableInfo(INVALID_CATALOG, schema_name, table_name);
 }
 
+CommonTableExpressionMap &GetCTEMap(SQLStatement &statement) {
+	switch (statement.type) {
+	case StatementType::INSERT_STATEMENT:
+		return statement.Cast<InsertStatement>().cte_map;
+	case StatementType::DELETE_STATEMENT:
+		return statement.Cast<DeleteStatement>().cte_map;
+	case StatementType::UPDATE_STATEMENT:
+		return statement.Cast<UpdateStatement>().cte_map;
+	case StatementType::MERGE_INTO_STATEMENT:
+		return statement.Cast<MergeIntoStatement>().cte_map;
+	default:
+		throw InvalidInputException(
+		    "Unsupported statement type for appender: expected INSERT, DELETE, UPDATE or MERGE INTO");
+	}
+}
+
+void ClientContext::Append(ColumnDataCollection &collection, const string &query, const vector<string> &column_names,
+                           const string &collection_name) {
+	// create the CTE for the appender
+	string alias = collection_name.empty() ? "appended_data" : collection_name;
+	auto column_data_ref = make_uniq<ColumnDataRef>(collection);
+	column_data_ref->alias = alias;
+	column_data_ref->expected_names = column_names;
+	auto cte = make_uniq<SelectNode>();
+	cte->select_list.push_back(make_uniq<StarExpression>());
+	cte->from_table = std::move(column_data_ref);
+	auto cte_select = make_uniq<SelectStatement>();
+	cte_select->node = std::move(cte);
+
+	// parse the query
+	Parser parser;
+	parser.ParseQuery(query);
+
+	// must be a single statement with CTEs
+	if (parser.statements.size() != 1) {
+		throw InvalidInputException("Expected exactly 1 query for appending data");
+	}
+
+	// add the appender data as a CTE to the cte map
+	auto &cte_map = GetCTEMap(*parser.statements[0]);
+	auto cte_info = make_uniq<CommonTableExpressionInfo>();
+	cte_info->query = std::move(cte_select);
+	cte_info->materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
+
+	cte_map.map.insert(alias, std::move(cte_info));
+
+	// now we have the query - run it in a transaction
+	auto result = Query(std::move(parser.statements[0]), false);
+	if (result->HasError()) {
+		result->GetErrorObject().Throw("Failed to append: ");
+	}
+}
+
 void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection,
                            optional_ptr<const vector<LogicalIndex>> column_ids) {
-
-	RunFunctionInTransaction([&]() {
-		auto &table_entry =
-		    Catalog::GetEntry<TableCatalogEntry>(*this, description.database, description.schema, description.table);
-		// verify that the table columns and types match up
-		if (description.PhysicalColumnCount() != table_entry.GetColumns().PhysicalColumnCount()) {
-			throw InvalidInputException("Failed to append: table entry has different number of columns!");
-		}
-		idx_t table_entry_col_idx = 0;
-		for (idx_t i = 0; i < description.columns.size(); i++) {
-			auto &column = description.columns[i];
-			if (column.Generated()) {
-				continue;
-			}
-			if (column.Type() != table_entry.GetColumns().GetColumn(PhysicalIndex(table_entry_col_idx)).Type()) {
-				throw InvalidInputException("Failed to append: table entry has different number of columns!");
+	string table_name = "__duckdb_internal_appended_data";
+	string query = "INSERT INTO ";
+	if (!description.database.empty()) {
+		query += StringUtil::Format("%s.", SQLIdentifier(description.database));
+	}
+	if (!description.schema.empty()) {
+		query += StringUtil::Format("%s.", SQLIdentifier(description.schema));
+	}
+	query += StringUtil::Format("%s", SQLIdentifier(description.table));
+	if (column_ids && !column_ids->empty()) {
+		query += "(";
+		auto &ids = *column_ids;
+		for (idx_t i = 0; i < ids.size(); i++) {
+			if (i > 0) {
+				query += ", ";
 			}
-			table_entry_col_idx++;
+			auto &col_name = description.columns[ids[i].index].Name();
+			query += StringUtil::Format("%s", SQLIdentifier(col_name));
 		}
-		auto binder = Binder::CreateBinder(*this);
-		auto bound_constraints = binder->BindConstraints(table_entry);
-		MetaTransaction::Get(*this).ModifyDatabase(table_entry.ParentCatalog().GetAttached());
-		table_entry.GetStorage().LocalAppend(table_entry, *this, collection, bound_constraints, column_ids);
-	});
+		query += ")";
+	}
+	query += " FROM ";
+	query += table_name;
+	vector<string> column_names;
+	Append(collection, query, column_names, table_name);
 }
 
 void ClientContext::InternalTryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns) {
@@ -1338,15 +1407,7 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 	return ErrorResult<MaterializedQueryResult>(ErrorData(err_str));
 }
 
-SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) const {
-	// first check the built-in settings
-	auto &db_config = DBConfig::GetConfig(*this);
-	auto option = db_config.GetOptionByName(key);
-	if (option) {
-		result = option->get_setting(*this);
-		return SettingLookupResult(SettingScope::LOCAL);
-	}
-
+SettingLookupResult ClientContext::TryGetCurrentSettingInternal(const string &key, Value &result) const {
 	// check the client session values
 	const auto &session_config_map = config.set_variables;
 
@@ -1360,11 +1421,26 @@ SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key,
 	return db->TryGetCurrentSetting(key, result);
 }
 
+SettingLookupResult ClientContext::TryGetCurrentSetting(const string &key, Value &result) const {
+	// first check the built-in settings
+	auto &db_config = DBConfig::GetConfig(*this);
+	auto option = db_config.GetOptionByName(key);
+	if (option) {
+		if (option->get_setting) {
+			result = option->get_setting(*this);
+			return SettingLookupResult(SettingScope::LOCAL);
+		}
+		// alias - search for the default key
+		return TryGetCurrentSettingInternal(option->name, result);
+	}
+	return TryGetCurrentSettingInternal(key, result);
+}
+
 ParserOptions ClientContext::GetParserOptions() const {
 	auto &client_config = ClientConfig::GetConfig(*this);
 	ParserOptions options;
-	options.preserve_identifier_case = client_config.preserve_identifier_case;
-	options.integer_division = client_config.integer_division;
+	options.preserve_identifier_case = DBConfig::GetSetting<PreserveIdentifierCaseSetting>(*this);
+	options.integer_division = DBConfig::GetSetting<IntegerDivisionSetting>(*this);
 	options.max_expression_depth = client_config.max_expression_depth;
 	options.extensions = &DBConfig::GetConfig(*this).parser_extensions;
 	return options;
@@ -1377,12 +1453,20 @@ ClientProperties ClientContext::GetClientProperties() {
 	if (TryGetCurrentSetting("TimeZone", result)) {
 		timezone = result.ToString();
 	}
+	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
+	if (DBConfig::GetSetting<ArrowLargeBufferSizeSetting>(*this)) {
+		arrow_offset_size = ArrowOffsetSize::LARGE;
+	}
+	bool arrow_use_list_view = DBConfig::GetSetting<ArrowOutputListViewSetting>(*this);
+	bool arrow_lossless_conversion = DBConfig::GetSetting<ArrowLosslessConversionSetting>(*this);
+	bool arrow_use_string_view = DBConfig::GetSetting<ProduceArrowStringViewSetting>(*this);
+	auto arrow_format_version = DBConfig::GetSetting<ArrowOutputVersionSetting>(*this);
 	return {timezone,
-	        db->config.options.arrow_offset_size,
-	        db->config.options.arrow_use_list_view,
-	        db->config.options.produce_arrow_string_views,
-	        db->config.options.arrow_lossless_conversion,
-	        db->config.options.arrow_output_version,
+	        arrow_offset_size,
+	        arrow_use_list_view,
+	        arrow_use_string_view,
+	        arrow_lossless_conversion,
+	        arrow_format_version,
 	        this};
 }
 

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/common/file_opener.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 namespace duckdb {
 

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

@@ -1,6 +1,5 @@
 #include "duckdb/main/client_data.hpp"
 
-#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/common/opener_file_system.hpp"
 #include "duckdb/common/random_engine.hpp"
@@ -11,6 +10,7 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/query_profiler.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
 
@@ -32,14 +32,152 @@ private:
 	ClientContext &context;
 };
 
+//! ClientBufferManager wraps the buffer manager to optionally forward the client context.
+class ClientBufferManager : public BufferManager {
+public:
+	explicit ClientBufferManager(BufferManager &buffer_manager_p) : buffer_manager(buffer_manager_p) {
+	}
+
+public:
+	shared_ptr<BlockHandle> AllocateTemporaryMemory(MemoryTag tag, idx_t block_size, bool can_destroy = true) override {
+		return buffer_manager.AllocateTemporaryMemory(tag, block_size, can_destroy);
+	}
+	shared_ptr<BlockHandle> AllocateMemory(MemoryTag tag, BlockManager *block_manager,
+	                                       bool can_destroy = true) override {
+		return buffer_manager.AllocateMemory(tag, block_manager, can_destroy);
+	}
+	BufferHandle Allocate(MemoryTag tag, idx_t block_size, bool can_destroy = true) override {
+		return buffer_manager.Allocate(tag, block_size, can_destroy);
+	}
+	BufferHandle Allocate(MemoryTag tag, BlockManager *block_manager, bool can_destroy = true) override {
+		return buffer_manager.Allocate(tag, block_manager, can_destroy);
+	}
+	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) override {
+		return buffer_manager.ReAllocate(handle, block_size);
+	}
+	BufferHandle Pin(shared_ptr<BlockHandle> &handle) override {
+		return buffer_manager.Pin(handle);
+	}
+	void Prefetch(vector<shared_ptr<BlockHandle>> &handles) override {
+		return buffer_manager.Prefetch(handles);
+	}
+	void Unpin(shared_ptr<BlockHandle> &handle) override {
+		return buffer_manager.Unpin(handle);
+	}
+
+	idx_t GetUsedMemory() const override {
+		return buffer_manager.GetUsedMemory();
+	}
+	idx_t GetMaxMemory() const override {
+		return buffer_manager.GetMaxMemory();
+	}
+	idx_t GetUsedSwap() const override {
+		return buffer_manager.GetUsedSwap();
+	}
+	optional_idx GetMaxSwap() const override {
+		return buffer_manager.GetMaxSwap();
+	}
+	idx_t GetBlockAllocSize() const override {
+		return buffer_manager.GetBlockAllocSize();
+	}
+	idx_t GetBlockSize() const override {
+		return buffer_manager.GetBlockSize();
+	}
+	idx_t GetQueryMaxMemory() const override {
+		return buffer_manager.GetQueryMaxMemory();
+	}
+
+	shared_ptr<BlockHandle> RegisterTransientMemory(const idx_t size, BlockManager &block_manager) override {
+		return buffer_manager.RegisterTransientMemory(size, block_manager);
+	}
+	shared_ptr<BlockHandle> RegisterSmallMemory(const idx_t size) override {
+		return buffer_manager.RegisterSmallMemory(size);
+	}
+	shared_ptr<BlockHandle> RegisterSmallMemory(MemoryTag tag, const idx_t size) override {
+		return buffer_manager.RegisterSmallMemory(tag, size);
+	}
+
+	Allocator &GetBufferAllocator() override {
+		return buffer_manager.GetBufferAllocator();
+	}
+	void ReserveMemory(idx_t size) override {
+		return buffer_manager.ReserveMemory(size);
+	}
+	void FreeReservedMemory(idx_t size) override {
+		return buffer_manager.FreeReservedMemory(size);
+	}
+	vector<MemoryInformation> GetMemoryUsageInfo() const override {
+		return buffer_manager.GetMemoryUsageInfo();
+	}
+	void SetMemoryLimit(idx_t limit = (idx_t)-1) override {
+		return buffer_manager.SetMemoryLimit(limit);
+	}
+	void SetSwapLimit(optional_idx limit = optional_idx()) override {
+		return buffer_manager.SetSwapLimit(limit);
+	}
+
+	vector<TemporaryFileInformation> GetTemporaryFiles() override {
+		return buffer_manager.GetTemporaryFiles();
+	}
+	const string &GetTemporaryDirectory() const override {
+		return buffer_manager.GetTemporaryDirectory();
+	}
+	void SetTemporaryDirectory(const string &new_dir) override {
+		return buffer_manager.SetTemporaryDirectory(new_dir);
+	}
+	bool HasTemporaryDirectory() const override {
+		return buffer_manager.HasTemporaryDirectory();
+	}
+	bool HasFilesInTemporaryDirectory() const override {
+		return buffer_manager.HasFilesInTemporaryDirectory();
+	}
+
+	unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, idx_t block_header_size, unique_ptr<FileBuffer> &&source,
+	                                              FileBufferType type = FileBufferType::MANAGED_BUFFER) override {
+		return buffer_manager.ConstructManagedBuffer(size, block_header_size, std::move(source), type);
+	}
+	BufferPool &GetBufferPool() const override {
+		return buffer_manager.GetBufferPool();
+	}
+	DatabaseInstance &GetDatabase() override {
+		return buffer_manager.GetDatabase();
+	}
+	TemporaryMemoryManager &GetTemporaryMemoryManager() override {
+		return buffer_manager.GetTemporaryMemoryManager();
+	}
+
+	void PurgeQueue(const BlockHandle &handle) override {
+		return buffer_manager.PurgeQueue(handle);
+	}
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle) override {
+		return buffer_manager.AddToEvictionQueue(handle);
+	}
+	void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) override {
+		return buffer_manager.WriteTemporaryBuffer(tag, block_id, buffer);
+	}
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(QueryContext context, MemoryTag tag, BlockHandle &block,
+	                                           unique_ptr<FileBuffer> buffer) override {
+		return buffer_manager.ReadTemporaryBuffer(context, tag, block, std::move(buffer));
+	}
+	void DeleteTemporaryFile(BlockHandle &block) override {
+		return buffer_manager.DeleteTemporaryFile(block);
+	}
+
+private:
+	BufferManager &buffer_manager;
+};
+
 ClientData::ClientData(ClientContext &context) : catalog_search_path(make_uniq<CatalogSearchPath>(context)) {
 	auto &db = DatabaseInstance::GetDatabase(context);
+
 	profiler = make_shared_ptr<QueryProfiler>(context);
 	temporary_objects = make_shared_ptr<AttachedDatabase>(db, AttachedDatabaseType::TEMP_DATABASE);
 	temporary_objects->oid = DatabaseManager::Get(db).NextOid();
 	random_engine = make_uniq<RandomEngine>();
 	file_opener = make_uniq<ClientContextFileOpener>(context);
 	client_file_system = make_uniq<ClientFileSystem>(context);
+	client_buffer_manager = make_uniq<ClientBufferManager>(db.GetBufferManager());
+
 	temporary_objects->Initialize();
 }
 

package/src/duckdb/src/main/client_verify.cpp

@@ -148,12 +148,20 @@ ErrorData ClientContext::VerifyQuery(ClientContextLock &lock, const string &quer
 		auto original_named_param_map = statement_copy_for_explain->named_param_map;
 		auto explain_stmt = make_uniq<ExplainStatement>(std::move(statement_copy_for_explain));
 		explain_stmt->named_param_map = original_named_param_map;
-		try {
-			RunStatementInternal(lock, explain_q, std::move(explain_stmt), false, parameters, false);
-		} catch (std::exception &ex) { // LCOV_EXCL_START
-			ErrorData error(ex);
-			interrupted = false;
-			return ErrorData("EXPLAIN failed but query did not (" + error.RawMessage() + ")");
+
+		auto explain_statement_verifier =
+		    StatementVerifier::Create(VerificationType::EXPLAIN, *explain_stmt, parameters);
+		const auto explain_failed = explain_statement_verifier->Run(
+		    *this, explain_q,
+		    [&](const string &q, unique_ptr<SQLStatement> s,
+		        optional_ptr<case_insensitive_map_t<BoundParameterData>> params) {
+			    return RunStatementInternal(lock, q, std::move(s), false, params, false);
+		    });
+
+		if (explain_failed) { // LCOV_EXCL_START
+			const auto &explain_error = explain_statement_verifier->materialized_result->error;
+			return ErrorData(explain_error.Type(), StringUtil::Format("Query succeeded but EXPLAIN failed with: %s",
+			                                                          explain_error.RawMessage()));
 		} // LCOV_EXCL_STOP
 
 #ifdef DUCKDB_VERIFY_BOX_RENDERER