#include "postgres.h"
#include "access/xact.h"
#include "fmgr.h"
#include "mb/stringinfo_mb.h"
#include "nodes/params.h"
#include "parser/parse_node.h"
#include "storage/shmem.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"

Include dependency graph for params.c:

Functions
static void	paramlist_parser_setup (ParseState pstate, void arg)

static Node *	paramlist_param_ref (ParseState pstate, ParamRef pref)

ParamListInfo	makeParamList (int numParams)

ParamListInfo	copyParamList (ParamListInfo from)

Size	EstimateParamListSpace (ParamListInfo paramLI)

void	SerializeParamList (ParamListInfo paramLI, char **start_address)

ParamListInfo	RestoreParamList (char **start_address)

char *	BuildParamLogString (ParamListInfo params, char **knownTextValues, int maxlen)

void	ParamsErrorCallback (void *arg)

Function Documentation

◆ BuildParamLogString()

char * BuildParamLogString	(	ParamListInfo	params,
		char **	knownTextValues,
		int	maxlen
	)

Definition at line 333 of file params.c.

{
    MemoryContext tmpCxt,
                oldCxt;
    StringInfoData buf;
 
    /*
     * NB: think not of returning params->paramValuesStr!  It may have been
     * generated with a different maxlen, and so be unsuitable.  Besides that,
     * this is the function used to create that string.
     */
 
    /*
     * No work if the param fetch hook is in use.  Also, it's not possible to
     * do this in an aborted transaction.  (It might be possible to improve on
     * this last point when some knownTextValues exist, but it seems tricky.)
     */
    if (params->paramFetch != NULL ||
        IsAbortedTransactionBlockState())
        return NULL;
 
    /* Initialize the output stringinfo, in caller's memory context */
    initStringInfo(&buf);
 
    /* Use a temporary context to call output functions, just in case */
    tmpCxt = AllocSetContextCreate(CurrentMemoryContext,
                                   "BuildParamLogString",
                                   ALLOCSET_DEFAULT_SIZES);
    oldCxt = MemoryContextSwitchTo(tmpCxt);
 
    for (int paramno = 0; paramno < params->numParams; paramno++)
    {
        ParamExternData *param = &params->params[paramno];
 
        appendStringInfo(&buf,
                         "%s$%d = ",
                         paramno > 0 ? ", " : "",
                         paramno + 1);
 
        if (param->isnull || !OidIsValid(param->ptype))
            appendStringInfoString(&buf, "NULL");
        else
        {
            if (knownTextValues != NULL && knownTextValues[paramno] != NULL)
                appendStringInfoStringQuoted(&buf, knownTextValues[paramno],
                                             maxlen);
            else
            {
                Oid         typoutput;
                bool        typisvarlena;
                char       *pstring;
 
                getTypeOutputInfo(param->ptype, &typoutput, &typisvarlena);
                pstring = OidOutputFunctionCall(typoutput, param->value);
                appendStringInfoStringQuoted(&buf, pstring, maxlen);
            }
        }
    }
 
    MemoryContextSwitchTo(oldCxt);
    MemoryContextDelete(tmpCxt);
 
    return buf.data;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, appendStringInfo(), appendStringInfoString(), appendStringInfoStringQuoted(), buf, CurrentMemoryContext, getTypeOutputInfo(), initStringInfo(), IsAbortedTransactionBlockState(), ParamExternData::isnull, MemoryContextDelete(), MemoryContextSwitchTo(), ParamListInfoData::numParams, OidIsValid, OidOutputFunctionCall(), ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::ptype, and ParamExternData::value.

Referenced by errdetail_params(), exec_bind_message(), and ExplainQueryParameters().

◆ copyParamList()

ParamListInfo copyParamList ( ParamListInfo from )

Definition at line 78 of file params.c.

{
    ParamListInfo retval;
 
    if (from == NULL || from->numParams <= 0)
        return NULL;
 
    retval = makeParamList(from->numParams);
 
    for (int i = 0; i < from->numParams; i++)
    {
        ParamExternData *oprm;
        ParamExternData *nprm = &retval->params[i];
        ParamExternData prmdata;
        int16       typLen;
        bool        typByVal;
 
        /* give hook a chance in case parameter is dynamic */
        if (from->paramFetch != NULL)
            oprm = from->paramFetch(from, i + 1, false, &prmdata);
        else
            oprm = &from->params[i];
 
        /* flat-copy the parameter info */
        *nprm = *oprm;
 
        /* need datumCopy in case it's a pass-by-reference datatype */
        if (nprm->isnull || !OidIsValid(nprm->ptype))
            continue;
        get_typlenbyval(nprm->ptype, &typLen, &typByVal);
        nprm->value = datumCopy(nprm->value, typByVal, typLen);
    }
 
    return retval;
}

References datumCopy(), get_typlenbyval(), i, ParamExternData::isnull, makeParamList(), ParamListInfoData::numParams, OidIsValid, ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::ptype, and ParamExternData::value.

Referenced by PerformCursorOpen(), and SPI_cursor_open_internal().

◆ EstimateParamListSpace()

Size EstimateParamListSpace ( ParamListInfo paramLI )

Definition at line 167 of file params.c.

{
    Size        sz = sizeof(int);
 
    if (paramLI == NULL || paramLI->numParams <= 0)
        return sz;
 
    for (int i = 0; i < paramLI->numParams; i++)
    {
        ParamExternData *prm;
        ParamExternData prmdata;
        Oid         typeOid;
        int16       typLen;
        bool        typByVal;
 
        /* give hook a chance in case parameter is dynamic */
        if (paramLI->paramFetch != NULL)
            prm = paramLI->paramFetch(paramLI, i + 1, false, &prmdata);
        else
            prm = &paramLI->params[i];
 
        typeOid = prm->ptype;
 
        sz = add_size(sz, sizeof(Oid)); /* space for type OID */
        sz = add_size(sz, sizeof(uint16));  /* space for pflags */
 
        /* space for datum/isnull */
        if (OidIsValid(typeOid))
            get_typlenbyval(typeOid, &typLen, &typByVal);
        else
        {
            /* If no type OID, assume by-value, like copyParamList does. */
            typLen = sizeof(Datum);
            typByVal = true;
        }
        sz = add_size(sz,
                      datumEstimateSpace(prm->value, prm->isnull, typByVal, typLen));
    }
 
    return sz;
}

References add_size(), datumEstimateSpace(), get_typlenbyval(), i, ParamExternData::isnull, ParamListInfoData::numParams, OidIsValid, ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::ptype, and ParamExternData::value.

Referenced by ExecInitParallelPlan().

◆ makeParamList()

ParamListInfo makeParamList ( int numParams )

Definition at line 44 of file params.c.

{
    ParamListInfo retval;
    Size        size;
 
    size = offsetof(ParamListInfoData, params) +
        numParams * sizeof(ParamExternData);
 
    retval = (ParamListInfo) palloc(size);
    retval->paramFetch = NULL;
    retval->paramFetchArg = NULL;
    retval->paramCompile = NULL;
    retval->paramCompileArg = NULL;
    retval->parserSetup = paramlist_parser_setup;
    retval->parserSetupArg = retval;
    retval->paramValuesStr = NULL;
    retval->numParams = numParams;
 
    return retval;
}

References ParamListInfoData::numParams, palloc(), ParamListInfoData::paramCompile, ParamListInfoData::paramCompileArg, ParamListInfoData::paramFetch, ParamListInfoData::paramFetchArg, paramlist_parser_setup(), ParamListInfoData::paramValuesStr, ParamListInfoData::parserSetup, and ParamListInfoData::parserSetupArg.

Referenced by _SPI_convert_params(), copyParamList(), EvaluateParams(), exec_bind_message(), exec_eval_using_params(), plpgsql_estate_setup(), postquel_sub_params(), and RestoreParamList().

◆ paramlist_param_ref()

static Node * paramlist_param_ref	(	ParseState *	pstate,
		ParamRef *	pref
	)

static

Definition at line 131 of file params.c.

{
    ParamListInfo paramLI = (ParamListInfo) pstate->p_ref_hook_state;
    int         paramno = pref->number;
    ParamExternData *prm;
    ParamExternData prmdata;
    Param      *param;
 
    /* check parameter number is valid */
    if (paramno <= 0 || paramno > paramLI->numParams)
        return NULL;
 
    /* give hook a chance in case parameter is dynamic */
    if (paramLI->paramFetch != NULL)
        prm = paramLI->paramFetch(paramLI, paramno, false, &prmdata);
    else
        prm = &paramLI->params[paramno - 1];
 
    if (!OidIsValid(prm->ptype))
        return NULL;
 
    param = makeNode(Param);
    param->paramkind = PARAM_EXTERN;
    param->paramid = paramno;
    param->paramtype = prm->ptype;
    param->paramtypmod = -1;
    param->paramcollid = get_typcollation(param->paramtype);
    param->location = pref->location;
 
    return (Node *) param;
}

References get_typcollation(), if(), ParamRef::location, makeNode, ParamRef::number, ParamListInfoData::numParams, OidIsValid, ParseState::p_ref_hook_state, PARAM_EXTERN, ParamListInfoData::paramFetch, and ParamListInfoData::params.

Referenced by paramlist_parser_setup().

◆ paramlist_parser_setup()

static void paramlist_parser_setup	(	ParseState *	pstate,
		void *	arg
	)

static

Definition at line 120 of file params.c.

{
    pstate->p_paramref_hook = paramlist_param_ref;
    /* no need to use p_coerce_param_hook */
    pstate->p_ref_hook_state = arg;
}

References arg, ParseState::p_paramref_hook, ParseState::p_ref_hook_state, and paramlist_param_ref().

Referenced by makeParamList().

◆ ParamsErrorCallback()

void ParamsErrorCallback ( void * arg )

Definition at line 405 of file params.c.

{
    ParamsErrorCbData *data = (ParamsErrorCbData *) arg;
 
    if (data == NULL ||
        data->params == NULL ||
        data->params->paramValuesStr == NULL)
        return;
 
    if (data->portalName && data->portalName[0] != '\0')
        errcontext("portal \"%s\" with parameters: %s",
                   data->portalName, data->params->paramValuesStr);
    else
        errcontext("unnamed portal with parameters: %s",
                   data->params->paramValuesStr);
}

References arg, data, and errcontext.

Referenced by exec_bind_message(), and exec_execute_message().

◆ RestoreParamList()

ParamListInfo RestoreParamList ( char ** start_address )

Definition at line 290 of file params.c.

{
    ParamListInfo paramLI;
    int         nparams;
 
    memcpy(&nparams, *start_address, sizeof(int));
    *start_address += sizeof(int);
 
    paramLI = makeParamList(nparams);
 
    for (int i = 0; i < nparams; i++)
    {
        ParamExternData *prm = &paramLI->params[i];
 
        /* Read type OID. */
        memcpy(&prm->ptype, *start_address, sizeof(Oid));
        *start_address += sizeof(Oid);
 
        /* Read flags. */
        memcpy(&prm->pflags, *start_address, sizeof(uint16));
        *start_address += sizeof(uint16);
 
        /* Read datum/isnull. */
        prm->value = datumRestore(start_address, &prm->isnull);
    }
 
    return paramLI;
}

References datumRestore(), i, ParamExternData::isnull, makeParamList(), ParamListInfoData::params, ParamExternData::pflags, ParamExternData::ptype, and ParamExternData::value.

Referenced by ExecParallelGetQueryDesc().

◆ SerializeParamList()

void SerializeParamList	(	ParamListInfo	paramLI,
		char **	start_address
	)

Definition at line 228 of file params.c.

{
    int         nparams;
 
    /* Write number of parameters. */
    if (paramLI == NULL || paramLI->numParams <= 0)
        nparams = 0;
    else
        nparams = paramLI->numParams;
    memcpy(*start_address, &nparams, sizeof(int));
    *start_address += sizeof(int);
 
    /* Write each parameter in turn. */
    for (int i = 0; i < nparams; i++)
    {
        ParamExternData *prm;
        ParamExternData prmdata;
        Oid         typeOid;
        int16       typLen;
        bool        typByVal;
 
        /* give hook a chance in case parameter is dynamic */
        if (paramLI->paramFetch != NULL)
            prm = paramLI->paramFetch(paramLI, i + 1, false, &prmdata);
        else
            prm = &paramLI->params[i];
 
        typeOid = prm->ptype;
 
        /* Write type OID. */
        memcpy(*start_address, &typeOid, sizeof(Oid));
        *start_address += sizeof(Oid);
 
        /* Write flags. */
        memcpy(*start_address, &prm->pflags, sizeof(uint16));
        *start_address += sizeof(uint16);
 
        /* Write datum/isnull. */
        if (OidIsValid(typeOid))
            get_typlenbyval(typeOid, &typLen, &typByVal);
        else
        {
            /* If no type OID, assume by-value, like copyParamList does. */
            typLen = sizeof(Datum);
            typByVal = true;
        }
        datumSerialize(prm->value, prm->isnull, typByVal, typLen,
                       start_address);
    }
}

References datumSerialize(), get_typlenbyval(), i, ParamExternData::isnull, ParamListInfoData::numParams, OidIsValid, ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::pflags, ParamExternData::ptype, and ParamExternData::value.