duckdb::KeyValueSecret Class Reference

#include <duckdb.hpp>

Inheritance diagram for duckdb::KeyValueSecret:

Collaboration diagram for duckdb::KeyValueSecret:

Public Member Functions
	KeyValueSecret (const vector< string > &prefix_paths, const string &type, const string &provider, const string &name)
	KeyValueSecret (const BaseSecret &secret)
	KeyValueSecret (const KeyValueSecret &secret)
	KeyValueSecret (KeyValueSecret &&secret) noexcept
string	ToString (SecretDisplayType mode=SecretDisplayType::REDACTED) const override
	Print the secret as a key value map in the format 'key1=value;key2=value2'.
void	Serialize (Serializer &serializer) const override
	Serialize this secret.
Value	TryGetValue (const string &key, bool error_on_missing=false) const
	Tries to get the value at key <key>, depending on error_on_missing will throw or return Value()
unique_ptr< const BaseSecret >	Clone () const override
bool	TryGetValue (const string &key, Value &result) const
bool	TrySetValue (const string &key, const CreateSecretInput &input)
Public Member Functions inherited from duckdb::BaseSecret
	BaseSecret (vector< string > prefix_paths_p, string type_p, string provider_p, string name_p)
	BaseSecret (const BaseSecret &other)
virtual int64_t	MatchScore (const string &path) const
const vector< string > &	GetScope () const
	Getters.
const string &	GetType () const
const string &	GetProvider () const
const string &	GetName () const
bool	IsSerializable () const

Static Public Member Functions
template<class TYPE >
static unique_ptr< BaseSecret >	Deserialize (Deserializer &deserializer, BaseSecret base_secret)

Public Attributes
case_insensitive_tree_t< Value >	secret_map
	the map of key -> values that make up the secret
case_insensitive_set_t	redact_keys
	keys that are sensitive and should be redacted

Additional Inherited Members
Protected Member Functions inherited from duckdb::BaseSecret
virtual void	SerializeBaseSecret (Serializer &serializer) const final
	Helper function to serialize the base BaseSecret class variables.
Protected Attributes inherited from duckdb::BaseSecret
vector< string >	prefix_paths
	prefixes to which the secret applies
string	type
	Type of secret.
string	provider
	Provider of the secret.
string	name
	Name of the secret.
bool	serializable
	Whether the secret can be serialized/deserialized.

Detailed Description

The KeyValueSecret is a class that implements a Secret as a set of key -> values. This class can be used for most use-cases of secrets as secrets generally tend to fit in a key value map.

Constructor & Destructor Documentation

KeyValueSecret() [1/4]

duckdb::KeyValueSecret::KeyValueSecret ( const vector< string > &  prefix_paths, const string &  type, const string &  provider, const string &  name  )

inline

        : BaseSecret(prefix_paths, type, provider, name) {
        D_ASSERT(!type.empty());
        serializable = true;
    }

KeyValueSecret() [2/4]

duckdb::KeyValueSecret::KeyValueSecret ( const BaseSecret &  secret )

inlineexplicit

        : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
        serializable = true;
    };

KeyValueSecret() [3/4]

duckdb::KeyValueSecret::KeyValueSecret ( const KeyValueSecret &  secret )

inline

        : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
        secret_map = secret.secret_map;
        redact_keys = secret.redact_keys;
        serializable = true;
    };

KeyValueSecret() [4/4]

duckdb::KeyValueSecret::KeyValueSecret ( KeyValueSecret &&  secret )

inlinenoexcept

        : 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;
    };

Member Function Documentation

ToString()

string duckdb::KeyValueSecret::ToString ( SecretDisplayType  mode = SecretDisplayType::REDACTED ) const

overridevirtual

Print the secret as a key value map in the format 'key1=value;key2=value2'.

Reimplemented from duckdb::BaseSecret.

Serialize()

void duckdb::KeyValueSecret::Serialize ( Serializer &  serializer ) const

overridevirtual

Serialize this secret.

Reimplemented from duckdb::BaseSecret.

Deserialize()

template<class TYPE >

static unique_ptr< BaseSecret > duckdb::KeyValueSecret::Deserialize ( Deserializer &  deserializer, BaseSecret  base_secret  )

inlinestatic

                                                                                                  {
        auto result = make_uniq<TYPE>(base_secret);
        Value secret_map_value;
        deserializer.ReadProperty(201, "secret_map", secret_map_value);
 
        for (const auto &entry : ListValue::GetChildren(secret_map_value)) {
            auto kv_struct = StructValue::GetChildren(entry);
            result->secret_map[kv_struct[0].ToString()] = kv_struct[1];
        }
 
        Value redact_set_value;
        deserializer.ReadProperty(202, "redact_keys", redact_set_value);
        for (const auto &entry : ListValue::GetChildren(redact_set_value)) {
            result->redact_keys.insert(entry.ToString());
        }
 
        return duckdb::unique_ptr_cast<TYPE, BaseSecret>(std::move(result));
    }

Clone()

unique_ptr< const BaseSecret > duckdb::KeyValueSecret::Clone ( ) const

inlineoverridevirtual

Reimplemented from duckdb::BaseSecret.

                                                        {
        return make_uniq<KeyValueSecret>(*this);
    }

TryGetValue()

bool duckdb::KeyValueSecret::TryGetValue ( const string &  key, Value &  result  ) const

inline

                                                             {
        auto lookup = secret_map.find(key);
        if (lookup == secret_map.end()) {
            return false;
        }
        result = lookup->second;
        return true;
    }

TrySetValue()

bool duckdb::KeyValueSecret::TrySetValue ( const string &  key, const CreateSecretInput &  input  )

inline

                                                                        {
        auto lookup = input.options.find(key);
        if (lookup != input.options.end()) {
            secret_map[key] = lookup->second;
            return true;
        }
        return false;
    }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.hpp