duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -35,6 +35,7 @@ struct ExtensionAlias {
 struct ExtensionInitResult {
 	string filename;
 	string filebase;
+	ExtensionABIType abi_type = ExtensionABIType::UNKNOWN;
 
 	// The deserialized install from the `<ext>.duckdb_extension.info` file
 	unique_ptr<ExtensionInstallInfo> install_info;
@@ -122,6 +123,10 @@ public:
 	static string ExtensionDirectory(ClientContext &context);
 	static string ExtensionDirectory(DatabaseInstance &db, FileSystem &fs);
 
+	// Get the extension directory path
+	static string GetExtensionDirectoryPath(ClientContext &context);
+	static string GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs);
+
 	static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata,
 	                                    const bool allow_community_extensions);
 	static ParsedExtensionMetaData ParseExtensionMetaData(const char *metadata) noexcept;
@@ -173,6 +178,19 @@ public:
 		return result;
 	}
 
+	template <idx_t N>
+	static idx_t ArraySize(const ExtensionEntry (&entries)[N]) {
+		return N;
+	}
+
+	template <idx_t N>
+	static const ExtensionEntry *GetArrayEntry(const ExtensionEntry (&entries)[N], idx_t entry) {
+		if (entry >= N) {
+			return nullptr;
+		}
+		return entries + entry;
+	}
+
 	//! Lookup a name in an ExtensionEntry list
 	template <idx_t N>
 	static string FindExtensionInEntries(const string &name, const ExtensionEntry (&entries)[N]) {

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

@@ -18,6 +18,9 @@
 namespace duckdb {
 struct CreateMacroInfo;
 struct CreateCollationInfo;
+struct CreateAggregateFunctionInfo;
+struct CreateScalarFunctionInfo;
+struct CreateTableFunctionInfo;
 class DatabaseInstance;
 
 //! The ExtensionUtil class contains methods that are useful for extensions
@@ -25,18 +28,18 @@ class ExtensionUtil {
 public:
 	//! Register a new DuckDB extension
 	DUCKDB_API static void RegisterExtension(DatabaseInstance &db, const string &name, const ExtensionLoadedInfo &info);
-	//! Register a new scalar function - throw an exception if the function already exists
+	//! Register a new scalar function - merge overloads if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
-	//! Register a new scalar function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
-	//! Register a new aggregate function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateScalarFunctionInfo info);
+	//! Register a new aggregate function - merge overloads if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
-	//! Register a new aggregate function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
-	//! Register a new table function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateAggregateFunctionInfo info);
+	//! Register a new table function - merge overloads if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
-	//! Register a new table function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunctionSet function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateTableFunctionInfo info);
 	//! Register a new pragma function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunction function);
 	//! Register a new pragma function set - throw an exception if the function already exists
@@ -56,6 +59,8 @@ public:
 	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
 	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
 	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static optional_ptr<CatalogEntry> TryGetFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static optional_ptr<CatalogEntry> TryGetTableFunction(DatabaseInstance &db, const string &name);
 
 	//! Add a function overload
 	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
@@ -64,7 +69,7 @@ public:
 
 	//! Registers a new type
 	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
-	                                    bind_type_modifiers_function_t bind_type_modifiers = nullptr);
+	                                    bind_logical_type_function_t bind_function = nullptr);
 
 	//! Registers a new secret type
 	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);

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

@@ -94,7 +94,7 @@ public:
 
 	template <class PAYLOAD>
 	static string ExcessValuesException(const case_insensitive_map_t<idx_t> &parameters,
-	                                    case_insensitive_map_t<PAYLOAD> &values) {
+	                                    const case_insensitive_map_t<PAYLOAD> &values) {
 		// Too many values
 		set<string> excess_set;
 		for (auto &pair : values) {
@@ -113,7 +113,7 @@ public:
 
 	template <class PAYLOAD>
 	static string MissingValuesException(const case_insensitive_map_t<idx_t> &parameters,
-	                                     case_insensitive_map_t<PAYLOAD> &values) {
+	                                     const case_insensitive_map_t<PAYLOAD> &values) {
 		// Missing values
 		set<string> missing_set;
 		for (auto &pair : parameters) {
@@ -131,7 +131,7 @@ public:
 	}
 
 	template <class PAYLOAD>
-	static void VerifyParameters(case_insensitive_map_t<PAYLOAD> &provided,
+	static void VerifyParameters(const case_insensitive_map_t<PAYLOAD> &provided,
 	                             const case_insensitive_map_t<idx_t> &expected) {
 		if (expected.size() == provided.size()) {
 			// Same amount of identifiers, if

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

@@ -60,8 +60,8 @@ public:
 
 public:
 	template <class METRIC_TYPE>
-	METRIC_TYPE GetMetricValue(const MetricsType setting) const {
-		auto val = metrics.at(setting);
+	METRIC_TYPE GetMetricValue(const MetricsType type) const {
+		auto val = metrics.at(type);
 		return val.GetValue<METRIC_TYPE>();
 	}
 

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

@@ -43,6 +43,7 @@ struct OperatorInformation {
 	idx_t elements_returned;
 	idx_t result_set_size;
 	string name;
+	InsertionOrderPreservingMap<string> extra_info;
 
 	void AddTime(double n_time) {
 		time += n_time;
@@ -88,8 +89,8 @@ private:
 	Profiler op;
 	//! The stack of Physical Operators that are currently active
 	optional_ptr<const PhysicalOperator> active_operator;
-	//! A mapping of physical operators to recorded timings
-	reference_map_t<const PhysicalOperator, OperatorInformation> timings;
+	//! A mapping of physical operators to profiled operator information.
+	reference_map_t<const PhysicalOperator, OperatorInformation> operator_infos;
 };
 
 struct QueryInfo {
@@ -113,6 +114,7 @@ private:
 	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, const profiler_settings_t &settings,
 	                                     const idx_t depth = 0);
 	void Render(const ProfilingNode &node, std::ostream &str) const;
+	string RenderDisabledMessage(ProfilerPrintFormat format) const;
 
 public:
 	DUCKDB_API bool IsEnabled() const;
@@ -145,6 +147,7 @@ public:
 	//! return the printed as a string. Unlike ToString, which is always formatted as a string,
 	//! the return value is formatted based on the current print format (see GetPrintFormat()).
 	DUCKDB_API string ToString(ExplainFormat format = ExplainFormat::DEFAULT) const;
+	DUCKDB_API string ToString(ProfilerPrintFormat format) const;
 
 	static InsertionOrderPreservingMap<string> JSONSanitize(const InsertionOrderPreservingMap<string> &input);
 	static string JSONSanitize(const string &text);
@@ -168,8 +171,8 @@ private:
 
 	//! Whether or not the query profiler is running
 	bool running;
-	//! The lock used for flushing information from a thread into the global query profiler
-	mutex flush_lock;
+	//! The lock used for accessing the global query profiler or flushing information to it from a thread
+	mutable std::mutex lock;
 
 	//! Whether or not the query requires profiling
 	bool query_requires_profiling;
@@ -207,6 +210,7 @@ private:
 	//! Check whether or not an operator type requires query profiling. If none of the ops in a query require profiling
 	//! no profiling information is output.
 	bool OperatorRequiresProfiling(PhysicalOperatorType op_type);
+	ExplainFormat GetExplainFormat(ProfilerPrintFormat format) const;
 };
 
 } // namespace duckdb

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

@@ -14,13 +14,15 @@ namespace duckdb {
 
 class CreateTableRelation : public Relation {
 public:
-	CreateTableRelation(shared_ptr<Relation> child, string schema_name, string table_name, bool temporary);
+	CreateTableRelation(shared_ptr<Relation> child, string schema_name, string table_name, bool temporary,
+	                    OnCreateConflict on_conflict);
 
 	shared_ptr<Relation> child;
 	string schema_name;
 	string table_name;
 	vector<ColumnDefinition> columns;
 	bool temporary;
+	OnCreateConflict on_conflict;
 
 public:
 	BoundStatement Bind(Binder &binder) override;

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

@@ -15,8 +15,8 @@ namespace duckdb {
 
 class DeleteRelation : public Relation {
 public:
-	DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
-	               string table_name);
+	DeleteRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition,
+	               string schema_name, string table_name);
 
 	vector<ColumnDefinition> columns;
 	unique_ptr<ParsedExpression> condition;

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

@@ -14,17 +14,14 @@ namespace duckdb {
 
 class SubqueryRelation : public Relation {
 public:
-	SubqueryRelation(shared_ptr<Relation> child, string alias);
-
+	SubqueryRelation(shared_ptr<Relation> child, const string &alias);
 	shared_ptr<Relation> child;
-	string alias;
 
 public:
 	unique_ptr<QueryNode> GetQueryNode() override;
 
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
-	string GetAlias() override;
 
 public:
 	bool InheritsColumnBindings() override {

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

@@ -17,7 +17,9 @@ public:
 	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
 	                      bool auto_init = true);
-
+	TableFunctionRelation(const shared_ptr<RelationContextWrapper> &context, string name, vector<Value> parameters,
+	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
+	                      bool auto_init = true);
 	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr, bool auto_init = true);
 	~TableFunctionRelation() override {

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

@@ -16,6 +16,7 @@ namespace duckdb {
 class TableRelation : public Relation {
 public:
 	TableRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
+	TableRelation(const shared_ptr<RelationContextWrapper> &context, unique_ptr<TableDescription> description);
 
 	unique_ptr<TableDescription> description;
 
@@ -29,6 +30,8 @@ public:
 	unique_ptr<TableRef> GetTableRef() override;
 
 	void Update(const string &update, const string &condition = string()) override;
+	void Update(vector<string> column_names, vector<unique_ptr<ParsedExpression>> &&update,
+	            unique_ptr<ParsedExpression> condition = nullptr) override;
 	void Delete(const string &condition = string()) override;
 };
 

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

@@ -15,8 +15,9 @@ namespace duckdb {
 
 class UpdateRelation : public Relation {
 public:
-	UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
-	               string table_name, vector<string> update_columns, vector<unique_ptr<ParsedExpression>> expressions);
+	UpdateRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition,
+	               string schema_name, string table_name, vector<string> update_columns,
+	               vector<unique_ptr<ParsedExpression>> expressions);
 
 	vector<ColumnDefinition> columns;
 	unique_ptr<ParsedExpression> condition;

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

@@ -17,6 +17,13 @@ class ValueRelation : public Relation {
 public:
 	ValueRelation(const shared_ptr<ClientContext> &context, const vector<vector<Value>> &values, vector<string> names,
 	              string alias = "values");
+	ValueRelation(const shared_ptr<ClientContext> &context, vector<vector<unique_ptr<ParsedExpression>>> &&expressions,
+	              vector<string> names, string alias = "values");
+	ValueRelation(const shared_ptr<RelationContextWrapper> &context, const vector<vector<Value>> &values,
+	              vector<string> names, string alias = "values");
+	ValueRelation(const shared_ptr<RelationContextWrapper> &context,
+	              vector<vector<unique_ptr<ParsedExpression>>> &&expressions, vector<string> names,
+	              string alias = "values");
 	ValueRelation(const shared_ptr<ClientContext> &context, const string &values, vector<string> names,
 	              string alias = "values");
 

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

@@ -15,6 +15,7 @@ namespace duckdb {
 class ViewRelation : public Relation {
 public:
 	ViewRelation(const shared_ptr<ClientContext> &context, string schema_name, string view_name);
+	ViewRelation(const shared_ptr<RelationContextWrapper> &context, string schema_name, string view_name);
 	ViewRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableRef> ref, const string &view_name);
 
 	string schema_name;

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

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/main/relation/write_csv_relation.hpp
+// duckdb/main/relation/write_parquet_relation.hpp
 //
 //
 //===----------------------------------------------------------------------===//

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

@@ -34,17 +34,46 @@ class LogicalOperator;
 class QueryNode;
 class TableRef;
 
+static string CreateRelationAlias(RelationType type, const string &alias) {
+	if (!alias.empty()) {
+		return alias;
+	}
+	return StringUtil::Format("%s_%s", EnumUtil::ToString(type), StringUtil::GenerateRandomName());
+}
+
+class RelationContextWrapper : public ClientContextWrapper {
+public:
+	~RelationContextWrapper() override = default;
+	explicit RelationContextWrapper(const shared_ptr<ClientContext> &context) : ClientContextWrapper(context) {};
+
+	explicit RelationContextWrapper(const ClientContextWrapper &context) : ClientContextWrapper(context) {};
+
+	void TryBindRelation(Relation &relation, vector<ColumnDefinition> &columns) override {
+		GetContext()->InternalTryBindRelation(relation, columns);
+	}
+
+private:
+	weak_ptr<ClientContext> client_context;
+};
+
 class Relation : public enable_shared_from_this<Relation> {
 public:
-	Relation(const shared_ptr<ClientContext> &context, RelationType type) : context(context), type(type) {
+	Relation(const shared_ptr<ClientContext> &context_p, const RelationType type) : type(type) {
+		context = make_shared_ptr<ClientContextWrapper>(context_p);
 	}
-	Relation(ClientContextWrapper &context, RelationType type) : context(context.GetContext()), type(type) {
+	Relation(const shared_ptr<ClientContextWrapper> &context, RelationType type, const string &alias_p = "")
+	    : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {
 	}
-	virtual ~Relation() {
+
+	Relation(const shared_ptr<RelationContextWrapper> &context, RelationType type, const string &alias_p = "")
+	    : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {
 	}
 
-	ClientContextWrapper context;
+	virtual ~Relation() = default;
+
+	shared_ptr<ClientContextWrapper> context;
 	RelationType type;
+	const string alias;
 	vector<shared_ptr<ExternalDependency>> external_dependencies;
 
 public:
@@ -64,7 +93,7 @@ public:
 	DUCKDB_API shared_ptr<Relation> CreateView(const string &name, bool replace = true, bool temporary = false);
 	DUCKDB_API shared_ptr<Relation> CreateView(const string &schema_name, const string &name, bool replace = true,
 	                                           bool temporary = false);
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &sql);
+	DUCKDB_API unique_ptr<QueryResult> Query(const string &sql) const;
 	DUCKDB_API unique_ptr<QueryResult> Query(const string &name, const string &sql);
 
 	//! Explain the query plan of this relation
@@ -75,6 +104,7 @@ public:
 	virtual bool IsReadOnly() {
 		return true;
 	}
+	DUCKDB_API void TryBindRelation(vector<ColumnDefinition> &columns);
 
 public:
 	// PROJECT
@@ -135,11 +165,15 @@ public:
 	DUCKDB_API void Insert(const string &schema_name, const string &table_name);
 	//! Insert a row (i.e.,list of values) into a table
 	DUCKDB_API void Insert(const vector<vector<Value>> &values);
+	DUCKDB_API void Insert(vector<vector<unique_ptr<ParsedExpression>>> &&expressions);
 	//! Create a table and insert the data from this relation into that table
 	DUCKDB_API shared_ptr<Relation> CreateRel(const string &schema_name, const string &table_name,
-	                                          bool temporary = false);
-	DUCKDB_API void Create(const string &table_name, bool temporary = false);
-	DUCKDB_API void Create(const string &schema_name, const string &table_name, bool temporary = false);
+	                                          bool temporary = false,
+	                                          OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
+	DUCKDB_API void Create(const string &table_name, bool temporary = false,
+	                       OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
+	DUCKDB_API void Create(const string &schema_name, const string &table_name, bool temporary = false,
+	                       OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
 
 	//! Write a relation to a CSV file
 	DUCKDB_API shared_ptr<Relation>
@@ -157,6 +191,8 @@ public:
 
 	//! Update a table, can only be used on a TableRelation
 	DUCKDB_API virtual void Update(const string &update, const string &condition = string());
+	DUCKDB_API virtual void Update(vector<string> column_names, vector<unique_ptr<ParsedExpression>> &&update,
+	                               unique_ptr<ParsedExpression> condition = nullptr);
 	//! Delete from a table, can only be used on a TableRelation
 	DUCKDB_API virtual void Delete(const string &condition = string());
 	//! Create a relation from calling a table in/out function on the input relation
@@ -177,7 +213,7 @@ public:
 	DUCKDB_API vector<shared_ptr<ExternalDependency>> GetAllDependencies();
 
 protected:
-	DUCKDB_API string RenderWhitespace(idx_t depth);
+	DUCKDB_API static string RenderWhitespace(idx_t depth);
 
 public:
 	template <class TARGET>

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

@@ -8,8 +8,13 @@
 
 #pragma once
 
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/on_create_conflict.hpp"
 #include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
@@ -20,15 +25,21 @@ struct CatalogTransaction;
 class DatabaseInstance;
 struct SecretMatch;
 struct SecretEntry;
+class SecretManager;
 
 //! Base class for SecretStorage API
 class SecretStorage {
 	friend class SecretManager;
 
 public:
-	explicit SecretStorage(const string &name) : storage_name(name), persistent(false) {};
+	explicit SecretStorage(const string &name, const int64_t tie_break_offset)
+	    : storage_name(name), tie_break_offset(tie_break_offset), persistent(false) {};
 	virtual ~SecretStorage() = default;
 
+	//! Default storage backend offsets
+	static const int64_t TEMPORARY_STORAGE_OFFSET = 10;
+	static const int64_t LOCAL_FILE_STORAGE_OFFSET = 20;
+
 public:
 	//! SecretStorage API
 
@@ -52,9 +63,6 @@ public:
 	virtual unique_ptr<SecretEntry> GetSecretByName(const string &name,
 	                                                optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
 
-	//! Return the offset associated to this storage for tie-breaking secrets between storages
-	virtual int64_t GetTieBreakOffset() = 0;
-
 	//! Returns include_in_lookups, used to create secret storage
 	virtual bool IncludeInLookups() {
 		return true;
@@ -67,16 +75,13 @@ public:
 protected:
 	//! Helper function to select the best matching secret within a storage. Tie-breaks within a storage are broken
 	//! by secret name by default.
-	SecretMatch SelectBestMatch(SecretEntry &secret_entry, const string &path, SecretMatch &current_best);
-
-	//! Offsets the score to tie-break secrets giving preference to the storage with the lowest storage_penalty
-	//! the base implementation will be chosen last in a tie-break
-	int64_t OffsetMatchScore(int64_t score) {
-		return 100 * score - GetTieBreakOffset();
-	}
+	static SecretMatch SelectBestMatch(SecretEntry &secret_entry, const string &path, int64_t offset,
+	                                   SecretMatch &current_best);
 
 	//! Name of the storage backend (e.g. temporary, file, etc)
 	string storage_name;
+	//! Offset associated to this storage for tie-breaking secrets between storages
+	const int64_t tie_break_offset;
 	//! Whether entries in this storage will survive duckdb reboots
 	bool persistent;
 };
@@ -94,8 +99,8 @@ public:
 //! Base Implementation for catalog set based secret storage
 class CatalogSetSecretStorage : public SecretStorage {
 public:
-	CatalogSetSecretStorage(DatabaseInstance &db_instance, const string &name_p)
-	    : SecretStorage(name_p), db(db_instance) {};
+	CatalogSetSecretStorage(DatabaseInstance &db_instance, const string &name_p, const int64_t offset)
+	    : SecretStorage(name_p, offset), db(db_instance) {};
 
 public:
 	//! SecretStorage API
@@ -128,15 +133,12 @@ protected:
 
 class TemporarySecretStorage : public CatalogSetSecretStorage {
 public:
-	TemporarySecretStorage(const string &name_p, DatabaseInstance &db_p) : CatalogSetSecretStorage(db_p, name_p) {
+	TemporarySecretStorage(const string &name_p, DatabaseInstance &db_p)
+	    : CatalogSetSecretStorage(db_p, name_p, TEMPORARY_STORAGE_OFFSET) {
 		secrets = make_uniq<CatalogSet>(Catalog::GetSystemCatalog(db));
 		persistent = false;
 	}
 
-	int64_t GetTieBreakOffset() override {
-		return 10;
-	}
-
 protected:
 };
 
@@ -145,10 +147,6 @@ public:
 	LocalFileSecretStorage(SecretManager &manager, DatabaseInstance &db, const string &name_p,
 	                       const string &secret_path);
 
-	int64_t GetTieBreakOffset() override {
-		return 20;
-	}
-
 protected:
 	//! Implements the writes to disk
 	void WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict) override;