parse_node.h File Reference

#include "nodes/parsenodes.h"
#include "utils/queryenvironment.h"
#include "utils/relcache.h"

Include dependency graph for parse_node.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ParseState
struct	ParseNamespaceItem
struct	ParseNamespaceColumn
struct	ParseCallbackState

Typedefs
typedef struct ParseState	ParseState
typedef struct ParseNamespaceItem	ParseNamespaceItem
typedef struct ParseNamespaceColumn	ParseNamespaceColumn
typedef enum ParseExprKind	ParseExprKind
typedef Node *(*	PreParseColumnRefHook) (ParseState *pstate, ColumnRef *cref)
typedef Node *(*	PostParseColumnRefHook) (ParseState *pstate, ColumnRef *cref, Node *var)
typedef Node *(*	ParseParamRefHook) (ParseState *pstate, ParamRef *pref)
typedef Node *(*	CoerceParamHook) (ParseState *pstate, Param *param, Oid targetTypeId, int32 targetTypeMod, int location)
typedef struct ParseCallbackState	ParseCallbackState

Enumerations
enum	ParseExprKind {   EXPR_KIND_NONE = 0 , EXPR_KIND_OTHER , EXPR_KIND_JOIN_ON , EXPR_KIND_JOIN_USING ,   EXPR_KIND_FROM_SUBSELECT , EXPR_KIND_FROM_FUNCTION , EXPR_KIND_WHERE , EXPR_KIND_HAVING ,   EXPR_KIND_FILTER , EXPR_KIND_WINDOW_PARTITION , EXPR_KIND_WINDOW_ORDER , EXPR_KIND_WINDOW_FRAME_RANGE ,   EXPR_KIND_WINDOW_FRAME_ROWS , EXPR_KIND_WINDOW_FRAME_GROUPS , EXPR_KIND_SELECT_TARGET , EXPR_KIND_INSERT_TARGET ,   EXPR_KIND_UPDATE_SOURCE , EXPR_KIND_UPDATE_TARGET , EXPR_KIND_MERGE_WHEN , EXPR_KIND_GROUP_BY ,   EXPR_KIND_ORDER_BY , EXPR_KIND_DISTINCT_ON , EXPR_KIND_LIMIT , EXPR_KIND_OFFSET ,   EXPR_KIND_RETURNING , EXPR_KIND_MERGE_RETURNING , EXPR_KIND_VALUES , EXPR_KIND_VALUES_SINGLE ,   EXPR_KIND_CHECK_CONSTRAINT , EXPR_KIND_DOMAIN_CHECK , EXPR_KIND_COLUMN_DEFAULT , EXPR_KIND_FUNCTION_DEFAULT ,   EXPR_KIND_INDEX_EXPRESSION , EXPR_KIND_INDEX_PREDICATE , EXPR_KIND_STATS_EXPRESSION , EXPR_KIND_ALTER_COL_TRANSFORM ,   EXPR_KIND_EXECUTE_PARAMETER , EXPR_KIND_TRIGGER_WHEN , EXPR_KIND_POLICY , EXPR_KIND_PARTITION_BOUND ,   EXPR_KIND_PARTITION_EXPRESSION , EXPR_KIND_CALL_ARGUMENT , EXPR_KIND_COPY_WHERE , EXPR_KIND_GENERATED_COLUMN ,   EXPR_KIND_CYCLE_MARK }

Functions
ParseState *	make_parsestate (ParseState *parentParseState)
void	free_parsestate (ParseState *pstate)
int	parser_errposition (ParseState *pstate, int location)
void	setup_parser_errposition_callback (ParseCallbackState *pcbstate, ParseState *pstate, int location)
void	cancel_parser_errposition_callback (ParseCallbackState *pcbstate)
void	transformContainerType (Oid *containerType, int32 *containerTypmod)
SubscriptingRef *	transformContainerSubscripts (ParseState *pstate, Node *containerBase, Oid containerType, int32 containerTypMod, List *indirection, bool isAssignment)
Const *	make_const (ParseState *pstate, A_Const *aconst)

Typedef Documentation

CoerceParamHook

typedef Node *(* CoerceParamHook) (ParseState *pstate, Param *param, Oid targetTypeId, int32 targetTypeMod, int location)

Definition at line 94 of file parse_node.h.

ParseCallbackState

typedef struct ParseCallbackState ParseCallbackState

ParseExprKind

typedef enum ParseExprKind ParseExprKind

ParseNamespaceColumn

typedef struct ParseNamespaceColumn ParseNamespaceColumn

Definition at line 25 of file parse_node.h.

ParseNamespaceItem

typedef struct ParseNamespaceItem ParseNamespaceItem

Definition at line 24 of file parse_node.h.

ParseParamRefHook

typedef Node *(* ParseParamRefHook) (ParseState *pstate, ParamRef *pref)

Definition at line 93 of file parse_node.h.

ParseState

typedef struct ParseState ParseState

Definition at line 23 of file parse_node.h.

PostParseColumnRefHook

typedef Node *(* PostParseColumnRefHook) (ParseState *pstate, ColumnRef *cref, Node *var)

Definition at line 92 of file parse_node.h.

PreParseColumnRefHook

typedef Node *(* PreParseColumnRefHook) (ParseState *pstate, ColumnRef *cref)

Definition at line 91 of file parse_node.h.

Enumeration Type Documentation

ParseExprKind

enum ParseExprKind

Enumerator
EXPR_KIND_NONE
EXPR_KIND_OTHER
EXPR_KIND_JOIN_ON
EXPR_KIND_JOIN_USING
EXPR_KIND_FROM_SUBSELECT
EXPR_KIND_FROM_FUNCTION
EXPR_KIND_WHERE
EXPR_KIND_HAVING
EXPR_KIND_FILTER
EXPR_KIND_WINDOW_PARTITION
EXPR_KIND_WINDOW_ORDER
EXPR_KIND_WINDOW_FRAME_RANGE
EXPR_KIND_WINDOW_FRAME_ROWS
EXPR_KIND_WINDOW_FRAME_GROUPS
EXPR_KIND_SELECT_TARGET
EXPR_KIND_INSERT_TARGET
EXPR_KIND_UPDATE_SOURCE
EXPR_KIND_UPDATE_TARGET
EXPR_KIND_MERGE_WHEN
EXPR_KIND_GROUP_BY
EXPR_KIND_ORDER_BY
EXPR_KIND_DISTINCT_ON
EXPR_KIND_LIMIT
EXPR_KIND_OFFSET
EXPR_KIND_RETURNING
EXPR_KIND_MERGE_RETURNING
EXPR_KIND_VALUES
EXPR_KIND_VALUES_SINGLE
EXPR_KIND_CHECK_CONSTRAINT
EXPR_KIND_DOMAIN_CHECK
EXPR_KIND_COLUMN_DEFAULT
EXPR_KIND_FUNCTION_DEFAULT
EXPR_KIND_INDEX_EXPRESSION
EXPR_KIND_INDEX_PREDICATE
EXPR_KIND_STATS_EXPRESSION
EXPR_KIND_ALTER_COL_TRANSFORM
EXPR_KIND_EXECUTE_PARAMETER
EXPR_KIND_TRIGGER_WHEN
EXPR_KIND_POLICY
EXPR_KIND_PARTITION_BOUND
EXPR_KIND_PARTITION_EXPRESSION
EXPR_KIND_CALL_ARGUMENT
EXPR_KIND_COPY_WHERE
EXPR_KIND_GENERATED_COLUMN
EXPR_KIND_CYCLE_MARK

Definition at line 38 of file parse_node.h.

{
    EXPR_KIND_NONE = 0,         /* "not in an expression" */
    EXPR_KIND_OTHER,            /* reserved for extensions */
    EXPR_KIND_JOIN_ON,          /* JOIN ON */
    EXPR_KIND_JOIN_USING,       /* JOIN USING */
    EXPR_KIND_FROM_SUBSELECT,   /* sub-SELECT in FROM clause */
    EXPR_KIND_FROM_FUNCTION,    /* function in FROM clause */
    EXPR_KIND_WHERE,            /* WHERE */
    EXPR_KIND_HAVING,           /* HAVING */
    EXPR_KIND_FILTER,           /* FILTER */
    EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */
    EXPR_KIND_WINDOW_ORDER,     /* window definition ORDER BY */
    EXPR_KIND_WINDOW_FRAME_RANGE,   /* window frame clause with RANGE */
    EXPR_KIND_WINDOW_FRAME_ROWS,    /* window frame clause with ROWS */
    EXPR_KIND_WINDOW_FRAME_GROUPS,  /* window frame clause with GROUPS */
    EXPR_KIND_SELECT_TARGET,    /* SELECT target list item */
    EXPR_KIND_INSERT_TARGET,    /* INSERT target list item */
    EXPR_KIND_UPDATE_SOURCE,    /* UPDATE assignment source item */
    EXPR_KIND_UPDATE_TARGET,    /* UPDATE assignment target item */
    EXPR_KIND_MERGE_WHEN,       /* MERGE WHEN [NOT] MATCHED condition */
    EXPR_KIND_GROUP_BY,         /* GROUP BY */
    EXPR_KIND_ORDER_BY,         /* ORDER BY */
    EXPR_KIND_DISTINCT_ON,      /* DISTINCT ON */
    EXPR_KIND_LIMIT,            /* LIMIT */
    EXPR_KIND_OFFSET,           /* OFFSET */
    EXPR_KIND_RETURNING,        /* RETURNING in INSERT/UPDATE/DELETE */
    EXPR_KIND_MERGE_RETURNING,  /* RETURNING in MERGE */
    EXPR_KIND_VALUES,           /* VALUES */
    EXPR_KIND_VALUES_SINGLE,    /* single-row VALUES (in INSERT only) */
    EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */
    EXPR_KIND_DOMAIN_CHECK,     /* CHECK constraint for a domain */
    EXPR_KIND_COLUMN_DEFAULT,   /* default value for a table column */
    EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */
    EXPR_KIND_INDEX_EXPRESSION, /* index expression */
    EXPR_KIND_INDEX_PREDICATE,  /* index predicate */
    EXPR_KIND_STATS_EXPRESSION, /* extended statistics expression */
    EXPR_KIND_ALTER_COL_TRANSFORM,  /* transform expr in ALTER COLUMN TYPE */
    EXPR_KIND_EXECUTE_PARAMETER,    /* parameter value in EXECUTE */
    EXPR_KIND_TRIGGER_WHEN,     /* WHEN condition in CREATE TRIGGER */
    EXPR_KIND_POLICY,           /* USING or WITH CHECK expr in policy */
    EXPR_KIND_PARTITION_BOUND,  /* partition bound expression */
    EXPR_KIND_PARTITION_EXPRESSION, /* PARTITION BY expression */
    EXPR_KIND_CALL_ARGUMENT,    /* procedure argument in CALL */
    EXPR_KIND_COPY_WHERE,       /* WHERE condition in COPY FROM */
    EXPR_KIND_GENERATED_COLUMN, /* generation expression for a column */
    EXPR_KIND_CYCLE_MARK,       /* cycle mark value */
} ParseExprKind;

Function Documentation

cancel_parser_errposition_callback()

void cancel_parser_errposition_callback ( ParseCallbackState *  pcbstate )

extern

Definition at line 156 of file parse_node.c.

{
    /* Pop the error context stack */
    error_context_stack = pcbstate->errcallback.previous;
}

References error_context_stack, fb(), and ErrorContextCallback::previous.

Referenced by addTargetToGroupList(), addTargetToSortList(), coerce_type(), LookupCollation(), LookupTypeNameExtended(), make_const(), make_oper_cache_key(), ParseFuncOrColumn(), parserOpenTable(), transformCreateStmt(), transformSetOperationTree(), transformTableLikeClause(), and typenameTypeMod().

free_parsestate()

void free_parsestate ( ParseState *  pstate )

extern

Definition at line 72 of file parse_node.c.

{
    /*
     * Check that we did not produce too many resnos; at the very least we
     * cannot allow more than 2^16, since that would exceed the range of a
     * AttrNumber. It seems safest to use MaxTupleAttributeNumber.
     */
    if (pstate->p_next_resno - 1 > MaxTupleAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("target lists can have at most %d entries",
                        MaxTupleAttributeNumber)));
 
    if (pstate->p_target_relation != NULL)
        table_close(pstate->p_target_relation, NoLock);
 
    pfree(pstate);
}

References ereport, errcode(), errmsg(), ERROR, fb(), MaxTupleAttributeNumber, NoLock, ParseState::p_next_resno, ParseState::p_target_relation, pfree(), and table_close().

Referenced by AlterPolicy(), CreatePolicy(), CreateTriggerFiringOn(), inline_function(), interpret_AS_clause(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), parse_sub_analyze(), standard_ProcessUtility(), transformIndexStmt(), transformInsertStmt(), transformJsonArrayQueryConstructor(), TransformPubWhereClauses(), transformRuleStmt(), and transformStatsStmt().

make_const()

Const * make_const ( ParseState *  pstate, A_Const *  aconst  )

extern

Definition at line 347 of file parse_node.c.

{
    Const      *con;
    Datum       val;
    Oid         typeid;
    int         typelen;
    bool        typebyval;
    ParseCallbackState pcbstate;
 
    if (aconst->isnull)
    {
        /* return a null const */
        con = makeConst(UNKNOWNOID,
                        -1,
                        InvalidOid,
                        -2,
                        (Datum) 0,
                        true,
                        false);
        con->location = aconst->location;
        return con;
    }
 
    switch (nodeTag(&aconst->val))
    {
        case T_Integer:
            val = Int32GetDatum(intVal(&aconst->val));
 
            typeid = INT4OID;
            typelen = sizeof(int32);
            typebyval = true;
            break;
 
        case T_Float:
            {
                /* could be an oversize integer as well as a float ... */
 
                ErrorSaveContext escontext = {T_ErrorSaveContext};
                int64       val64;
 
                val64 = pg_strtoint64_safe(aconst->val.fval.fval, (Node *) &escontext);
                if (!escontext.error_occurred)
                {
                    /*
                     * It might actually fit in int32. Probably only INT_MIN
                     * can occur, but we'll code the test generally just to be
                     * sure.
                     */
                    int32       val32 = (int32) val64;
 
                    if (val64 == (int64) val32)
                    {
                        val = Int32GetDatum(val32);
 
                        typeid = INT4OID;
                        typelen = sizeof(int32);
                        typebyval = true;
                    }
                    else
                    {
                        val = Int64GetDatum(val64);
 
                        typeid = INT8OID;
                        typelen = sizeof(int64);
                        typebyval = true;
                    }
                }
                else
                {
                    /* arrange to report location if numeric_in() fails */
                    setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
                    val = DirectFunctionCall3(numeric_in,
                                              CStringGetDatum(aconst->val.fval.fval),
                                              ObjectIdGetDatum(InvalidOid),
                                              Int32GetDatum(-1));
                    cancel_parser_errposition_callback(&pcbstate);
 
                    typeid = NUMERICOID;
                    typelen = -1;   /* variable len */
                    typebyval = false;
                }
                break;
            }
 
        case T_Boolean:
            val = BoolGetDatum(boolVal(&aconst->val));
 
            typeid = BOOLOID;
            typelen = 1;
            typebyval = true;
            break;
 
        case T_String:
 
            /*
             * We assume here that UNKNOWN's internal representation is the
             * same as CSTRING
             */
            val = CStringGetDatum(strVal(&aconst->val));
 
            typeid = UNKNOWNOID;    /* will be coerced later */
            typelen = -2;       /* cstring-style varwidth type */
            typebyval = false;
            break;
 
        case T_BitString:
            /* arrange to report location if bit_in() fails */
            setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
            val = DirectFunctionCall3(bit_in,
                                      CStringGetDatum(aconst->val.bsval.bsval),
                                      ObjectIdGetDatum(InvalidOid),
                                      Int32GetDatum(-1));
            cancel_parser_errposition_callback(&pcbstate);
            typeid = BITOID;
            typelen = -1;
            typebyval = false;
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(&aconst->val));
            return NULL;        /* keep compiler quiet */
    }
 
    con = makeConst(typeid,
                    -1,         /* typmod -1 is OK for all cases */
                    InvalidOid, /* all cases are uncollatable types */
                    typelen,
                    val,
                    false,
                    typebyval);
    con->location = aconst->location;
 
    return con;
}

References bit_in(), BoolGetDatum(), boolVal, cancel_parser_errposition_callback(), CStringGetDatum(), DirectFunctionCall3, elog, ERROR, ErrorSaveContext::error_occurred, fb(), Int32GetDatum(), Int64GetDatum(), intVal, InvalidOid, makeConst(), nodeTag, numeric_in(), ObjectIdGetDatum(), pg_strtoint64_safe(), setup_parser_errposition_callback(), strVal, and val.

Referenced by transformExprRecurse().

make_parsestate()

ParseState * make_parsestate ( ParseState *  parentParseState )

extern

Definition at line 39 of file parse_node.c.

{
    ParseState *pstate;
 
    pstate = palloc0_object(ParseState);
 
    pstate->parentParseState = parentParseState;
 
    /* Fill in fields that don't start at null/false/zero */
    pstate->p_next_resno = 1;
    pstate->p_resolve_unknowns = true;
 
    if (parentParseState)
    {
        pstate->p_sourcetext = parentParseState->p_sourcetext;
        /* all hooks are copied from parent */
        pstate->p_pre_columnref_hook = parentParseState->p_pre_columnref_hook;
        pstate->p_post_columnref_hook = parentParseState->p_post_columnref_hook;
        pstate->p_paramref_hook = parentParseState->p_paramref_hook;
        pstate->p_coerce_param_hook = parentParseState->p_coerce_param_hook;
        pstate->p_ref_hook_state = parentParseState->p_ref_hook_state;
        /* query environment stays in context for the whole parse analysis */
        pstate->p_queryEnv = parentParseState->p_queryEnv;
    }
 
    return pstate;
}

References ParseState::p_coerce_param_hook, ParseState::p_next_resno, ParseState::p_paramref_hook, ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseState::p_queryEnv, ParseState::p_ref_hook_state, ParseState::p_resolve_unknowns, ParseState::p_sourcetext, palloc0_object, and ParseState::parentParseState.

Referenced by AddRelationNewConstraints(), AlterDomainDefault(), AlterPolicy(), ATExecAttachPartition(), ATPrepAlterColumnType(), convert_ANY_sublink_to_join(), copy_table(), CreatePolicy(), CreateTriggerFiringOn(), DefineRelation(), domainAddCheckConstraint(), ExplainExecuteQuery(), inline_function(), interpret_AS_clause(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), parse_sub_analyze(), rewriteTargetView(), standard_ProcessUtility(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformAlterTableStmt(), transformCreateStmt(), transformIndexStmt(), transformInsertStmt(), transformJsonArrayQueryConstructor(), transformPartitionSpec(), TransformPubWhereClauses(), transformRuleStmt(), and transformStatsStmt().

parser_errposition()

int parser_errposition ( ParseState *  pstate, int  location  )

extern

Definition at line 106 of file parse_node.c.

{
    int         pos;
 
    /* No-op if location was not provided */
    if (location < 0)
        return 0;
    /* Can't do anything if source text is not available */
    if (pstate == NULL || pstate->p_sourcetext == NULL)
        return 0;
    /* Convert offset to character number */
    pos = pg_mbstrlen_with_len(pstate->p_sourcetext, location) + 1;
    /* And pass it to the ereport mechanism */
    return errposition(pos);
}

References errposition(), fb(), ParseState::p_sourcetext, and pg_mbstrlen_with_len().

Referenced by addRangeTableEntryForCTE(), addRangeTableEntryForFunction(), addRangeTableEntryForTableFunc(), AlterDatabase(), analyzeCTE(), analyzeCTETargetList(), array_subscript_transform(), assign_collations_walker(), assign_hypothetical_collations(), ATPrepAlterColumnType(), check_agg_arguments(), check_agg_arguments_walker(), check_agglevels_and_constraints(), check_lateral_ref_ok(), check_nested_generated_walker(), check_new_partition_bound(), check_parameter_resolution_walker(), check_partition_bounds_for_split_list(), check_partition_bounds_for_split_range(), check_partitions_not_overlap_list(), check_simple_rowfilter_expr_walker(), check_srf_call_placement(), check_two_partitions_bounds_range(), check_virtual_generated_security_walker(), CheckDuplicateColumnOrPathNames(), checkExprIsVarFree(), checkInsertTargets(), checkJsonOutputFormat(), checkTargetlistEntrySQL92(), checkWellFormedRecursion(), checkWellFormedRecursionWalker(), cluster(), coerce_to_boolean(), coerce_to_common_type(), coerce_to_specific_type_typmod(), colNameToVar(), compatible_oper(), compute_common_attribute(), compute_function_attributes(), ComputeIndexAttrs(), ComputePartitionAttrs(), createdb(), CreateTriggerFiringOn(), defGetCopyLogVerbosityChoice(), defGetCopyOnErrorChoice(), DefineCollation(), DefineDomain(), DefineType(), DropDatabase(), errorConflictingDefElem(), errorMissingColumn(), errorMissingRTE(), EvaluateParams(), ExecCheckpoint(), ExecReindex(), ExecVacuum(), ExecWaitStmt(), ExpandAllTables(), ExpandColumnRefStar(), finalize_grouping_exprs_walker(), findTargetlistEntrySQL92(), fixed_paramref_hook(), generateSerialExtraStmts(), GetColumnDefCollation(), GrantRole(), hstore_subscript_transform(), init_params(), interpret_function_parameter_list(), jsonb_subscript_transform(), LookupOperName(), LookupTypeNameExtended(), LookupTypeNameOid(), make_distinct_op(), make_op(), make_row_comparison_op(), make_row_distinct_op(), make_scalar_array_op(), merge_collation_state(), op_error(), parseCheckAggregates(), ParseExplainOptionList(), ParseFuncOrColumn(), parser_coercion_errposition(), pcb_error_callback(), plpgsql_post_column_ref(), ProcessCopyOptions(), resolve_column_ref(), resolve_unique_index_expr(), scanNameSpaceForRefname(), scanNameSpaceForRelid(), scanNSItemForColumn(), scanRTEForColumn(), select_common_collation(), select_common_type(), substitute_grouped_columns_mutator(), TopologicalSort(), transformAExprNullIf(), transformAggregateCall(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), transformCaseExpr(), transformCoalesceExpr(), transformCollateClause(), transformColumnDefinition(), transformColumnRef(), transformColumnType(), transformConstraintAttrs(), transformContainerSubscripts(), transformDistinctClause(), transformDistinctOnClause(), transformExprRecurse(), transformFrameOffset(), transformFromClauseItem(), transformGroupingFunc(), transformGroupingSet(), transformIndexConstraint(), transformIndirection(), transformInsertRow(), transformInsertStmt(), transformJsonAggConstructor(), transformJsonArrayQueryConstructor(), transformJsonBehavior(), transformJsonFuncExpr(), transformJsonParseArg(), transformJsonParseExpr(), transformJsonReturning(), transformJsonTable(), transformJsonTableColumns(), transformJsonValueExpr(), transformLockingClause(), transformMergeSupportFunc(), transformMultiAssignRef(), transformOnConflictArbiter(), transformParamRef(), transformPartitionBound(), transformPartitionBoundValue(), transformPartitionCmdForMerge(), transformPartitionCmdForSplit(), transformPLAssignStmtTarget(), transformRangeFunction(), transformRangeTableFunc(), transformRangeTableSample(), transformReturningClause(), transformRowExpr(), transformSelectStmt(), transformSetOperationStmt(), transformSetOperationTree(), transformSubLink(), transformTableConstraint(), transformUpdateTargetList(), transformValuesClause(), transformWindowDefinitions(), transformWindowFuncCall(), transformWithClause(), transformXmlExpr(), transformXmlSerialize(), typenameType(), typenameTypeMod(), unknown_attribute(), validateInfiniteBounds(), variable_coerce_param_hook(), and variable_paramref_hook().

setup_parser_errposition_callback()

void setup_parser_errposition_callback ( ParseCallbackState *  pcbstate, ParseState *  pstate, int  location  )

extern

Definition at line 140 of file parse_node.c.

{
    /* Setup error traceback support for ereport() */
    pcbstate->pstate = pstate;
    pcbstate->location = location;
    pcbstate->errcallback.callback = pcb_error_callback;
    pcbstate->errcallback.arg = pcbstate;
    pcbstate->errcallback.previous = error_context_stack;
    error_context_stack = &pcbstate->errcallback;
}

References error_context_stack, fb(), and pcb_error_callback().

Referenced by addTargetToGroupList(), addTargetToSortList(), coerce_type(), LookupCollation(), LookupTypeNameExtended(), make_const(), make_oper_cache_key(), ParseFuncOrColumn(), parserOpenTable(), transformCreateStmt(), transformSetOperationTree(), transformTableLikeClause(), and typenameTypeMod().

transformContainerSubscripts()

SubscriptingRef * transformContainerSubscripts ( ParseState *  pstate, Node *  containerBase, Oid  containerType, int32  containerTypMod, List *  indirection, bool  isAssignment  )

extern

Definition at line 243 of file parse_node.c.

{
    SubscriptingRef *sbsref;
    const SubscriptRoutines *sbsroutines;
    Oid         elementType;
    bool        isSlice = false;
    ListCell   *idx;
 
    /*
     * Determine the actual container type, smashing any domain.  In the
     * assignment case the caller already did this, since it also needs to
     * know the actual container type.
     */
    if (!isAssignment)
        transformContainerType(&containerType, &containerTypMod);
 
    /*
     * Verify that the container type is subscriptable, and get its support
     * functions and typelem.
     */
    sbsroutines = getSubscriptingRoutines(containerType, &elementType);
    if (!sbsroutines)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot subscript type %s because it does not support subscripting",
                        format_type_be(containerType)),
                 parser_errposition(pstate, exprLocation(containerBase))));
 
    /*
     * Detect whether any of the indirection items are slice specifiers.
     *
     * A list containing only simple subscripts refers to a single container
     * element.  If any of the items are slice specifiers (lower:upper), then
     * the subscript expression means a container slice operation.
     */
    foreach(idx, indirection)
    {
        A_Indices  *ai = lfirst_node(A_Indices, idx);
 
        if (ai->is_slice)
        {
            isSlice = true;
            break;
        }
    }
 
    /*
     * Ready to build the SubscriptingRef node.
     */
    sbsref = makeNode(SubscriptingRef);
 
    sbsref->refcontainertype = containerType;
    sbsref->refelemtype = elementType;
    /* refrestype is to be set by container-specific logic */
    sbsref->reftypmod = containerTypMod;
    /* refcollid will be set by parse_collate.c */
    /* refupperindexpr, reflowerindexpr are to be set by container logic */
    sbsref->refexpr = (Expr *) containerBase;
    sbsref->refassgnexpr = NULL;    /* caller will fill if it's an assignment */
 
    /*
     * Call the container-type-specific logic to transform the subscripts and
     * determine the subscripting result type.
     */
    sbsroutines->transform(sbsref, indirection, pstate,
                           isSlice, isAssignment);
 
    /*
     * Verify we got a valid type (this defends, for example, against someone
     * using array_subscript_handler as typsubscript without setting typelem).
     */
    if (!OidIsValid(sbsref->refrestype))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot subscript type %s because it does not support subscripting",
                        format_type_be(containerType))));
 
    return sbsref;
}

References ereport, errcode(), errmsg(), ERROR, exprLocation(), fb(), format_type_be(), getSubscriptingRoutines(), idx(), lfirst_node, makeNode, OidIsValid, parser_errposition(), SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, and transformContainerType().

Referenced by transformAssignmentSubscripts(), and transformIndirection().

transformContainerType()

void transformContainerType ( Oid *  containerType, int32 *  containerTypmod  )

extern

Definition at line 189 of file parse_node.c.

{
    /*
     * If the input is a domain, smash to base type, and extract the actual
     * typmod to be applied to the base type. Subscripting a domain is an
     * operation that necessarily works on the base container type, not the
     * domain itself. (Note that we provide no method whereby the creator of a
     * domain over a container type could hide its ability to be subscripted.)
     */
    *containerType = getBaseTypeAndTypmod(*containerType, containerTypmod);
 
    /*
     * We treat int2vector and oidvector as though they were domains over
     * int2[] and oid[].  This is needed because array slicing could create an
     * array that doesn't satisfy the dimensionality constraints of the
     * xxxvector type; so we want the result of a slice operation to be
     * considered to be of the more general type.
     */
    if (*containerType == INT2VECTOROID)
        *containerType = INT2ARRAYOID;
    else if (*containerType == OIDVECTOROID)
        *containerType = OIDARRAYOID;
}

References fb(), and getBaseTypeAndTypmod().

Referenced by transformAssignmentSubscripts(), and transformContainerSubscripts().