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

package/src/duckdb/src/main/connection.cpp

@@ -18,7 +18,8 @@
 
 namespace duckdb {
 
-Connection::Connection(DatabaseInstance &database) : context(make_shared<ClientContext>(database.shared_from_this())) {
+Connection::Connection(DatabaseInstance &database)
+    : context(make_shared_ptr<ClientContext>(database.shared_from_this())) {
 	ConnectionManager::Get(database).AddConnection(*context);
 #ifdef DEBUG
 	EnableProfiling();
@@ -186,7 +187,7 @@ shared_ptr<Relation> Connection::Table(const string &schema_name, const string &
 	if (!table_info) {
 		throw CatalogException("Table '%s' does not exist!", table_name);
 	}
-	return make_shared<TableRelation>(context, std::move(table_info));
+	return make_shared_ptr<TableRelation>(context, std::move(table_info));
 }
 
 shared_ptr<Relation> Connection::View(const string &tname) {
@@ -194,7 +195,7 @@ shared_ptr<Relation> Connection::View(const string &tname) {
 }
 
 shared_ptr<Relation> Connection::View(const string &schema_name, const string &table_name) {
-	return make_shared<ViewRelation>(context, schema_name, table_name);
+	return make_shared_ptr<ViewRelation>(context, schema_name, table_name);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
@@ -205,11 +206,11 @@ shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
                                                const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters);
+	return make_shared_ptr<TableFunctionRelation>(context, fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context, fname, values);
+	return make_shared_ptr<TableFunctionRelation>(context, fname, values);
 }
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
@@ -219,7 +220,7 @@ shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values, const vector<string> &column_names,
                                         const string &alias) {
-	return make_shared<ValueRelation>(context, values, column_names, alias);
+	return make_shared_ptr<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::Values(const string &values) {
@@ -228,7 +229,7 @@ shared_ptr<Relation> Connection::Values(const string &values) {
 }
 
 shared_ptr<Relation> Connection::Values(const string &values, const vector<string> &column_names, const string &alias) {
-	return make_shared<ValueRelation>(context, values, column_names, alias);
+	return make_shared_ptr<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
@@ -237,7 +238,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const vector<string> &csv_input, named_parameter_map_t &&options) {
-	return make_shared<ReadCSVRelation>(context, csv_input, std::move(options));
+	return make_shared_ptr<ReadCSVRelation>(context, csv_input, std::move(options));
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_input, named_parameter_map_t &&options) {
@@ -258,7 +259,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 		column_list.push_back({col_def.GetName(), col_def.GetType().ToString()});
 	}
 	vector<string> files {csv_file};
-	return make_shared<ReadCSVRelation>(context, files, std::move(options));
+	return make_shared_ptr<ReadCSVRelation>(context, files, std::move(options));
 }
 
 shared_ptr<Relation> Connection::ReadParquet(const string &parquet_file, bool binary_as_string) {
@@ -277,7 +278,7 @@ shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const st
 }
 
 shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
-	return make_shared<QueryRelation>(context, std::move(select_stmt), alias);
+	return make_shared_ptr<QueryRelation>(context, std::move(select_stmt), alias);
 }
 
 void Connection::BeginTransaction() {

package/src/duckdb/src/main/connection_manager.cpp

@@ -5,7 +5,7 @@
 
 namespace duckdb {
 
-ConnectionManager::ConnectionManager() : is_locking(false) {
+ConnectionManager::ConnectionManager() {
 }
 
 void ConnectionManager::AddConnection(ClientContext &context) {
@@ -13,7 +13,7 @@ void ConnectionManager::AddConnection(ClientContext &context) {
 	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
 		callback->OnConnectionOpened(context);
 	}
-	connections.insert(make_pair(&context, weak_ptr<ClientContext>(context.shared_from_this())));
+	connections[context] = weak_ptr<ClientContext>(context.shared_from_this());
 }
 
 void ConnectionManager::RemoveConnection(ClientContext &context) {
@@ -21,10 +21,16 @@ void ConnectionManager::RemoveConnection(ClientContext &context) {
 	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
 		callback->OnConnectionClosed(context);
 	}
-	connections.erase(&context);
+	connections.erase(context);
+}
+
+idx_t ConnectionManager::GetConnectionCount() const {
+	lock_guard<mutex> lock(connections_lock);
+	return connections.size();
 }
 
 vector<shared_ptr<ClientContext>> ConnectionManager::GetConnectionList() {
+	lock_guard<mutex> lock(connections_lock);
 	vector<shared_ptr<ClientContext>> result;
 	for (auto &it : connections) {
 		auto connection = it.second.lock();
@@ -39,24 +45,4 @@ vector<shared_ptr<ClientContext>> ConnectionManager::GetConnectionList() {
 	return result;
 }
 
-void ConnectionManager::LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context) {
-	{
-		lock_guard<mutex> l(lock_clients_lock);
-		if (is_locking) {
-			throw TransactionException("Failed to lock clients - another thread is running FORCE CHECKPOINT");
-		}
-		is_locking = true;
-	}
-	client_locks.emplace_back(connections_lock, nullptr);
-	auto connection_list = GetConnectionList();
-	for (auto &con : connection_list) {
-		if (con.get() == &context) {
-			continue;
-		}
-		auto &context_lock = con->context_lock;
-		client_locks.emplace_back(context_lock, std::move(con));
-	}
-	is_locking = false;
-}
-
 } // namespace duckdb

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

@@ -203,27 +203,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		config_ptr = user_config;
 	}
 
-	if (config_ptr->options.duckdb_api.empty()) {
-		config_ptr->SetOptionByName("duckdb_api", "cpp");
-	}
-
-	if (config_ptr->options.temporary_directory.empty() && database_path) {
-		// no directory specified: use default temp path
-		config_ptr->options.temporary_directory = string(database_path) + ".tmp";
-
-		// special treatment for in-memory mode
-		if (strcmp(database_path, IN_MEMORY_PATH) == 0) {
-			config_ptr->options.temporary_directory = ".tmp";
-		}
-	}
-
-	if (database_path) {
-		config_ptr->options.database_path = database_path;
-	} else {
-		config_ptr->options.database_path.clear();
-	}
-
-	Configure(*config_ptr);
+	Configure(*config_ptr, database_path);
 
 	if (user_config && !user_config->options.use_temporary_directory) {
 		// temporary directories explicitly disabled
@@ -272,7 +252,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	scheduler->RelaunchThreads();
 }
 
-DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared<DatabaseInstance>()) {
+DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared_ptr<DatabaseInstance>()) {
 	instance->Initialize(path, new_config);
 	if (instance->config.options.load_extensions) {
 		ExtensionHelper::LoadAllExtensions(*this);
@@ -344,8 +324,23 @@ Allocator &Allocator::Get(AttachedDatabase &db) {
 	return Allocator::Get(db.GetDatabase());
 }
 
-void DatabaseInstance::Configure(DBConfig &new_config) {
+void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path) {
 	config.options = new_config.options;
+
+	if (new_config.options.duckdb_api.empty()) {
+		config.SetOptionByName("duckdb_api", "cpp");
+	}
+
+	if (database_path) {
+		config.options.database_path = database_path;
+	} else {
+		config.options.database_path.clear();
+	}
+
+	if (new_config.options.temporary_directory.empty()) {
+		config.SetDefaultTempDirectory();
+	}
+
 	if (config.options.access_mode == AccessMode::UNDEFINED) {
 		config.options.access_mode = AccessMode::READ_WRITE;
 	}
@@ -358,10 +353,10 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	if (new_config.secret_manager) {
 		config.secret_manager = std::move(new_config.secret_manager);
 	}
-	if (config.options.maximum_memory == (idx_t)-1) {
+	if (config.options.maximum_memory == DConstants::INVALID_INDEX) {
 		config.SetDefaultMaxMemory();
 	}
-	if (new_config.options.maximum_threads == (idx_t)-1) {
+	if (new_config.options.maximum_threads == DConstants::INVALID_INDEX) {
 		config.options.maximum_threads = config.GetSystemMaxThreads(*config.file_system);
 	}
 	config.allocator = std::move(new_config.allocator);
@@ -380,7 +375,8 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	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);
+		config.buffer_pool = make_shared_ptr<BufferPool>(config.options.maximum_memory,
+		                                                 config.options.buffer_manager_track_eviction_timestamps);
 	}
 }
 
@@ -393,14 +389,14 @@ const DBConfig &DBConfig::GetConfig(const ClientContext &context) {
 }
 
 idx_t DatabaseInstance::NumberOfThreads() {
-	return scheduler->NumberOfThreads();
+	return NumericCast<idx_t>(scheduler->NumberOfThreads());
 }
 
 const unordered_set<std::string> &DatabaseInstance::LoadedExtensions() {
 	return loaded_extensions;
 }
 
-const unordered_map<std::string, ExtensionInfo> &DatabaseInstance::LoadedExtensionsData() {
+const unordered_map<std::string, ExtensionInstallInfo> &DatabaseInstance::LoadedExtensionsData() {
 	return loaded_extensions_data;
 }
 
@@ -417,10 +413,10 @@ bool DuckDB::ExtensionIsLoaded(const std::string &name) {
 	return instance->ExtensionIsLoaded(name);
 }
 
-void DatabaseInstance::SetExtensionLoaded(const std::string &name, const std::string &extension_version) {
+void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallInfo &install_info) {
 	auto extension_name = ExtensionHelper::GetExtensionName(name);
 	loaded_extensions.insert(extension_name);
-	loaded_extensions_data.insert({extension_name, ExtensionInfo(extension_version)});
+	loaded_extensions_data.insert({extension_name, install_info});
 
 	auto &callbacks = DBConfig::GetConfig(*this).extension_callbacks;
 	for (auto &callback : callbacks) {

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -66,7 +66,7 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &databas
 	if (abs_database_path.rfind(IN_MEMORY_PATH, 0) == 0) {
 		instance_path = IN_MEMORY_PATH;
 	}
-	auto db_instance = make_shared<DuckDB>(instance_path, &config);
+	auto db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
 	if (cache_instance) {
 		db_instances[abs_database_path] = db_instance;
 	}