duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/include/duckdb/main/database.hpp

@@ -25,6 +25,17 @@ class FileSystem;
 class TaskScheduler;
 class ObjectCache;
 struct AttachInfo;
+class DatabaseFileSystem;
+
+struct ExtensionInfo {
+	explicit ExtensionInfo(const std::string &version) : extension_version(version) {
+	}
+	ExtensionInfo() : ExtensionInfo("defaultme") {
+	}
+	ExtensionInfo(const ExtensionInfo &x) : ExtensionInfo(x.extension_version) {
+	}
+	std::string extension_version;
+};
 
 class DatabaseInstance : public std::enable_shared_from_this<DatabaseInstance> {
 	friend class DuckDB;
@@ -39,22 +50,25 @@ public:
 	BufferPool &GetBufferPool() const;
 	DUCKDB_API SecretManager &GetSecretManager();
 	DUCKDB_API BufferManager &GetBufferManager();
+	DUCKDB_API const BufferManager &GetBufferManager() const;
 	DUCKDB_API DatabaseManager &GetDatabaseManager();
 	DUCKDB_API FileSystem &GetFileSystem();
 	DUCKDB_API TaskScheduler &GetScheduler();
 	DUCKDB_API ObjectCache &GetObjectCache();
 	DUCKDB_API ConnectionManager &GetConnectionManager();
 	DUCKDB_API ValidChecker &GetValidChecker();
-	DUCKDB_API void SetExtensionLoaded(const std::string &extension_name);
+	DUCKDB_API void SetExtensionLoaded(const std::string &extension_name, const std::string &extension_version = "");
 
 	idx_t NumberOfThreads();
 
 	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
+	DUCKDB_API static const DatabaseInstance &GetDatabase(const ClientContext &context);
 
 	DUCKDB_API const unordered_set<std::string> &LoadedExtensions();
+	DUCKDB_API const unordered_map<string, ExtensionInfo> &LoadedExtensionsData();
 	DUCKDB_API bool ExtensionIsLoaded(const string &name);
 
-	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const string &key, Value &result);
+	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) const;
 
 	unique_ptr<AttachedDatabase> CreateAttachedDatabase(ClientContext &context, const AttachInfo &info,
 	                                                    const string &type, AccessMode access_mode);
@@ -66,13 +80,15 @@ private:
 	void Configure(DBConfig &config);
 
 private:
-	unique_ptr<BufferManager> buffer_manager;
+	shared_ptr<BufferManager> buffer_manager;
 	unique_ptr<DatabaseManager> db_manager;
 	unique_ptr<TaskScheduler> scheduler;
 	unique_ptr<ObjectCache> object_cache;
 	unique_ptr<ConnectionManager> connection_manager;
 	unordered_set<std::string> loaded_extensions;
+	unordered_map<std::string, ExtensionInfo> loaded_extensions_data;
 	ValidChecker db_validity;
+	unique_ptr<DatabaseFileSystem> db_file_system;
 };
 
 //! The database object. This object holds the catalog and all the

package/src/duckdb/src/include/duckdb/main/database_file_opener.hpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/database_file_opener.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/file_opener.hpp"
+#include "duckdb/common/opener_file_system.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/database.hpp"
+
+namespace duckdb {
+class DatabaseInstance;
+
+class DatabaseFileOpener : public FileOpener {
+public:
+	explicit DatabaseFileOpener(DatabaseInstance &db_p) : db(db_p) {
+	}
+
+	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override {
+		return SettingLookupResult();
+	}
+
+	optional_ptr<ClientContext> TryGetClientContext() override {
+		return nullptr;
+	}
+
+	optional_ptr<DatabaseInstance> TryGetDatabase() override {
+		return &db;
+	}
+
+private:
+	DatabaseInstance &db;
+};
+
+class DatabaseFileSystem : public OpenerFileSystem {
+public:
+	explicit DatabaseFileSystem(DatabaseInstance &db_p) : db(db_p), database_opener(db_p) {
+	}
+
+	FileSystem &GetFileSystem() const override {
+		auto &config = DBConfig::GetConfig(db);
+		return *config.file_system;
+	}
+	optional_ptr<FileOpener> GetOpener() const override {
+		return &database_opener;
+	}
+
+private:
+	DatabaseInstance &db;
+	mutable DatabaseFileOpener database_opener;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/database_path_and_type.hpp

@@ -17,9 +17,9 @@ struct DBPathAndType {
 	//! Parse database extension type and rest of path from combined form (type:path)
 	static void ExtractExtensionPrefix(string &path, string &db_type);
 	//! Check the magic bytes of a file and set the database type based on that
-	static void CheckMagicBytes(string &path, string &db_type, const DBConfig &config);
+	static void CheckMagicBytes(FileSystem &fs, string &path, string &db_type);
 
 	//! Run ExtractExtensionPrefix followed by CheckMagicBytes
-	static void ResolveDatabaseType(string &path, string &db_type, const DBConfig &config);
+	static void ResolveDatabaseType(FileSystem &fs, string &path, string &db_type);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/error_manager.hpp

@@ -32,23 +32,23 @@ enum class ErrorType : uint16_t {
 //! It allows for error messages to be overridden by extensions and clients
 class ErrorManager {
 public:
-	template <typename... Args>
-	string FormatException(ErrorType error_type, Args... params) {
+	template <typename... ARGS>
+	string FormatException(ErrorType error_type, ARGS... params) {
 		vector<ExceptionFormatValue> values;
 		return FormatExceptionRecursive(error_type, values, params...);
 	}
 
 	DUCKDB_API string FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values);
 
-	template <class T, typename... Args>
+	template <class T, typename... ARGS>
 	string FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values, T param,
-	                                Args... params) {
+	                                ARGS... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
 		return FormatExceptionRecursive(error_type, values, params...);
 	}
 
-	template <typename... Args>
-	static string FormatException(ClientContext &context, ErrorType error_type, Args... params) {
+	template <typename... ARGS>
+	static string FormatException(ClientContext &context, ErrorType error_type, ARGS... params) {
 		return Get(context).FormatException(error_type, params...);
 	}
 

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -47,6 +47,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
     {"get_substrait", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
     {"get_substrait_json", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY},
+    {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
     {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -88,9 +90,11 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY},
     {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -128,6 +132,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
     {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -150,6 +155,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -197,6 +203,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -257,6 +264,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"pg_experimental_filter_pushdown", "postgres_scanner"},
     {"pg_pages_per_task", "postgres_scanner"},
     {"pg_use_binary_copy", "postgres_scanner"},
+    {"pg_use_ctid_scan", "postgres_scanner"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_region", "httpfs"},

package/src/duckdb/src/include/duckdb/main/extension_helper.hpp

@@ -31,6 +31,7 @@ struct ExtensionAlias {
 struct ExtensionInitResult {
 	string filename;
 	string filebase;
+	string extension_version;
 
 	void *lib_hdl;
 };

package/src/duckdb/src/include/duckdb/main/external_dependencies.hpp

@@ -10,7 +10,8 @@
 
 namespace duckdb {
 
-enum ExternalDependenciesType { PYTHON_DEPENDENCY };
+enum class ExternalDependenciesType : uint8_t { PYTHON_DEPENDENCY };
+
 class ExternalDependency {
 public:
 	explicit ExternalDependency(ExternalDependenciesType type_p) : type(type_p) {};

package/src/duckdb/src/include/duckdb/main/prepared_statement.hpp

@@ -66,8 +66,8 @@ public:
 	DUCKDB_API case_insensitive_map_t<LogicalType> GetExpectedParameterTypes() const;
 
 	//! Create a pending query result of the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<PendingQueryResult> PendingQuery(Args... args) {
+	template <typename... ARGS>
+	unique_ptr<PendingQueryResult> PendingQuery(ARGS... args) {
 		vector<Value> values;
 		return PendingQueryRecursive(values, args...);
 	}
@@ -87,8 +87,8 @@ public:
 	                                           bool allow_stream_result = true);
 
 	//! Execute the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<QueryResult> Execute(Args... args) {
+	template <typename... ARGS>
+	unique_ptr<QueryResult> Execute(ARGS... args) {
 		vector<Value> values;
 		return ExecuteRecursive(values, args...);
 	}
@@ -158,8 +158,8 @@ private:
 		return PendingQuery(values);
 	}
 
-	template <typename T, typename... Args>
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, Args... args) {
+	template <typename T, typename... ARGS>
+	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, ARGS... args) {
 		values.push_back(Value::CreateValue<T>(value));
 		return PendingQueryRecursive(values, args...);
 	}
@@ -168,8 +168,8 @@ private:
 		return Execute(values);
 	}
 
-	template <typename T, typename... Args>
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, Args... args) {
+	template <typename T, typename... ARGS>
+	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, ARGS... args) {
 		values.push_back(Value::CreateValue<T>(value));
 		return ExecuteRecursive(values, args...);
 	}

package/src/duckdb/src/include/duckdb/main/query_profiler.hpp

@@ -28,70 +28,13 @@ class ExpressionExecutor;
 class PhysicalOperator;
 class SQLStatement;
 
-//! The ExpressionInfo keeps information related to an expression
-struct ExpressionInfo {
-	explicit ExpressionInfo() : hasfunction(false) {
-	}
-	// A vector of children
-	vector<unique_ptr<ExpressionInfo>> children;
-	// Extract ExpressionInformation from a given expression state
-	void ExtractExpressionsRecursive(unique_ptr<ExpressionState> &state);
-
-	//! Whether or not expression has function
-	bool hasfunction;
-	//! The function Name
-	string function_name;
-	//! The function time
-	uint64_t function_time = 0;
-	//! Count the number of ALL tuples
-	uint64_t tuples_count = 0;
-	//! Count the number of tuples sampled
-	uint64_t sample_tuples_count = 0;
-};
-
-//! The ExpressionRootInfo keeps information related to the root of an expression tree
-struct ExpressionRootInfo {
-	ExpressionRootInfo(ExpressionExecutorState &executor, string name);
-
-	//! Count the number of time the executor called
-	uint64_t total_count = 0;
-	//! Count the number of time the executor called since last sampling
-	uint64_t current_count = 0;
-	//! Count the number of samples
-	uint64_t sample_count = 0;
-	//! Count the number of tuples in all samples
-	uint64_t sample_tuples_count = 0;
-	//! Count the number of tuples processed by this executor
-	uint64_t tuples_count = 0;
-	//! A vector which contain the pointer to root of each expression tree
-	unique_ptr<ExpressionInfo> root;
-	//! Name
-	string name;
-	//! Elapsed time
-	double time;
-	//! Extra Info
-	string extra_info;
-};
-
-struct ExpressionExecutorInfo {
-	explicit ExpressionExecutorInfo() {};
-	explicit ExpressionExecutorInfo(ExpressionExecutor &executor, const string &name, int id);
-
-	//! A vector which contain the pointer to all ExpressionRootInfo
-	vector<unique_ptr<ExpressionRootInfo>> roots;
-	//! Id, it will be used as index for executors_info vector
-	int id;
-};
-
 struct OperatorInformation {
-	explicit OperatorInformation(double time_ = 0, idx_t elements_ = 0) : time(time_), elements(elements_) {
+	explicit OperatorInformation(double time_p = 0, idx_t elements_p = 0) : time(time_p), elements(elements_p) {
 	}
 
 	double time = 0;
 	idx_t elements = 0;
 	string name;
-	//! A vector of Expression Executor Info
-	vector<unique_ptr<ExpressionExecutorInfo>> executors_info;
 };
 
 //! The OperatorProfiler measures timings of individual operators
@@ -125,7 +68,7 @@ private:
 //! The QueryProfiler can be used to measure timings of queries
 class QueryProfiler {
 public:
-	DUCKDB_API QueryProfiler(ClientContext &context);
+	DUCKDB_API explicit QueryProfiler(ClientContext &context);
 
 public:
 	struct TreeNode {

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -65,7 +65,7 @@ public:
 	                       vector<LogicalType> types, vector<string> names, ClientProperties client_properties);
 	//! Creates an unsuccessful query result with error condition
 	DUCKDB_API QueryResult(QueryResultType type, ErrorData error);
-	DUCKDB_API virtual ~QueryResult() override;
+	DUCKDB_API ~QueryResult() override;
 
 	//! Properties from the client context
 	ClientProperties client_properties;
@@ -190,10 +190,10 @@ private:
 	};
 
 public:
-	QueryResultIterator begin() {
+	QueryResultIterator begin() { // NOLINT: match stl API
 		return QueryResultIterator(this);
 	}
-	QueryResultIterator end() {
+	QueryResultIterator end() { // NOLINT: match stl API
 		return QueryResultIterator(nullptr);
 	}
 

package/src/duckdb/src/include/duckdb/main/relation/query_relation.hpp

@@ -17,7 +17,7 @@ class SelectStatement;
 class QueryRelation : public Relation {
 public:
 	QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
-	~QueryRelation();
+	~QueryRelation() override;
 
 	unique_ptr<SelectStatement> select_stmt;
 	string alias;

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -185,7 +185,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/main/secret/secret.hpp

@@ -51,7 +51,9 @@ public:
 //! should be seen as the method of secret creation. (e.g. user-provided config, env variables, auto-detect)
 class CreateSecretFunctionSet {
 public:
-	CreateSecretFunctionSet(string &name) : name(name) {};
+	explicit CreateSecretFunctionSet(string &name) : name(name) {};
+
+public:
 	bool ProviderExists(const string &provider_name);
 	void AddFunction(CreateSecretFunction &function, OnCreateConflict on_conflict);
 	CreateSecretFunction &GetFunction(const string &provider);
@@ -81,8 +83,9 @@ class BaseSecret {
 	friend class SecretManager;
 
 public:
-	BaseSecret(const vector<string> &prefix_paths, const string &type, const string &provider, const string &name)
-	    : prefix_paths(prefix_paths), type(type), provider(provider), name(name), serializable(false) {
+	BaseSecret(vector<string> prefix_paths_p, string type_p, string provider_p, string name_p)
+	    : prefix_paths(std::move(prefix_paths_p)), type(std::move(type_p)), provider(std::move(provider_p)),
+	      name(std::move(name_p)), serializable(false) {
 		D_ASSERT(!type.empty());
 	}
 	BaseSecret(const BaseSecret &other)
@@ -148,7 +151,7 @@ public:
 		D_ASSERT(!type.empty());
 		serializable = true;
 	}
-	KeyValueSecret(BaseSecret &secret)
+	explicit KeyValueSecret(const BaseSecret &secret)
 	    : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
 		serializable = true;
 	};
@@ -158,15 +161,16 @@ public:
 		redact_keys = secret.redact_keys;
 		serializable = true;
 	};
-	KeyValueSecret(KeyValueSecret &&secret)
-	    : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
+	KeyValueSecret(KeyValueSecret &&secret) noexcept
+	    : BaseSecret(std::move(secret.prefix_paths), std::move(secret.type), std::move(secret.provider),
+	                 std::move(secret.name)) {
 		secret_map = std::move(secret.secret_map);
 		redact_keys = std::move(secret.redact_keys);
 		serializable = true;
 	};
 
 	//! Print the secret as a key value map in the format 'key1=value;key2=value2'
-	virtual string ToString(SecretDisplayType mode = SecretDisplayType::REDACTED) const override;
+	string ToString(SecretDisplayType mode = SecretDisplayType::REDACTED) const override;
 	void Serialize(Serializer &serializer) const override;
 
 	//! Tries to get the value at key <key>, depending on error_on_missing will throw or return Value()

package/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp

@@ -55,8 +55,8 @@ public:
 //! A Secret Entry in the secret manager
 struct SecretEntry {
 public:
-	SecretEntry(unique_ptr<const BaseSecret> secret) : secret(secret != nullptr ? secret->Clone() : nullptr) {};
-
+	explicit SecretEntry(unique_ptr<const BaseSecret> secret) : secret(secret != nullptr ? secret->Clone() : nullptr) {
+	}
 	SecretEntry(const SecretEntry &other)
 	    : persist_type(other.persist_type), storage_mode(other.storage_mode),
 	      secret((other.secret != nullptr) ? other.secret->Clone() : nullptr) {

package/src/duckdb/src/include/duckdb/main/secret/secret_storage.hpp

@@ -26,7 +26,7 @@ class SecretStorage {
 	friend class SecretManager;
 
 public:
-	SecretStorage(const string &name) : storage_name(name), persistent(false) {};
+	explicit SecretStorage(const string &name) : storage_name(name), persistent(false) {};
 	virtual ~SecretStorage() = default;
 
 public:
@@ -103,8 +103,8 @@ public:
 		return storage_name;
 	};
 
-	virtual unique_ptr<SecretEntry> StoreSecret(unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
-	                                            optional_ptr<CatalogTransaction> transaction = nullptr) override;
+	unique_ptr<SecretEntry> StoreSecret(unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
+	                                    optional_ptr<CatalogTransaction> transaction = nullptr) override;
 	vector<SecretEntry> AllSecrets(optional_ptr<CatalogTransaction> transaction = nullptr) override;
 	void DropSecretByName(const string &name, OnEntryNotFound on_entry_not_found,
 	                      optional_ptr<CatalogTransaction> transaction = nullptr) override;
@@ -153,7 +153,7 @@ protected:
 	//! Implements the writes to disk
 	void WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict) override;
 	//! Implements the deletes from disk
-	virtual void RemoveSecret(const string &secret, OnEntryNotFound on_entry_not_found) override;
+	void RemoveSecret(const string &secret, OnEntryNotFound on_entry_not_found) override;
 
 	//! Set of persistent secrets that are lazily loaded
 	case_insensitive_set_t persistent_secrets;