Inheritance diagram for duckdb::ClientContext:

Collaboration diagram for duckdb::ClientContext:

[legend]

Public Member Functions
DUCKDB_API	ClientContext (shared_ptr< DatabaseInstance > db)

MetaTransaction &	ActiveTransaction ()

DUCKDB_API void	Interrupt ()
	Interrupt execution of a query.

DUCKDB_API bool	IsInterrupted () const

DUCKDB_API void	ClearInterrupt ()

DUCKDB_API void	CancelTransaction ()

DUCKDB_API void	EnableProfiling ()
	Enable query profiling.

DUCKDB_API void	DisableProfiling ()
	Disable query profiling.

DUCKDB_API unique_ptr< QueryResult >	Query (const string &query, QueryParameters query_parameters)

DUCKDB_API unique_ptr< QueryResult >	Query (unique_ptr< SQLStatement > statement, QueryParameters query_parameters)

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (const string &query, QueryParameters query_parameters)

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (unique_ptr< SQLStatement > statement, QueryParameters query_parameters)
	Issues a query to the database and returns a Pending Query Result.

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (unique_ptr< SQLStatement > statement, case_insensitive_map_t< BoundParameterData > &values, QueryParameters query_parameters)
	Create a pending query with a list of parameters.

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (const string &query, case_insensitive_map_t< BoundParameterData > &values, QueryParameters query_parameters)

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (const string &query, PendingQueryParameters parameters)

DUCKDB_API void	Destroy ()
	Destroy the client context.

DUCKDB_API unique_ptr< TableDescription >	TableInfo (const string &database_name, const string &schema_name, const string &table_name)
	Get the table info of a specific table, or nullptr if it cannot be found.

DUCKDB_API unique_ptr< TableDescription >	TableInfo (const string &schema_name, const string &table_name)
	Get the table info of a specific table, or nullptr if it cannot be found. Uses INVALID_CATALOG.

DUCKDB_API void	Append (unique_ptr< SQLStatement > stmt)
	Executes a query with the given collection "attached" to the query using a CTE.

DUCKDB_API void	Append (TableDescription &description, ColumnDataCollection &collection)
	Appends a ColumnDataCollection to the described table.

DUCKDB_API void	TryBindRelation (Relation &relation, vector< ColumnDefinition > &result_columns)

DUCKDB_API void	InternalTryBindRelation (Relation &relation, vector< ColumnDefinition > &result_columns)
	Internal function for try bind relation. It does not require a client-context lock.

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (const shared_ptr< Relation > &relation, QueryParameters query_parameters)
	Execute a relation.

DUCKDB_API unique_ptr< QueryResult >	Execute (const shared_ptr< Relation > &relation)

DUCKDB_API unique_ptr< PreparedStatement >	Prepare (const string &query)
	Prepare a query.

DUCKDB_API unique_ptr< PreparedStatement >	Prepare (unique_ptr< SQLStatement > statement)
	Directly prepare a SQL statement.

DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (const string &query, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

DUCKDB_API unique_ptr< QueryResult >	Execute (const string &query, shared_ptr< PreparedStatementData > &prepared, case_insensitive_map_t< BoundParameterData > &values, QueryParameters query_parameters=QueryResultOutputType::ALLOW_STREAMING)

DUCKDB_API unique_ptr< QueryResult >	Execute (const string &query, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

DUCKDB_API QueryProgress	GetQueryProgress ()
	Gets current percentage of the query's progress, returns 0 in case the progress bar is disabled.

DUCKDB_API void	RegisterFunction (CreateFunctionInfo &info)
	Register function in the temporary schema.

DUCKDB_API vector< unique_ptr< SQLStatement > >	ParseStatements (const string &query)
	Parse statements from a query.

DUCKDB_API unique_ptr< LogicalOperator >	ExtractPlan (const string &query)
	Extract the logical plan of a query.

DUCKDB_API void	PreprocessStatements (vector< unique_ptr< SQLStatement > > &statements)

DUCKDB_API void	RunFunctionInTransaction (const std::function< void(void)> &fun, bool requires_valid_transaction=true)

DUCKDB_API void	RunFunctionInTransactionInternal (ClientContextLock &lock, const std::function< void(void)> &fun, bool requires_valid_transaction=true)
	Same as RunFunctionInTransaction, but does not obtain a lock on the client context or check for validation.

DUCKDB_API SettingLookupResult	TryGetCurrentSetting (const string &key, Value &result) const
	Equivalent to CURRENT_SETTING(key) SQL function.

DUCKDB_API SettingLookupResult	TryGetCurrentUserSetting (idx_t setting_index, Value &result) const
	Returns the value of the current setting set by the user - if the user has set it.

DUCKDB_API ParserOptions	GetParserOptions () const
	Returns the parser options for this client context.

DUCKDB_API bool	IsActiveResult (ClientContextLock &lock, BaseQueryResult &result)
	Whether or not the given result object (streaming query result or pending query result) is active.

Executor &	GetExecutor ()
	Returns the current executor.

Logger &	GetLogger () const
	Return the current logger.

const string &	GetCurrentQuery ()
	Returns the current query string (if any)

connection_t	GetConnectionId () const

DUCKDB_API unordered_set< string >	GetTableNames (const string &query, const bool qualified=false)

DUCKDB_API ClientProperties	GetClientProperties ()

DUCKDB_API bool	ExecutionIsFinished ()
	Returns true if execution of the current query is finished.

DUCKDB_API void	ProcessError (ErrorData &error, const string &query) const
	Process an error for display to the user.

DUCKDB_API LogicalType	ParseLogicalType (const string &type)

Public Member Functions inherited from duckdb::enable_shared_from_this< ClientContext >
shared_ptr< ClientContext >	shared_from_this ()

shared_ptr< ClientContext const >	shared_from_this () const

Public Attributes
shared_ptr< DatabaseInstance >	db
	The database that this client is connected to.

atomic< bool >	interrupted
	Whether or not the query is interrupted.

unique_ptr< RegisteredStateManager >	registered_state
	Set of optional states (e.g. Caches) that can be held by the ClientContext.

shared_ptr< Logger >	logger
	The logger to be used by this ClientContext.

ClientConfig	config
	The client configuration.

unique_ptr< ClientData >	client_data
	The set of client-specific data.

TransactionContext	transaction
	Data for the currently running transaction.

Private Member Functions
vector< unique_ptr< SQLStatement > >	ParseStatements (ClientContextLock &lock, const string &query)
	Parse statements and resolve pragmas from a query.

unique_ptr< PendingQueryResult >	PendingQueryInternal (ClientContextLock &lock, unique_ptr< SQLStatement > statement, const PendingQueryParameters &parameters, bool verify=true)
	Issues a query to the database and returns a Pending Query Result.

unique_ptr< QueryResult >	ExecutePendingQueryInternal (ClientContextLock &lock, PendingQueryResult &query)

vector< unique_ptr< SQLStatement > >	ParseStatementsInternal (ClientContextLock &lock, const string &query)
	Parse statements from a query.

ErrorData	VerifyQuery (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, PendingQueryParameters parameters)

void	InitialCleanup (ClientContextLock &lock)

void	CleanupInternal (ClientContextLock &lock, BaseQueryResult *result=nullptr, bool invalidate_transaction=false)
	Internal clean up, does not lock. Caller must hold the context_lock.

unique_ptr< PendingQueryResult >	PendingStatementOrPreparedStatement (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

unique_ptr< PendingQueryResult >	PendingPreparedStatement (ClientContextLock &lock, const string &query, shared_ptr< PreparedStatementData > statement_p, const PendingQueryParameters &parameters)

unique_ptr< PendingQueryResult >	PendingPreparedStatementInternal (ClientContextLock &lock, shared_ptr< PreparedStatementData > statement_data_p, const PendingQueryParameters &parameters)

void	CheckIfPreparedStatementIsExecutable (PreparedStatementData &statement)

shared_ptr< PreparedStatementData >	CreatePreparedStatement (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, PendingQueryParameters parameters, PreparedStatementMode mode=PreparedStatementMode::PREPARE_ONLY)
	Internally prepare a SQL statement. Caller must hold the context_lock.

unique_ptr< PendingQueryResult >	PendingStatementInternal (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, const PendingQueryParameters &parameters)

unique_ptr< QueryResult >	RunStatementInternal (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, const PendingQueryParameters &parameters, bool verify=true)

unique_ptr< PreparedStatement >	PrepareInternal (ClientContextLock &lock, unique_ptr< SQLStatement > statement)

void	LogQueryInternal (ClientContextLock &lock, const string &query)

unique_ptr< QueryResult >	FetchResultInternal (ClientContextLock &lock, PendingQueryResult &pending)

unique_ptr< ClientContextLock >	LockContext ()

void	BeginQueryInternal (ClientContextLock &lock, const string &query)

ErrorData	EndQueryInternal (ClientContextLock &lock, bool success, bool invalidate_transaction, optional_ptr< ErrorData > previous_error)

void	WaitForTask (ClientContextLock &lock, BaseQueryResult &result)
	Wait until a task is available to execute.

PendingExecutionResult	ExecuteTaskInternal (ClientContextLock &lock, BaseQueryResult &result, bool dry_run=false)

unique_ptr< PendingQueryResult >	PendingStatementOrPreparedStatementInternal (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

unique_ptr< PendingQueryResult >	PendingQueryPreparedInternal (ClientContextLock &lock, const string &query, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

unique_ptr< PendingQueryResult >	PendingQueryInternal (ClientContextLock &, const shared_ptr< Relation > &relation, QueryParameters query_parameters)

void	RebindPreparedStatement (ClientContextLock &lock, const string &query, shared_ptr< PreparedStatementData > &prepared, const PendingQueryParameters &parameters)

template<class T >
unique_ptr< T >	ErrorResult (ErrorData error, const string &query=string())

shared_ptr< PreparedStatementData >	CreatePreparedStatementInternal (ClientContextLock &lock, const string &query, unique_ptr< SQLStatement > statement, PendingQueryParameters parameters)

bool	ErrorInvalidatesTransaction (ExceptionType type)

Private Attributes
mutex	context_lock
	Lock on using the ClientContext in parallel.

unique_ptr< ActiveQueryContext >	active_query
	The currently active query context.

QueryProgress	query_progress
	The current query progress.

connection_t	connection_id
	The connection corresponding to this client context.

Friends
class	PendingQueryResult

class	BufferedData

class	SimpleBufferedData

class	BatchedBufferedData

class	StreamQueryResult

class	ConnectionManager

Additional Inherited Members
Protected Member Functions inherited from duckdb::enable_shared_from_this< ClientContext >
	enable_shared_from_this (enable_shared_from_this const &) noexcept

enable_shared_from_this &	operator= (enable_shared_from_this const &) noexcept

Detailed Description

The ClientContext holds information relevant to the current client session during execution

Member Function Documentation

◆ ActiveTransaction()

MetaTransaction & duckdb::ClientContext::ActiveTransaction ( )

inline

                                         {
        return transaction.ActiveTransaction();
    }

◆ Query()

DUCKDB_API unique_ptr< QueryResult > duckdb::ClientContext::Query	(	const string &	query,
		QueryParameters	query_parameters
	)

Issue a query, returning a QueryResult. The QueryResult can be either a StreamQueryResult or a MaterializedQueryResult. The StreamQueryResult will only be returned in the case of a successful SELECT statement.

◆ PendingQuery() [1/2]

DUCKDB_API unique_ptr< PendingQueryResult > duckdb::ClientContext::PendingQuery	(	const string &	query,
		QueryParameters	query_parameters
	)

Issues a query to the database and returns a Pending Query Result. Note that "query" may only contain a single statement.

◆ TryBindRelation()

DUCKDB_API void duckdb::ClientContext::TryBindRelation	(	Relation &	relation,
		vector< ColumnDefinition > &	result_columns
	)

Try to bind a relation in the current client context; either throws an exception or fills the result_columns list with the set of returned columns

◆ PendingQuery() [2/2]

DUCKDB_API unique_ptr< PendingQueryResult > duckdb::ClientContext::PendingQuery	(	const string &	query,
		shared_ptr< PreparedStatementData > &	prepared,
		const PendingQueryParameters &	parameters
	)

Create a pending query result from a prepared statement with the given name and set of parameters It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is modified in between the prepared statement being bound and the prepared statement being run.

◆ Execute()

DUCKDB_API unique_ptr< QueryResult > duckdb::ClientContext::Execute	(	const string &	query,
		shared_ptr< PreparedStatementData > &	prepared,
		case_insensitive_map_t< BoundParameterData > &	values,
		QueryParameters	query_parameters = `QueryResultOutputType::ALLOW_STREAMING`
	)

Execute a prepared statement with the given name and set of parameters It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is modified in between the prepared statement being bound and the prepared statement being run.

◆ RunFunctionInTransaction()

DUCKDB_API void duckdb::ClientContext::RunFunctionInTransaction	(	const std::function< void(void)> &	fun,
		bool	requires_valid_transaction = `true`
	)

Runs a function with a valid transaction context, potentially starting a transaction if the context is in auto commit mode.

◆ GetTableNames()

DUCKDB_API unordered_set< string > duckdb::ClientContext::GetTableNames	(	const string &	query,
		const bool	qualified = `false`
	)

Fetch the set of tables names of the query. Returns the fully qualified, escaped table names, if qualified is set to true, else returns the not qualified, not escaped table names.

◆ VerifyQuery()

ErrorData duckdb::ClientContext::VerifyQuery	(	ClientContextLock &	lock,
		const string &	query,
		unique_ptr< SQLStatement >	statement,
		PendingQueryParameters	parameters
	)

private

Perform aggressive query verification of a SELECT statement. Only called when query_verification_enabled is true.

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

external/duckdb/duckdb.hpp

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members