duckdb::PreparedStatement Class Reference

A prepared statement. More...

Collaboration diagram for duckdb::PreparedStatement:

Public Member Functions
DUCKDB_API	PreparedStatement (shared_ptr< ClientContext > context, shared_ptr< PreparedStatementData > data, string query, case_insensitive_map_t< idx_t > named_param_map)
	Create a successfully prepared prepared statement object with the given name.
DUCKDB_API	PreparedStatement (ErrorData error)
	Create a prepared statement that was not successfully prepared.
DUCKDB_API const string &	GetError ()
	Returns the stored error message.
DUCKDB_API ErrorData &	GetErrorObject ()
	Returns the stored error object.
DUCKDB_API bool	HasError () const
	Returns whether or not an error occurred.
DUCKDB_API idx_t	ColumnCount ()
	Returns the number of columns in the result.
DUCKDB_API StatementType	GetStatementType ()
	Returns the statement type of the underlying prepared statement object.
DUCKDB_API StatementProperties	GetStatementProperties ()
	Returns the underlying statement properties.
DUCKDB_API const vector< LogicalType > &	GetTypes ()
	Returns the result SQL types of the prepared statement.
DUCKDB_API const vector< string > &	GetNames ()
	Returns the result names of the prepared statement.
DUCKDB_API case_insensitive_map_t< LogicalType >	GetExpectedParameterTypes () const
	Returns the map of parameter index to the expected type of parameter.
template<typename... ARGS>
unique_ptr< PendingQueryResult >	PendingQuery (ARGS... args)
	Create a pending query result of the prepared statement with the given set of arguments.
DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (vector< Value > &values, bool allow_stream_result=true)
	Create a pending query result of the prepared statement with the given set of arguments.
DUCKDB_API unique_ptr< PendingQueryResult >	PendingQuery (case_insensitive_map_t< BoundParameterData > &named_values, bool allow_stream_result=true)
	Create a pending query result of the prepared statement with the given set named arguments.
DUCKDB_API unique_ptr< QueryResult >	Execute (vector< Value > &values, bool allow_stream_result=true)
	Execute the prepared statement with the given set of values.
DUCKDB_API unique_ptr< QueryResult >	Execute (case_insensitive_map_t< BoundParameterData > &named_values, bool allow_stream_result=true)
	Execute the prepared statement with the given set of named+unnamed values.
template<typename... ARGS>
unique_ptr< QueryResult >	Execute (ARGS... args)
	Execute the prepared statement with the given set of arguments.

Static Public Member Functions
template<class PAYLOAD >
static string	ExcessValuesException (const case_insensitive_map_t< idx_t > &parameters, const case_insensitive_map_t< PAYLOAD > &values)
template<class PAYLOAD >
static string	MissingValuesException (const case_insensitive_map_t< idx_t > &parameters, const case_insensitive_map_t< PAYLOAD > &values)
template<class PAYLOAD >
static void	VerifyParameters (const case_insensitive_map_t< PAYLOAD > &provided, const case_insensitive_map_t< idx_t > &expected)
static bool	CanCachePlan (const LogicalOperator &op)
	Returns whether or not we can / want to cache a logical plan.

Public Attributes
shared_ptr< ClientContext >	context
	The client context this prepared statement belongs to.
shared_ptr< PreparedStatementData >	data
	The prepared statement data.
string	query
	The query that is being prepared.
bool	success
	Whether or not the statement was successfully prepared.
ErrorData	error
	The error message (if success = false)
case_insensitive_map_t< idx_t >	named_param_map
	The parameter mapping.

Private Member Functions
unique_ptr< PendingQueryResult >	PendingQueryRecursive (vector< Value > &values)
template<typename T , typename... ARGS>
unique_ptr< PendingQueryResult >	PendingQueryRecursive (vector< Value > &values, T value, ARGS... args)
unique_ptr< QueryResult >	ExecuteRecursive (vector< Value > &values)
template<typename T , typename... ARGS>
unique_ptr< QueryResult >	ExecuteRecursive (vector< Value > &values, T value, ARGS... args)

Detailed Description

A prepared statement.

Member Function Documentation

PendingQuery()

template<typename... ARGS>

unique_ptr< PendingQueryResult > duckdb::PreparedStatement::PendingQuery ( ARGS...  args )

inline

Create a pending query result of the prepared statement with the given set of arguments.

                                                              {
        vector<Value> values;
        return PendingQueryRecursive(values, args...);
    }

Execute()

template<typename... ARGS>

unique_ptr< QueryResult > duckdb::PreparedStatement::Execute ( ARGS...  args )

inline

Execute the prepared statement with the given set of arguments.

                                                  {
        vector<Value> values;
        return ExecuteRecursive(values, args...);
    }

ExcessValuesException()

template<class PAYLOAD >

static string duckdb::PreparedStatement::ExcessValuesException ( const case_insensitive_map_t< idx_t > &  parameters, const case_insensitive_map_t< PAYLOAD > &  values  )

inlinestatic

                                                                                       {
        // Too many values
        set<string> excess_set;
        for (auto &pair : values) {
            auto &name = pair.first;
            if (!parameters.count(name)) {
                excess_set.insert(name);
            }
        }
        vector<string> excess_values;
        for (auto &val : excess_set) {
            excess_values.push_back(val);
        }
        return StringUtil::Format("Parameter argument/count mismatch, identifiers of the excess parameters: %s",
                                  StringUtil::Join(excess_values, ", "));
    }

MissingValuesException()

template<class PAYLOAD >

static string duckdb::PreparedStatement::MissingValuesException ( const case_insensitive_map_t< idx_t > &  parameters, const case_insensitive_map_t< PAYLOAD > &  values  )

inlinestatic

                                                                                        {
        // Missing values
        set<string> missing_set;
        for (auto &pair : parameters) {
            auto &name = pair.first;
            if (!values.count(name)) {
                missing_set.insert(name);
            }
        }
        vector<string> missing_values;
        for (auto &val : missing_set) {
            missing_values.push_back(val);
        }
        return StringUtil::Format("Values were not provided for the following prepared statement parameters: %s",
                                  StringUtil::Join(missing_values, ", "));
    }

VerifyParameters()

template<class PAYLOAD >

static void duckdb::PreparedStatement::VerifyParameters ( const case_insensitive_map_t< PAYLOAD > &  provided, const case_insensitive_map_t< idx_t > &  expected  )

inlinestatic

                                                                                {
        if (expected.size() == provided.size()) {
            // Same amount of identifiers, if
            for (auto &pair : expected) {
                auto &identifier = pair.first;
                if (!provided.count(identifier)) {
                    throw InvalidInputException(MissingValuesException(expected, provided));
                }
            }
            return;
        }
        // Mismatch in expected and provided parameters/values
        if (expected.size() > provided.size()) {
            throw InvalidInputException(MissingValuesException(expected, provided));
        } else {
            D_ASSERT(provided.size() > expected.size());
            throw InvalidInputException(ExcessValuesException(expected, provided));
        }
    }

PendingQueryRecursive() [1/2]

unique_ptr< PendingQueryResult > duckdb::PreparedStatement::PendingQueryRecursive ( vector< Value > &  values )

inlineprivate

                                                                                {
        return PendingQuery(values);
    }

PendingQueryRecursive() [2/2]

template<typename T , typename... ARGS>

unique_ptr< PendingQueryResult > duckdb::PreparedStatement::PendingQueryRecursive ( vector< Value > &  values, T  value, ARGS...  args  )

inlineprivate

                                                                                                       {
        values.push_back(Value::CreateValue<T>(value));
        return PendingQueryRecursive(values, args...);
    }

ExecuteRecursive() [1/2]

unique_ptr< QueryResult > duckdb::PreparedStatement::ExecuteRecursive ( vector< Value > &  values )

inlineprivate

                                                                    {
        return Execute(values);
    }

ExecuteRecursive() [2/2]

template<typename T , typename... ARGS>

unique_ptr< QueryResult > duckdb::PreparedStatement::ExecuteRecursive ( vector< Value > &  values, T  value, ARGS...  args  )

inlineprivate

                                                                                           {
        values.push_back(Value::CreateValue<T>(value));
        return ExecuteRecursive(values, args...);
    }

---

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

• external/duckdb/duckdb.hpp