duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -64,7 +64,7 @@ struct ActiveQueryContext {
 };
 
 ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : db(move(database)), interrupted(false), client_data(make_unique<ClientData>(*this)), transaction(*this) {
+    : db(std::move(database)), interrupted(false), client_data(make_unique<ClientData>(*this)), transaction(*this) {
 }
 
 ClientContext::~ClientContext() {
@@ -166,12 +166,14 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 	}
 
 	D_ASSERT(active_query.get());
+	active_query.reset();
+	query_progress = -1;
 	PreservedError error;
 	try {
 		if (transaction.HasActiveTransaction()) {
 			// Move the query profiler into the history
 			auto &prev_profilers = client_data->query_profiler_history->GetPrevProfilers();
-			prev_profilers.emplace_back(transaction.GetActiveQuery(), move(client_data->profiler));
+			prev_profilers.emplace_back(transaction.GetActiveQuery(), std::move(client_data->profiler));
 			// Reinitialize the query profiler
 			client_data->profiler = make_shared<QueryProfiler>(*this);
 			// Propagate settings of the saved query into the new profiler.
@@ -203,8 +205,6 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 	} catch (...) { // LCOV_EXCL_START
 		error = PreservedError("Unhandled exception!");
 	} // LCOV_EXCL_STOP
-	active_query.reset();
-	query_progress = -1;
 	return error;
 }
 
@@ -258,7 +258,7 @@ unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lo
 		auto stream_result = make_unique<StreamQueryResult>(pending.statement_type, pending.properties,
 		                                                    shared_from_this(), pending.types, pending.names);
 		active_query->open_result = stream_result.get();
-		return move(stream_result);
+		return std::move(stream_result);
 	}
 	unique_ptr<QueryResult> result;
 	if (executor.HasResultCollector()) {
@@ -269,8 +269,9 @@ unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lo
 		// no result collector - create a materialized result by continuously fetching
 		auto result_collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), pending.types);
 		D_ASSERT(!result_collection->Types().empty());
-		auto materialized_result = make_unique<MaterializedQueryResult>(
-		    pending.statement_type, pending.properties, pending.names, move(result_collection), GetClientProperties());
+		auto materialized_result =
+		    make_unique<MaterializedQueryResult>(pending.statement_type, pending.properties, pending.names,
+		                                         std::move(result_collection), GetClientProperties());
 
 		auto &collection = materialized_result->Collection();
 		D_ASSERT(!collection.Types().empty());
@@ -290,7 +291,7 @@ unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lo
 #endif
 			collection.Append(append_state, *chunk);
 		}
-		result = move(materialized_result);
+		result = std::move(materialized_result);
 	}
 	return result;
 }
@@ -321,16 +322,16 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 			planner.parameter_data.emplace_back(value);
 		}
 	}
-	planner.CreatePlan(move(statement));
+	planner.CreatePlan(std::move(statement));
 	D_ASSERT(planner.plan || !planner.properties.bound_all_parameters);
 	profiler.EndPhase();
 
-	auto plan = move(planner.plan);
+	auto plan = std::move(planner.plan);
 	// extract the result column names from the plan
 	result->properties = planner.properties;
 	result->names = planner.names;
 	result->types = planner.types;
-	result->value_map = move(planner.value_map);
+	result->value_map = std::move(planner.value_map);
 	result->catalog_version = MetaTransaction::Get(*this).catalog_version;
 
 	if (!planner.properties.bound_all_parameters) {
@@ -342,7 +343,7 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	if (config.enable_optimizer && plan->RequireOptimizer()) {
 		profiler.StartPhase("optimizer");
 		Optimizer optimizer(*planner.binder, *this);
-		plan = optimizer.Optimize(move(plan));
+		plan = optimizer.Optimize(std::move(plan));
 		D_ASSERT(plan);
 		profiler.EndPhase();
 
@@ -354,13 +355,13 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	profiler.StartPhase("physical_planner");
 	// now convert logical query plan into a physical query plan
 	PhysicalPlanGenerator physical_planner(*this);
-	auto physical_plan = physical_planner.CreatePlan(move(plan));
+	auto physical_plan = physical_planner.CreatePlan(std::move(plan));
 	profiler.EndPhase();
 
 #ifdef DEBUG
 	D_ASSERT(!physical_plan->ToString().empty());
 #endif
-	result->plan = move(physical_plan);
+	result->plan = std::move(physical_plan);
 	return result;
 }
 
@@ -415,7 +416,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 		    config.result_collector ? config.result_collector : PhysicalResultCollector::GetResultCollector;
 		collector = get_method(*this, statement);
 		D_ASSERT(collector->type == PhysicalOperatorType::RESULT_COLLECTOR);
-		executor.Initialize(move(collector));
+		executor.Initialize(std::move(collector));
 	} else {
 		executor.Initialize(statement.plan.get());
 	}
@@ -423,8 +424,9 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 	D_ASSERT(types == statement.types);
 	D_ASSERT(!active_query->open_result);
 
-	auto pending_result = make_unique<PendingQueryResult>(shared_from_this(), *statement_p, move(types), stream_result);
-	active_query->prepared = move(statement_p);
+	auto pending_result =
+	    make_unique<PendingQueryResult>(shared_from_this(), *statement_p, std::move(types), stream_result);
+	active_query->prepared = std::move(statement_p);
 	active_query->open_result = pending_result.get();
 	return pending_result;
 }
@@ -473,7 +475,7 @@ vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientCo
 	PragmaHandler handler(*this);
 	handler.HandlePragmaStatements(lock, parser.statements);
 
-	return move(parser.statements);
+	return std::move(parser.statements);
 }
 
 void ClientContext::HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements) {
@@ -494,14 +496,14 @@ unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
 	unique_ptr<LogicalOperator> plan;
 	RunFunctionInTransactionInternal(*lock, [&]() {
 		Planner planner(*this);
-		planner.CreatePlan(move(statements[0]));
+		planner.CreatePlan(std::move(statements[0]));
 		D_ASSERT(planner.plan);
 
-		plan = move(planner.plan);
+		plan = std::move(planner.plan);
 
 		if (config.enable_optimizer) {
 			Optimizer optimizer(*planner.binder, *this);
-			plan = optimizer.Optimize(move(plan));
+			plan = optimizer.Optimize(std::move(plan));
 		}
 
 		ColumnBindingResolver resolver;
@@ -516,15 +518,15 @@ unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
 unique_ptr<PreparedStatement> ClientContext::PrepareInternal(ClientContextLock &lock,
                                                              unique_ptr<SQLStatement> statement) {
 	auto n_param = statement->n_param;
-	auto named_param_map = move(statement->named_param_map);
+	auto named_param_map = std::move(statement->named_param_map);
 	auto statement_query = statement->query;
 	shared_ptr<PreparedStatementData> prepared_data;
 	auto unbound_statement = statement->Copy();
 	RunFunctionInTransactionInternal(
-	    lock, [&]() { prepared_data = CreatePreparedStatement(lock, statement_query, move(statement)); }, false);
-	prepared_data->unbound_statement = move(unbound_statement);
-	return make_unique<PreparedStatement>(shared_from_this(), move(prepared_data), move(statement_query), n_param,
-	                                      move(named_param_map));
+	    lock, [&]() { prepared_data = CreatePreparedStatement(lock, statement_query, std::move(statement)); }, false);
+	prepared_data->unbound_statement = std::move(unbound_statement);
+	return make_unique<PreparedStatement>(shared_from_this(), std::move(prepared_data), std::move(statement_query),
+	                                      n_param, std::move(named_param_map));
 }
 
 unique_ptr<PreparedStatement> ClientContext::Prepare(unique_ptr<SQLStatement> statement) {
@@ -532,7 +534,7 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(unique_ptr<SQLStatement> st
 	// prepare the query
 	try {
 		InitialCleanup(*lock);
-		return PrepareInternal(*lock, move(statement));
+		return PrepareInternal(*lock, std::move(statement));
 	} catch (const Exception &ex) {
 		return make_unique<PreparedStatement>(PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -554,7 +556,7 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
 		if (statements.size() > 1) {
 			throw Exception("Cannot prepare multiple statements at once!");
 		}
-		return PrepareInternal(*lock, move(statements[0]));
+		return PrepareInternal(*lock, std::move(statements[0]));
 	} catch (const Exception &ex) {
 		return make_unique<PreparedStatement>(PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -604,7 +606,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientCon
                                                                        unique_ptr<SQLStatement> statement,
                                                                        PendingQueryParameters parameters) {
 	// prepare the query for execution
-	auto prepared = CreatePreparedStatement(lock, query, move(statement), parameters.parameters);
+	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters);
 	if (prepared->properties.parameter_count > 0 && !parameters.parameters) {
 		string error_message = StringUtil::Format("Expected %lld parameters, but none were supplied",
 		                                          prepared->properties.parameter_count);
@@ -614,7 +616,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientCon
 		return make_unique<PendingQueryResult>(PreservedError("Not all parameters were bound"));
 	}
 	// execute the prepared statement
-	return PendingPreparedStatement(lock, move(prepared), parameters);
+	return PendingPreparedStatement(lock, std::move(prepared), parameters);
 }
 
 unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
@@ -622,7 +624,7 @@ unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &l
                                                             bool allow_stream_result, bool verify) {
 	PendingQueryParameters parameters;
 	parameters.allow_stream_result = allow_stream_result;
-	auto pending = PendingQueryInternal(lock, move(statement), parameters, verify);
+	auto pending = PendingQueryInternal(lock, std::move(statement), parameters, verify);
 	if (pending->HasError()) {
 		return make_unique<MaterializedQueryResult>(pending->GetErrorObject());
 	}
@@ -650,7 +652,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 			// in case this is a select query, we verify the original statement
 			PreservedError error;
 			try {
-				error = VerifyQuery(lock, query, move(statement));
+				error = VerifyQuery(lock, query, std::move(statement));
 			} catch (const Exception &ex) {
 				error = PreservedError(ex);
 			} catch (std::exception &ex) {
@@ -660,9 +662,10 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 				// error in verifying query
 				return make_unique<PendingQueryResult>(error);
 			}
-			statement = move(copied_statement);
+			statement = std::move(copied_statement);
 			break;
 		}
+		case StatementType::COPY_STATEMENT:
 		case StatementType::INSERT_STATEMENT:
 		case StatementType::DELETE_STATEMENT:
 		case StatementType::UPDATE_STATEMENT: {
@@ -679,15 +682,15 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 				// error in verifying query
 				return make_unique<PendingQueryResult>(error);
 			}
-			statement = move(parser.statements[0]);
+			statement = std::move(parser.statements[0]);
 			break;
 		}
 		default:
-			statement = move(copied_statement);
+			statement = std::move(copied_statement);
 			break;
 		}
 	}
-	return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, parameters);
+	return PendingStatementOrPreparedStatement(lock, query, std::move(statement), prepared, parameters);
 }
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatement(
@@ -719,15 +722,15 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 	bool invalidate_query = true;
 	try {
 		if (statement) {
-			result = PendingStatementInternal(lock, query, move(statement), parameters);
+			result = PendingStatementInternal(lock, query, std::move(statement), parameters);
 		} else {
 			if (prepared->RequireRebind(*this, *parameters.parameters)) {
 				// catalog was modified: rebind the statement before execution
 				auto new_prepared =
 				    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
 				D_ASSERT(new_prepared->properties.bound_all_parameters);
-				new_prepared->unbound_statement = move(prepared->unbound_statement);
-				prepared = move(new_prepared);
+				new_prepared->unbound_statement = std::move(prepared->unbound_statement);
+				prepared = std::move(new_prepared);
 				prepared->properties.bound_all_parameters = false;
 			}
 			result = PendingPreparedStatement(lock, prepared, parameters);
@@ -782,7 +785,7 @@ void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
 }
 
 unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	auto pending_query = PendingQuery(move(statement), allow_stream_result);
+	auto pending_query = PendingQuery(std::move(statement), allow_stream_result);
 	if (pending_query->HasError()) {
 		return make_unique<MaterializedQueryResult>(pending_query->GetErrorObject());
 	}
@@ -795,15 +798,15 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 	PreservedError error;
 	vector<unique_ptr<SQLStatement>> statements;
 	if (!ParseStatements(*lock, query, statements, error)) {
-		return make_unique<MaterializedQueryResult>(move(error));
+		return make_unique<MaterializedQueryResult>(std::move(error));
 	}
 	if (statements.empty()) {
 		// no statements, return empty successful result
 		StatementProperties properties;
 		vector<string> names;
 		auto collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator());
-		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT, properties, move(names),
-		                                            move(collection), GetClientProperties());
+		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT, properties, std::move(names),
+		                                            std::move(collection), GetClientProperties());
 	}
 
 	unique_ptr<QueryResult> result;
@@ -813,7 +816,7 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 		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, move(statement), parameters);
+		auto pending_query = PendingQueryInternal(*lock, std::move(statement), parameters);
 		unique_ptr<QueryResult> current_result;
 		if (pending_query->HasError()) {
 			current_result = make_unique<MaterializedQueryResult>(pending_query->GetErrorObject());
@@ -823,11 +826,11 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 		// now append the result to the list of results
 		if (!last_result) {
 			// first result of the query
-			result = move(current_result);
+			result = std::move(current_result);
 			last_result = result.get();
 		} else {
 			// later results; attach to the result chain
-			last_result->next = move(current_result);
+			last_result->next = std::move(current_result);
 			last_result = last_result->next.get();
 		}
 	}
@@ -856,14 +859,14 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
 	PreservedError error;
 	vector<unique_ptr<SQLStatement>> statements;
 	if (!ParseStatements(*lock, query, statements, error)) {
-		return make_unique<PendingQueryResult>(move(error));
+		return make_unique<PendingQueryResult>(std::move(error));
 	}
 	if (statements.size() != 1) {
 		return make_unique<PendingQueryResult>(PreservedError("PendingQuery can only take a single statement"));
 	}
 	PendingQueryParameters parameters;
 	parameters.allow_stream_result = allow_stream_result;
-	return PendingQueryInternal(*lock, move(statements[0]), parameters);
+	return PendingQueryInternal(*lock, std::move(statements[0]), parameters);
 }
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement,
@@ -871,7 +874,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStateme
 	auto lock = LockContext();
 	PendingQueryParameters parameters;
 	parameters.allow_stream_result = allow_stream_result;
-	return PendingQueryInternal(*lock, move(statement), parameters);
+	return PendingQueryInternal(*lock, std::move(statement), parameters);
 }
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
@@ -880,9 +883,9 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContext
 	auto query = statement->query;
 	shared_ptr<PreparedStatementData> prepared;
 	if (verify) {
-		return PendingStatementOrPreparedStatementInternal(lock, query, move(statement), prepared, parameters);
+		return PendingStatementOrPreparedStatementInternal(lock, query, std::move(statement), prepared, parameters);
 	} else {
-		return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, parameters);
+		return PendingStatementOrPreparedStatement(lock, query, std::move(statement), prepared, parameters);
 	}
 }
 
@@ -977,7 +980,7 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 		result = make_unique<TableDescription>();
 		result->schema = schema_name;
 		result->table = table_name;
-		for (auto &column : table->columns.Logical()) {
+		for (auto &column : table->GetColumns().Logical()) {
 			result->columns.emplace_back(column.Name(), column.Type());
 		}
 	});
@@ -989,15 +992,15 @@ void ClientContext::Append(TableDescription &description, ColumnDataCollection &
 		auto table_entry =
 		    Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, description.schema, description.table);
 		// verify that the table columns and types match up
-		if (description.columns.size() != table_entry->columns.PhysicalColumnCount()) {
+		if (description.columns.size() != table_entry->GetColumns().PhysicalColumnCount()) {
 			throw Exception("Failed to append: table entry has different number of columns!");
 		}
 		for (idx_t i = 0; i < description.columns.size(); i++) {
-			if (description.columns[i].Type() != table_entry->columns.GetColumn(PhysicalIndex(i)).Type()) {
+			if (description.columns[i].Type() != table_entry->GetColumns().GetColumn(PhysicalIndex(i)).Type()) {
 				throw Exception("Failed to append: table entry has different number of columns!");
 			}
 		}
-		table_entry->storage->LocalAppend(*table_entry, *this, collection);
+		table_entry->GetStorage().LocalAppend(*table_entry, *this, collection);
 	});
 }
 
@@ -1038,9 +1041,10 @@ unordered_set<string> ClientContext::GetTableNames(const string &query) {
 	return result;
 }
 
-unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relation) {
-	auto lock = LockContext();
-	InitialCleanup(*lock);
+unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
+                                                                   const shared_ptr<Relation> &relation,
+                                                                   bool allow_stream_result) {
+	InitialCleanup(lock);
 
 	string query;
 	if (config.query_verification_enabled) {
@@ -1051,14 +1055,32 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 			// verify read only statements by running a select statement
 			auto select = make_unique<SelectStatement>();
 			select->node = relation->GetQueryNode();
-			RunStatementInternal(*lock, query, move(select), false);
+			RunStatementInternal(lock, query, std::move(select), false);
 		}
 	}
-	auto &expected_columns = relation->Columns();
+
 	auto relation_stmt = make_unique<RelationStatement>(relation);
+	PendingQueryParameters parameters;
+	parameters.allow_stream_result = allow_stream_result;
+	return PendingQueryInternal(lock, std::move(relation_stmt), parameters);
+}
+
+unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const shared_ptr<Relation> &relation,
+                                                           bool allow_stream_result) {
+	auto lock = LockContext();
+	return PendingQueryInternal(*lock, relation, allow_stream_result);
+}
+
+unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relation) {
+	auto lock = LockContext();
+	auto &expected_columns = relation->Columns();
+	auto pending = PendingQueryInternal(*lock, relation, false);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(pending->GetErrorObject());
+	}
 
 	unique_ptr<QueryResult> result;
-	result = RunStatementInternal(*lock, query, move(relation_stmt), false);
+	result = ExecutePendingQueryInternal(*lock, *pending);
 	if (result->HasError()) {
 		return result;
 	}
@@ -1129,4 +1151,11 @@ ClientProperties ClientContext::GetClientProperties() const {
 	return properties;
 }
 
+bool ClientContext::ExecutionIsFinished() {
+	if (!active_query || !active_query->executor) {
+		return false;
+	}
+	return active_query->executor->ExecutionIsFinished();
+}
+
 } // namespace duckdb

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

@@ -8,4 +8,18 @@ bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &res
 	return context.TryGetCurrentSetting(key, result);
 }
 
+ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) {
+	if (!opener) {
+		return nullptr;
+	}
+	return opener->TryGetClientContext();
+}
+
+bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) {
+	if (!opener) {
+		return false;
+	}
+	return opener->TryGetCurrentSetting(key, result);
+}
+
 } // namespace duckdb

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

@@ -9,6 +9,7 @@
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -17,6 +18,7 @@ ClientData::ClientData(ClientContext &context) : catalog_search_path(make_unique
 	profiler = make_shared<QueryProfiler>(context);
 	query_profiler_history = make_unique<QueryProfilerHistory>();
 	temporary_objects = make_shared<AttachedDatabase>(db, AttachedDatabaseType::TEMP_DATABASE);
+	temporary_objects->oid = DatabaseManager::Get(db).ModifyCatalog();
 	random_engine = make_unique<RandomEngine>();
 	file_opener = make_unique<ClientContextFileOpener>(context);
 	temporary_objects->Initialize();

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

@@ -33,7 +33,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::EXTERNAL, stmt));
 	}
 
-	auto original = make_unique<StatementVerifier>(move(statement));
+	auto original = make_unique<StatementVerifier>(std::move(statement));
 	for (auto &verifier : statement_verifiers) {
 		original->CheckExpressions(*verifier);
 	}
@@ -54,7 +54,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 
 	// Execute the original statement
 	bool any_failed = original->Run(*this, query, [&](const string &q, unique_ptr<SQLStatement> s) {
-		return RunStatementInternal(lock, q, move(s), false, false);
+		return RunStatementInternal(lock, q, std::move(s), false, false);
 	});
 	if (!any_failed) {
 		statement_verifiers.emplace_back(
@@ -63,7 +63,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	// Execute the verifiers
 	for (auto &verifier : statement_verifiers) {
 		bool failed = verifier->Run(*this, query, [&](const string &q, unique_ptr<SQLStatement> s) {
-			return RunStatementInternal(lock, q, move(s), false, false);
+			return RunStatementInternal(lock, q, std::move(s), false, false);
 		});
 		any_failed = any_failed || failed;
 	}
@@ -71,11 +71,11 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	if (!any_failed && prepared_statement_verifier) {
 		// If none failed, we execute the prepared statement verifier
 		bool failed = prepared_statement_verifier->Run(*this, query, [&](const string &q, unique_ptr<SQLStatement> s) {
-			return RunStatementInternal(lock, q, move(s), false, false);
+			return RunStatementInternal(lock, q, std::move(s), false, false);
 		});
 		if (!failed) {
 			// PreparedStatementVerifier fails if it runs into a ParameterNotAllowedException, which is OK
-			statement_verifiers.push_back(move(prepared_statement_verifier));
+			statement_verifiers.push_back(std::move(prepared_statement_verifier));
 		}
 	} else {
 		if (ValidChecker::IsInvalidated(*db)) {
@@ -90,9 +90,9 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	// Check explain, only if q does not already contain EXPLAIN
 	if (original->materialized_result->success) {
 		auto explain_q = "EXPLAIN " + query;
-		auto explain_stmt = make_unique<ExplainStatement>(move(statement_copy_for_explain));
+		auto explain_stmt = make_unique<ExplainStatement>(std::move(statement_copy_for_explain));
 		try {
-			RunStatementInternal(lock, explain_q, move(explain_stmt), false, false);
+			RunStatementInternal(lock, explain_q, std::move(explain_stmt), false, false);
 		} catch (std::exception &ex) { // LCOV_EXCL_START
 			interrupted = false;
 			return PreservedError("EXPLAIN failed but query did not (" + string(ex.what()) + ")");

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/settings.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -58,6 +59,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(EnableExternalAccessSetting),
                                                  DUCKDB_GLOBAL(EnableFSSTVectors),
                                                  DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
+                                                 DUCKDB_LOCAL(CustomExtensionRepository),
                                                  DUCKDB_GLOBAL(EnableObjectCacheSetting),
                                                  DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting),
                                                  DUCKDB_LOCAL(EnableProfilingSetting),
@@ -143,6 +145,15 @@ void DBConfig::SetOption(const ConfigurationOption &option, const Value &value)
 	SetOption(nullptr, option, value);
 }
 
+void DBConfig::SetOptionByName(const string &name, const Value &value) {
+	auto option = DBConfig::GetOptionByName(name);
+	if (option) {
+		SetOption(*option, value);
+	} else {
+		options.unrecognized_options[name] = value;
+	}
+}
+
 void DBConfig::SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value) {
 	lock_guard<mutex> l(config_lock);
 	if (!option.set_global) {
@@ -164,7 +175,7 @@ void DBConfig::ResetOption(DatabaseInstance *db, const ConfigurationOption &opti
 
 void DBConfig::SetOption(const string &name, Value value) {
 	lock_guard<mutex> l(config_lock);
-	options.set_variables[name] = move(value);
+	options.set_variables[name] = std::move(value);
 }
 
 void DBConfig::ResetOption(const string &name) {
@@ -184,7 +195,7 @@ void DBConfig::ResetOption(const string &name) {
 void DBConfig::AddExtensionOption(const string &name, string description, LogicalType parameter,
                                   const Value &default_value, set_option_callback_t function) {
 	extension_parameters.insert(
-	    make_pair(name, ExtensionOption(move(description), move(parameter), function, default_value)));
+	    make_pair(name, ExtensionOption(std::move(description), std::move(parameter), function, default_value)));
 	if (!default_value.IsNull()) {
 		// Default value is set, insert it into the 'set_variables' list
 		options.set_variables[name] = default_value;