duckdb 0.5.2-dev678.0 → 0.5.2-dev708.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.5.2-dev678.0",
+  "version": "0.5.2-dev708.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -16955,7 +16955,20 @@ FileOpener *FileSystem::GetFileOpener(ClientContext &context) {
 	return ClientData::Get(context).file_opener.get();
 }
 
+bool PathMatched(const string &path, const string &sub_path) {
+	if (path.rfind(sub_path, 0) == 0) {
+		return true;
+	}
+	return false;
+}
+
 #ifndef _WIN32
+
+bool FileSystem::IsPathAbsolute(const string &path) {
+	auto path_separator = FileSystem::PathSeparator();
+	return PathMatched(path, path_separator);
+}
+
 string FileSystem::PathSeparator() {
 	return "/";
 }
@@ -16985,6 +16998,27 @@ string FileSystem::GetWorkingDirectory() {
 }
 #else
 
+bool FileSystem::IsPathAbsolute(const string &path) {
+	// 1) A single backslash
+	auto sub_path = FileSystem::PathSeparator();
+	if (PathMatched(path, sub_path)) {
+		return true;
+	}
+	// 2) check if starts with a double-backslash (i.e., \\)
+	sub_path += FileSystem::PathSeparator();
+	if (PathMatched(path, sub_path)) {
+		return true;
+	}
+	// 3) A disk designator with a backslash (e.g., C:\)
+	auto path_aux = path;
+	path_aux.erase(0, 1);
+	sub_path = ":" + FileSystem::PathSeparator();
+	if (PathMatched(path_aux, sub_path)) {
+		return true;
+	}
+	return false;
+}
+
 string FileSystem::PathSeparator() {
 	return "\\";
 }
@@ -130140,6 +130174,19 @@ idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 	return (idx_t)multiplier * limit;
 }
 
+// Right now we only really care about access mode when comparing DBConfigs
+bool DBConfigOptions::operator==(const DBConfigOptions &other) const {
+	return other.access_mode == access_mode;
+}
+
+bool DBConfig::operator==(const DBConfig &other) {
+	return other.options == options;
+}
+
+bool DBConfig::operator!=(const DBConfig &other) {
+	return !(other.options == options);
+}
+
 } // namespace duckdb
 
 
@@ -130722,6 +130769,23 @@ DBConfig::DBConfig() {
 	cast_functions = make_unique<CastFunctionSet>();
 }
 
+DBConfig::DBConfig(std::unordered_map<string, string> &config_dict, bool read_only) {
+	compression_functions = make_unique<CompressionFunctionSet>();
+	if (read_only) {
+		options.access_mode = AccessMode::READ_ONLY;
+	}
+	for (auto &kv : config_dict) {
+		string key = kv.first;
+		string val = kv.second;
+		auto config_property = DBConfig::GetOptionByName(key);
+		if (!config_property) {
+			throw InvalidInputException("Unrecognized configuration property \"%s\"", key);
+		}
+		auto opt_val = Value(val);
+		DBConfig::SetOption(*config_property, opt_val);
+	}
+}
+
 DBConfig::~DBConfig() {
 }
 
@@ -131026,6 +131090,97 @@ bool DatabaseInstance::IsInvalidated() {
 }
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/db_instance_cache.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+class DBInstanceCache {
+public:
+	DBInstanceCache() {};
+	//! Gets a DB Instance from the cache if already exists (Fails if the configurations do not match)
+	shared_ptr<DuckDB> GetInstance(const string &database, const DBConfig &config_dict);
+
+	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
+	shared_ptr<DuckDB> CreateInstance(const string &database, DBConfig &config_dict, bool cache_instance = true);
+
+private:
+	//! A map with the cached instances <absolute_path/instance>
+	unordered_map<string, weak_ptr<DuckDB>> db_instances;
+
+	//! Lock to alter cache
+	mutex cache_lock;
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+string GetDBAbsolutePath(const string &database) {
+	if (database.empty()) {
+		return ":memory:";
+	}
+	if (database.rfind(":memory:", 0) == 0) {
+		// this is a memory db, just return it.
+		return database;
+	}
+	if (FileSystem::IsPathAbsolute(database)) {
+		return database;
+	}
+	return FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database);
+}
+
+shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DBConfig &config) {
+	lock_guard<mutex> l(cache_lock);
+	shared_ptr<DuckDB> db_instance;
+	auto abs_database_path = GetDBAbsolutePath(database);
+	if (db_instances.find(abs_database_path) != db_instances.end()) {
+		db_instance = db_instances[abs_database_path].lock();
+		if (db_instance) {
+			if (db_instance->instance->config != config) {
+				throw duckdb::Exception(ExceptionType::CONNECTION,
+				                        "Can't open a connection to same database file with a different configuration "
+				                        "than existing connections");
+			}
+		} else {
+			// clean-up
+			db_instances.erase(abs_database_path);
+		}
+	}
+	return db_instance;
+}
+
+shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBConfig &config, bool cache_instance) {
+	lock_guard<mutex> l(cache_lock);
+	auto abs_database_path = GetDBAbsolutePath(database);
+	if (db_instances.find(abs_database_path) != db_instances.end()) {
+		throw duckdb::Exception(ExceptionType::CONNECTION,
+		                        "Instance with path: " + abs_database_path + " already exists.");
+	}
+	// Creates new instance
+	string instance_path = abs_database_path;
+	if (abs_database_path.rfind(":memory:", 0) == 0) {
+		instance_path = ":memory:";
+	}
+	auto db_instance = make_shared<DuckDB>(instance_path, &config);
+	if (cache_instance) {
+		db_instances[abs_database_path] = db_instance;
+	}
+	return db_instance;
+}
+
+} // namespace duckdb
 
 
 

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "23b94dd87"
-#define DUCKDB_VERSION "v0.5.2-dev678"
+#define DUCKDB_SOURCE_ID "c5d35b30c"
+#define DUCKDB_VERSION "v0.5.2-dev708"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2184,6 +2184,8 @@ public:
 	DUCKDB_API static idx_t GetAvailableMemory();
 	//! Path separator for the current file system
 	DUCKDB_API static string PathSeparator();
+	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
+	DUCKDB_API static bool IsPathAbsolute(const string &path);
 	//! Join two paths together
 	DUCKDB_API static string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
@@ -24439,6 +24441,8 @@ struct DBConfigOptions {
 	bool allow_unsigned_extensions = false;
 	//! Enable emitting FSST Vectors
 	bool enable_fsst_vectors = false;
+
+	bool operator==(const DBConfigOptions &other) const;
 };
 
 struct DBConfig {
@@ -24447,6 +24451,7 @@ struct DBConfig {
 
 public:
 	DUCKDB_API DBConfig();
+	DUCKDB_API DBConfig(std::unordered_map<string, string> &config_dict, bool read_only);
 	DUCKDB_API ~DBConfig();
 
 	//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
@@ -24495,6 +24500,9 @@ public:
 	//! Return the compression function for the specified compression type/physical type combo
 	DUCKDB_API CompressionFunction *GetCompressionFunction(CompressionType type, PhysicalType data_type);
 
+	bool operator==(const DBConfig &other);
+	bool operator!=(const DBConfig &other);
+
 	DUCKDB_API CastFunctionSet &GetCastFunctions();
 
 private: