Collaboration diagram for duckdb::DBConfig:

[legend]

Public Member Functions
DUCKDB_API	DBConfig (bool read_only)

DUCKDB_API	DBConfig (const case_insensitive_map_t< Value > &config_dict, bool read_only)

DUCKDB_API void	AddExtensionOption (const string &name, string description, LogicalType parameter, const Value &default_value=Value(), set_option_callback_t function=nullptr, SetScope default_scope=SetScope::SESSION)

DUCKDB_API bool	HasExtensionOption (const string &name) const

DUCKDB_API case_insensitive_map_t< ExtensionOption >	GetExtensionSettings () const

DUCKDB_API bool	TryGetExtensionOption (const String &name, ExtensionOption &result) const

DUCKDB_API void	SetOption (const ConfigurationOption &option, const Value &value)

DUCKDB_API void	SetOption (optional_ptr< DatabaseInstance > db, const ConfigurationOption &option, const Value &value)

DUCKDB_API void	SetOption (const string &name, Value value)

DUCKDB_API void	SetOption (idx_t setting_index, Value value)

DUCKDB_API void	SetOptionByName (const string &name, const Value &value)

DUCKDB_API void	SetOptionsByName (const case_insensitive_map_t< Value > &values)

DUCKDB_API void	ResetOption (optional_ptr< DatabaseInstance > db, const ConfigurationOption &option)

DUCKDB_API void	ResetOption (const ExtensionOption &extension_option)

DUCKDB_API void	ResetGenericOption (idx_t setting_index)

DUCKDB_API optional_idx	TryGetSettingIndex (const String &name, optional_ptr< const ConfigurationOption > &option) const

DUCKDB_API void	CheckLock (const String &name)

DUCKDB_API vector< reference< const CompressionFunction > >	GetCompressionFunctions (const PhysicalType physical_type) const
	Returns the list of possible compression functions for the physical type.

DUCKDB_API reference< const CompressionFunction >	GetCompressionFunction (CompressionType type, const PhysicalType physical_type) const

DUCKDB_API optional_ptr< const CompressionFunction >	TryGetCompressionFunction (CompressionType type, const PhysicalType physical_type) const

DUCKDB_API void	SetDisabledCompressionMethods (const vector< CompressionType > &disabled_compression_methods)
	Sets the disabled compression methods.

DUCKDB_API vector< CompressionType >	GetDisabledCompressionMethods () const
	Returns a list of disabled compression methods.

DUCKDB_API optional_ptr< EncodingFunction >	GetEncodeFunction (const string &name) const
	Returns the encode function matching the encoding name.

DUCKDB_API void	RegisterEncodeFunction (const EncodingFunction &function) const

DUCKDB_API vector< reference< EncodingFunction > >	GetLoadedEncodedFunctions () const
	Returns the encode function names.

DUCKDB_API ArrowTypeExtension	GetArrowExtension (ArrowExtensionMetadata info) const
	Returns the encode function matching the encoding name.

DUCKDB_API ArrowTypeExtension	GetArrowExtension (const LogicalType &type) const

DUCKDB_API bool	HasArrowExtension (const LogicalType &type) const

DUCKDB_API bool	HasArrowExtension (ArrowExtensionMetadata info) const

DUCKDB_API void	RegisterArrowExtension (const ArrowTypeExtension &extension) const

bool	operator== (const DBConfig &other)

bool	operator!= (const DBConfig &other)

DUCKDB_API CastFunctionSet &	GetCastFunctions ()

DUCKDB_API TypeManager &	GetTypeManager ()

DUCKDB_API CollationBinding &	GetCollationBinding ()

DUCKDB_API IndexTypeSet &	GetIndexTypes ()

void	SetDefaultMaxMemory ()

void	SetDefaultTempDirectory ()

OrderType	ResolveOrder (ClientContext &context, OrderType order_type) const

OrderByNullType	ResolveNullOrder (ClientContext &context, OrderType order_type, OrderByNullType null_type) const

const string	UserAgent () const

SettingLookupResult	TryGetCurrentSetting (const string &key, Value &result) const
	Returns the value of a setting currently. If the setting is not set by the user, returns the default value.

SettingLookupResult	TryGetCurrentUserSetting (idx_t setting_index, Value &result) const
	Returns the value of a setting set by the user currently.

bool	CanAccessFile (const string &path, FileType type)

void	AddAllowedConfig (const string &config_name)

void	AddAllowedDirectory (const string &path)

void	AddAllowedPath (const string &path)

string	SanitizeAllowedPath (const string &path) const

ExtensionCallbackManager &	GetCallbackManager ()

const ExtensionCallbackManager &	GetCallbackManager () const

void	SetHTTPUtil (const shared_ptr< HTTPUtil > &new_http_util)

HTTPUtil &	GetHTTPUtil () const

Static Public Member Functions
static DUCKDB_API DBConfig &	GetConfig (ClientContext &context)

static DUCKDB_API DBConfig &	GetConfig (DatabaseInstance &db)

static DUCKDB_API DBConfig &	Get (AttachedDatabase &db)

static DUCKDB_API const DBConfig &	GetConfig (const ClientContext &context)

static DUCKDB_API const DBConfig &	GetConfig (const DatabaseInstance &db)

static DUCKDB_API vector< ConfigurationOption >	GetOptions ()

static DUCKDB_API vector< ConfigurationAlias >	GetAliases ()

static DUCKDB_API idx_t	GetOptionCount ()

static DUCKDB_API idx_t	GetAliasCount ()

static DUCKDB_API vector< string >	GetOptionNames ()

static DUCKDB_API bool	IsInMemoryDatabase (const char *database_path)

static DUCKDB_API optional_ptr< const ConfigurationOption >	GetOptionByIndex (idx_t index)
	Fetch an option by index. Returns a pointer to the option, or nullptr if out of range.

static DUCKDB_API optional_ptr< const ConfigurationAlias >	GetAliasByIndex (idx_t index)
	Fetcha n alias by index, or nullptr if out of range.

static DUCKDB_API optional_ptr< const ConfigurationOption >	GetOptionByName (const String &name)
	Fetch an option by name. Returns a pointer to the option, or nullptr if none exists.

static LogicalType	ParseLogicalType (const string &type)

static DUCKDB_API idx_t	ParseMemoryLimit (const string &arg)

static idx_t	GetSystemMaxThreads (FileSystem &fs)

static idx_t	GetSystemAvailableMemory (FileSystem &fs)

static optional_idx	ParseMemoryLimitSlurm (const string &arg)

static SettingLookupResult	TryGetDefaultValue (optional_ptr< const ConfigurationOption > option, Value &result)
	Returns the default value of an option.

Public Attributes
vector< ReplacementScan >	replacement_scans
	Replacement table scans are automatically attempted when a table name cannot be found in the schema.

unique_ptr< FileSystem >	file_system

unique_ptr< SecretManager >	secret_manager
	Secret manager.

unique_ptr< Allocator >	allocator
	The allocator used by the system.

unique_ptr< BlockAllocator >	block_allocator
	The block allocator used by the system.

DBConfigOptions	options
	Database configuration options.

unique_ptr< ErrorManager >	error_manager
	Error manager.

shared_ptr< Allocator >	default_allocator
	A reference to the (shared) default allocator (Allocator::DefaultAllocator)

shared_ptr< BufferPool >	buffer_pool
	A buffer pool can be shared across multiple databases (if desired).

shared_ptr< BufferManager >	buffer_manager
	Provide a custom buffer manager implementation (if desired).

shared_ptr< EncryptionUtil >	encryption_util
	Encryption Util for OpenSSL and MbedTLS.

shared_ptr< DatabaseCacheEntry >	db_cache_entry
	Reference to the database cache entry (if any)

shared_ptr< DatabaseFilePathManager >	path_manager
	Reference to the database file path manager.

GlobalUserSettings	user_settings
	Database configuration variables as controlled by SET.

Private Attributes
mutex	config_lock

unique_ptr< CompressionFunctionSet >	compression_functions

unique_ptr< EncodingFunctionSet >	encoding_functions

unique_ptr< ArrowTypeExtensionSet >	arrow_extensions

unique_ptr< TypeManager >	type_manager

unique_ptr< CollationBinding >	collation_bindings

unique_ptr< IndexTypeSet >	index_types

unique_ptr< ExtensionCallbackManager >	callback_manager

bool	is_user_config = true

shared_ptr< HTTPUtil >	http_util
	HTTP Request utility functions.

vector< shared_ptr< HTTPUtil > >	old_http_utils

mutex	http_util_lock

Friends
class	DatabaseInstance

class	StorageManager

Member Function Documentation

◆ GetCompressionFunction()

DUCKDB_API reference< const CompressionFunction > duckdb::DBConfig::GetCompressionFunction	(	CompressionType	type,
		const PhysicalType	physical_type
	)		const

Returns the compression function matching the compression and physical type. Throws an error if the function does not exist.

◆ GetArrowExtension() [1/2]

ArrowTypeExtension duckdb::DBConfig::GetArrowExtension ( ArrowExtensionMetadata info ) const

Returns the encode function matching the encoding name.

                                                                                {
    lock_guard<mutex> l(arrow_extensions->lock);
    return GetArrowExtensionInternal(arrow_extensions->type_extensions, std::move(info));
}

◆ GetArrowExtension() [2/2]

ArrowTypeExtension duckdb::DBConfig::GetArrowExtension ( const LogicalType & type ) const

                                                                            {
    lock_guard<mutex> l(arrow_extensions->lock);
    TypeInfo type_info(type);
    if (!arrow_extensions->type_to_info[type_info].empty()) {
        return GetArrowExtensionInternal(arrow_extensions->type_extensions,
                                         arrow_extensions->type_to_info[type_info].front());
    }
    type_info.type = LogicalTypeId::ANY;
    return GetArrowExtensionInternal(arrow_extensions->type_extensions,
                                     arrow_extensions->type_to_info[type_info].front());
}

◆ HasArrowExtension() [1/2]

bool duckdb::DBConfig::HasArrowExtension ( const LogicalType & type ) const

                                                              {
    lock_guard<mutex> l(arrow_extensions->lock);
    TypeInfo type_info(type);
    if (!arrow_extensions->type_to_info[type_info].empty()) {
        return true;
    }
    type_info.type = LogicalTypeId::ANY;
    return !arrow_extensions->type_to_info[type_info].empty();
}

◆ HasArrowExtension() [2/2]

bool duckdb::DBConfig::HasArrowExtension ( ArrowExtensionMetadata info ) const

                                                                  {
    lock_guard<mutex> l(arrow_extensions->lock);
    auto type_extensions = arrow_extensions->type_extensions;
 
    if (type_extensions.find(info) != type_extensions.end()) {
        return true;
    }
 
    auto og_info = info;
    info.SetArrowFormat("");
    if (type_extensions.find(info) != type_extensions.end()) {
        return true;
    }
 
    return false;
}

◆ RegisterArrowExtension()

void duckdb::DBConfig::RegisterArrowExtension ( const ArrowTypeExtension & extension ) const

                                                                               {
    lock_guard<mutex> l(arrow_extensions->lock);
    auto extension_info = extension.GetInfo();
    if (arrow_extensions->type_extensions.find(extension_info) != arrow_extensions->type_extensions.end()) {
        throw NotImplementedException("Arrow Extension with configuration %s is already registered",
                                      extension_info.ToString());
    }
    arrow_extensions->type_extensions[extension_info] = extension;
    if (extension.HasType()) {
        const TypeInfo type_info(extension.GetLogicalType());
        arrow_extensions->type_to_info[type_info].push_back(extension_info);
        return;
    }
    const TypeInfo type_info(extension.GetInfo().GetExtensionName());
    arrow_extensions->type_to_info[type_info].push_back(extension_info);
}

Member Data Documentation

◆ file_system

unique_ptr<FileSystem> duckdb::DBConfig::file_system

The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g. RamFS or something similar)

The documentation for this struct was generated from the following files:

external/duckdb/duckdb.hpp
external/duckdb/duckdb.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Private Attributes

Friends