parse_param.c File Reference

#include "postgres.h"
#include <limits.h>
#include "catalog/pg_type.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_param.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"

Include dependency graph for parse_param.c:

Go to the source code of this file.

Data Structures
struct	FixedParamState
struct	VarParamState

Typedefs
typedef struct FixedParamState	FixedParamState
typedef struct VarParamState	VarParamState

Functions
static Node *	fixed_paramref_hook (ParseState *pstate, ParamRef *pref)
static Node *	variable_paramref_hook (ParseState *pstate, ParamRef *pref)
static Node *	variable_coerce_param_hook (ParseState *pstate, Param *param, Oid targetTypeId, int32 targetTypeMod, int location)
static bool	check_parameter_resolution_walker (Node *node, ParseState *pstate)
static bool	query_contains_extern_params_walker (Node *node, void *context)
void	setup_parse_fixed_parameters (ParseState *pstate, const Oid *paramTypes, int numParams)
void	setup_parse_variable_parameters (ParseState *pstate, Oid **paramTypes, int *numParams)
void	check_variable_parameters (ParseState *pstate, Query *query)
bool	query_contains_extern_params (Query *query)

Typedef Documentation

FixedParamState

typedef struct FixedParamState FixedParamState

VarParamState

typedef struct VarParamState VarParamState

Function Documentation

check_parameter_resolution_walker()

static bool check_parameter_resolution_walker ( Node *  node, ParseState *  pstate  )

static

Definition at line 287 of file parse_param.c.

{
    if (node == NULL)
        return false;
    if (IsA(node, Param))
    {
        Param      *param = (Param *) node;
 
        if (param->paramkind == PARAM_EXTERN)
        {
            VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
            int         paramno = param->paramid;
 
            if (paramno <= 0 || /* shouldn't happen, but... */
                paramno > *parstate->numParams)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_PARAMETER),
                         errmsg("there is no parameter $%d", paramno),
                         parser_errposition(pstate, param->location)));
 
            if (param->paramtype != (*parstate->paramTypes)[paramno - 1])
                ereport(ERROR,
                        (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
                         errmsg("could not determine data type of parameter $%d",
                                paramno),
                         parser_errposition(pstate, param->location)));
        }
        return false;
    }
    if (IsA(node, Query))
    {
        /* Recurse into RTE subquery or not-yet-planned sublink subquery */
        return query_tree_walker((Query *) node,
                                 check_parameter_resolution_walker,
                                 pstate, 0);
    }
    return expression_tree_walker(node, check_parameter_resolution_walker,
                                  pstate);
}

References check_parameter_resolution_walker(), ereport, errcode(), errmsg(), ERROR, expression_tree_walker, if(), IsA, Param::location, VarParamState::numParams, ParseState::p_ref_hook_state, PARAM_EXTERN, Param::paramid, Param::paramkind, Param::paramtype, VarParamState::paramTypes, parser_errposition(), and query_tree_walker.

Referenced by check_parameter_resolution_walker(), and check_variable_parameters().

check_variable_parameters()

void check_variable_parameters	(	ParseState *	pstate,
		Query *	query
	)

Definition at line 269 of file parse_param.c.

{
    VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
 
    /* If numParams is zero then no Params were generated, so no work */
    if (*parstate->numParams > 0)
        (void) query_tree_walker(query,
                                 check_parameter_resolution_walker,
                                 pstate, 0);
}

References check_parameter_resolution_walker(), if(), VarParamState::numParams, ParseState::p_ref_hook_state, and query_tree_walker.

Referenced by parse_analyze_varparams(), and transformExplainStmt().

fixed_paramref_hook()

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

static

Definition at line 100 of file parse_param.c.

{
    FixedParamState *parstate = (FixedParamState *) pstate->p_ref_hook_state;
    int         paramno = pref->number;
    Param      *param;
 
    /* Check parameter number is valid */
    if (paramno <= 0 || paramno > parstate->numParams ||
        !OidIsValid(parstate->paramTypes[paramno - 1]))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_PARAMETER),
                 errmsg("there is no parameter $%d", paramno),
                 parser_errposition(pstate, pref->location)));
 
    param = makeNode(Param);
    param->paramkind = PARAM_EXTERN;
    param->paramid = paramno;
    param->paramtype = parstate->paramTypes[paramno - 1];
    param->paramtypmod = -1;
    param->paramcollid = get_typcollation(param->paramtype);
    param->location = pref->location;
 
    return (Node *) param;
}

References ereport, errcode(), errmsg(), ERROR, get_typcollation(), if(), ParamRef::location, makeNode, ParamRef::number, FixedParamState::numParams, OidIsValid, ParseState::p_ref_hook_state, PARAM_EXTERN, FixedParamState::paramTypes, and parser_errposition().

Referenced by setup_parse_fixed_parameters().

query_contains_extern_params()

bool query_contains_extern_params

(

Query *

query

)

Definition at line 331 of file parse_param.c.

{
    return query_tree_walker(query,
                             query_contains_extern_params_walker,
                             NULL, 0);
}

References query_contains_extern_params_walker(), and query_tree_walker.

Referenced by transformCreateTableAsStmt().

query_contains_extern_params_walker()

static bool query_contains_extern_params_walker ( Node *  node, void *  context  )

static

Definition at line 339 of file parse_param.c.

{
    if (node == NULL)
        return false;
    if (IsA(node, Param))
    {
        Param      *param = (Param *) node;
 
        if (param->paramkind == PARAM_EXTERN)
            return true;
        return false;
    }
    if (IsA(node, Query))
    {
        /* Recurse into RTE subquery or not-yet-planned sublink subquery */
        return query_tree_walker((Query *) node,
                                 query_contains_extern_params_walker,
                                 context, 0);
    }
    return expression_tree_walker(node, query_contains_extern_params_walker,
                                  context);
}

References expression_tree_walker, IsA, PARAM_EXTERN, Param::paramkind, query_contains_extern_params_walker(), and query_tree_walker.

Referenced by query_contains_extern_params(), and query_contains_extern_params_walker().

setup_parse_fixed_parameters()

void setup_parse_fixed_parameters	(	ParseState *	pstate,
		const Oid *	paramTypes,
		int	numParams
	)

Definition at line 68 of file parse_param.c.

{
    FixedParamState *parstate = palloc(sizeof(FixedParamState));
 
    parstate->paramTypes = paramTypes;
    parstate->numParams = numParams;
    pstate->p_ref_hook_state = parstate;
    pstate->p_paramref_hook = fixed_paramref_hook;
    /* no need to use p_coerce_param_hook */
}

References fixed_paramref_hook(), FixedParamState::numParams, ParseState::p_paramref_hook, ParseState::p_ref_hook_state, palloc(), and FixedParamState::paramTypes.

Referenced by parse_analyze_fixedparams().

setup_parse_variable_parameters()

void setup_parse_variable_parameters	(	ParseState *	pstate,
		Oid **	paramTypes,
		int *	numParams
	)

Definition at line 84 of file parse_param.c.

{
    VarParamState *parstate = palloc(sizeof(VarParamState));
 
    parstate->paramTypes = paramTypes;
    parstate->numParams = numParams;
    pstate->p_ref_hook_state = parstate;
    pstate->p_paramref_hook = variable_paramref_hook;
    pstate->p_coerce_param_hook = variable_coerce_param_hook;
}

References VarParamState::numParams, ParseState::p_coerce_param_hook, ParseState::p_paramref_hook, ParseState::p_ref_hook_state, palloc(), VarParamState::paramTypes, variable_coerce_param_hook(), and variable_paramref_hook().

Referenced by parse_analyze_varparams(), and transformExplainStmt().

variable_coerce_param_hook()

static Node * variable_coerce_param_hook ( ParseState *  pstate, Param *  param, Oid  targetTypeId, int32  targetTypeMod, int  location  )

static

Definition at line 187 of file parse_param.c.

{
    if (param->paramkind == PARAM_EXTERN && param->paramtype == UNKNOWNOID)
    {
        /*
         * Input is a Param of previously undetermined type, and we want to
         * update our knowledge of the Param's type.
         */
        VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
        Oid        *paramTypes = *parstate->paramTypes;
        int         paramno = param->paramid;
 
        if (paramno <= 0 ||     /* shouldn't happen, but... */
            paramno > *parstate->numParams)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_PARAMETER),
                     errmsg("there is no parameter $%d", paramno),
                     parser_errposition(pstate, param->location)));
 
        if (paramTypes[paramno - 1] == UNKNOWNOID)
        {
            /* We've successfully resolved the type */
            paramTypes[paramno - 1] = targetTypeId;
        }
        else if (paramTypes[paramno - 1] == targetTypeId)
        {
            /* We previously resolved the type, and it matches */
        }
        else
        {
            /* Oops */
            ereport(ERROR,
                    (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
                     errmsg("inconsistent types deduced for parameter $%d",
                            paramno),
                     errdetail("%s versus %s",
                               format_type_be(paramTypes[paramno - 1]),
                               format_type_be(targetTypeId)),
                     parser_errposition(pstate, param->location)));
        }
 
        param->paramtype = targetTypeId;
 
        /*
         * Note: it is tempting here to set the Param's paramtypmod to
         * targetTypeMod, but that is probably unwise because we have no
         * infrastructure that enforces that the value delivered for a Param
         * will match any particular typmod.  Leaving it -1 ensures that a
         * run-time length check/coercion will occur if needed.
         */
        param->paramtypmod = -1;
 
        /*
         * This module always sets a Param's collation to be the default for
         * its datatype.  If that's not what you want, you should be using the
         * more general parser substitution hooks.
         */
        param->paramcollid = get_typcollation(param->paramtype);
 
        /* Use the leftmost of the param's and coercion's locations */
        if (location >= 0 &&
            (param->location < 0 || location < param->location))
            param->location = location;
 
        return (Node *) param;
    }
 
    /* Else signal to proceed with normal coercion */
    return NULL;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), get_typcollation(), if(), Param::location, VarParamState::numParams, ParseState::p_ref_hook_state, PARAM_EXTERN, Param::paramid, Param::paramkind, Param::paramtype, VarParamState::paramTypes, and parser_errposition().

Referenced by setup_parse_variable_parameters().

variable_paramref_hook()

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

static

Definition at line 132 of file parse_param.c.

{
    VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
    int         paramno = pref->number;
    Oid        *pptype;
    Param      *param;
 
    /* Check parameter number is in range */
    if (paramno <= 0 || paramno > MaxAllocSize / sizeof(Oid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_PARAMETER),
                 errmsg("there is no parameter $%d", paramno),
                 parser_errposition(pstate, pref->location)));
    if (paramno > *parstate->numParams)
    {
        /* Need to enlarge param array */
        if (*parstate->paramTypes)
            *parstate->paramTypes = repalloc0_array(*parstate->paramTypes, Oid,
                                                    *parstate->numParams, paramno);
        else
            *parstate->paramTypes = palloc0_array(Oid, paramno);
        *parstate->numParams = paramno;
    }
 
    /* Locate param's slot in array */
    pptype = &(*parstate->paramTypes)[paramno - 1];
 
    /* If not seen before, initialize to UNKNOWN type */
    if (*pptype == InvalidOid)
        *pptype = UNKNOWNOID;
 
    /*
     * If the argument is of type void and it's procedure call, interpret it
     * as unknown.  This allows the JDBC driver to not have to distinguish
     * function and procedure calls.  See also another component of this hack
     * in ParseFuncOrColumn().
     */
    if (*pptype == VOIDOID && pstate->p_expr_kind == EXPR_KIND_CALL_ARGUMENT)
        *pptype = UNKNOWNOID;
 
    param = makeNode(Param);
    param->paramkind = PARAM_EXTERN;
    param->paramid = paramno;
    param->paramtype = *pptype;
    param->paramtypmod = -1;
    param->paramcollid = get_typcollation(param->paramtype);
    param->location = pref->location;
 
    return (Node *) param;
}

References ereport, errcode(), errmsg(), ERROR, EXPR_KIND_CALL_ARGUMENT, get_typcollation(), if(), InvalidOid, ParamRef::location, makeNode, MaxAllocSize, ParamRef::number, VarParamState::numParams, ParseState::p_expr_kind, ParseState::p_ref_hook_state, palloc0_array, PARAM_EXTERN, VarParamState::paramTypes, parser_errposition(), and repalloc0_array.

Referenced by setup_parse_variable_parameters().