Struct CallPlan 

pub struct CallPlan {

    pub function: QualifiedIdentifier,
    pub params: CallParams,
    pub returns_scalar: bool,
    pub return_type: Option<String>,
    pub returns_set: bool,
    pub returns_void: bool,
    pub returns_composite: bool,
    pub volatility: String,
    pub param_types: Vec<(String, String)>,
    pub media_type: Option<String>,
    pub media_base_type: Option<String>,
    pub output_columns: Vec<(String, String)>,
    pub variadic_params: Vec<String>,
}

A plan for calling a stored function.

Fields

function: QualifiedIdentifier

Function identifier

params: CallParams

Call parameters

returns_scalar: bool

Whether to return a scalar result

return_type: Option<String>

The declared return type, as PostgreSQL spells it.

Used to decide whether this process can decode the result or whether the database should render it, exactly as for a table’s columns.

returns_set: bool

Whether the function is set-returning

returns_void: bool

Whether the function returns nothing at all.

A void function has no result to report, which is 204 rather than a body of null – and RetType::Void has no type name, so asking for one would never find it.

returns_composite: bool

Whether the return type is composite (row type or record): its columns are real output columns, never the function-name wrapper.

volatility: String

Function volatility (for transaction handling)

param_types: Vec<(String, String)>

Declared parameter types, in the routine’s own order, as (name, pg_type).

Arguments arrive from the URL or a JSON body as strings. Binding them as text leaves PostgreSQL unable to resolve any signature that isn’t text – add_them(a => text, b => text) does not exist – so each one is cast to its declared type at call time.

The type is the one an argument can be cast to without losing part of itself: a char(4) parameter is stored as bare character, whose length is one, and a parameter’s length is not enforced anyway.

media_type: Option<String>

The media type the function’s value already is, where its return type is a domain that says so.

The result is that media type rather than something to serialise as JSON, so it is returned verbatim – but only where the client asked for it, since a function whose value is a PNG is still a value a client may want as JSON.

media_base_type: Option<String>

The type that domain is a domain over – what says whether the value is bytes or text.

output_columns: Vec<(String, String)>

The columns the result has, where the function declares its own.

RETURNS TABLE(a text, b colour) has no table to read the result’s shape from, so SELECT * is all that can be asked for – and a column of a type this process cannot decode comes back null. Knowing the columns is what lets the database render those instead.

variadic_params: Vec<String>

The names of the parameters declared VARIADIC.

Named notation spells one VARIADIC v := ...; v => ... finds no function at all, because the array is the whole of the variadic tail rather than one value of it.

Implementations

impl CallPlan

pub fn from_request(request: &ApiRequest, routine: &Routine) -> Result<Self>

Create a call plan from an API request.

pub fn has_params(&self) -> bool

Check if this call has parameters.

Trait Implementations

impl Clone for CallPlan

fn clone(&self) -> CallPlan

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CallPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CallPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CallPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.