#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:

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 )

Definition at line 156 of file parse_node.c.

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

References ParseCallbackState::errcallback, error_context_stack, 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 )

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, 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
	)

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 = FLOAT8PASSBYVAL;    /* int8 and float8 alike */
                    }
                }
                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, ValUnion::bsval, BitString::bsval, cancel_parser_errposition_callback(), CStringGetDatum(), DirectFunctionCall3, elog, ERROR, ErrorSaveContext::error_occurred, FLOAT8PASSBYVAL, ValUnion::fval, Float::fval, Int32GetDatum(), Int64GetDatum(), intVal, InvalidOid, A_Const::isnull, A_Const::location, makeConst(), nodeTag, numeric_in(), ObjectIdGetDatum(), pg_strtoint64_safe(), setup_parser_errposition_callback(), strVal, A_Const::val, and val.

Referenced by transformExprRecurse().

◆ make_parsestate()

ParseState * make_parsestate ( ParseState * parentParseState )

Definition at line 39 of file parse_node.c.

{
    ParseState *pstate;
 
    pstate = palloc0(sizeof(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(), 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
	)

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(), 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_simple_rowfilter_expr_walker(), check_srf_call_placement(), 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(), ComputePartitionAttrs(), createdb(), CreateTriggerFiringOn(), defGetCopyLogVerbosityChoice(), defGetCopyOnErrorChoice(), DefineCollation(), DefineDomain(), DefineType(), DropDatabase(), errorConflictingDefElem(), errorMissingColumn(), errorMissingRTE(), EvaluateParams(), ExecReindex(), ExecVacuum(), 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(), transformJsonAggConstructor(), transformJsonArrayQueryConstructor(), transformJsonBehavior(), transformJsonFuncExpr(), transformJsonParseArg(), transformJsonParseExpr(), transformJsonReturning(), transformJsonTable(), transformJsonTableColumns(), transformJsonValueExpr(), transformLockingClause(), transformMergeSupportFunc(), transformMultiAssignRef(), transformOnConflictArbiter(), transformParamRef(), transformPartitionBound(), transformPartitionBoundValue(), transformPLAssignStmt(), 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
	)

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 ErrorContextCallback::arg, ErrorContextCallback::callback, ParseCallbackState::errcallback, error_context_stack, ParseCallbackState::location, pcb_error_callback(), ErrorContextCallback::previous, and ParseCallbackState::pstate.

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
	)

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(), format_type_be(), getSubscriptingRoutines(), idx(), A_Indices::is_slice, lfirst_node, makeNode, OidIsValid, parser_errposition(), SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, SubscriptRoutines::transform, and transformContainerType().

Referenced by transformAssignmentSubscripts(), and transformIndirection().

◆ transformContainerType()

void transformContainerType	(	Oid *	containerType,
		int32 *	containerTypmod
	)

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 getBaseTypeAndTypmod().

Referenced by transformAssignmentSubscripts(), and transformContainerSubscripts().

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

◆ CoerceParamHook

◆ ParseCallbackState

◆ ParseExprKind

◆ ParseNamespaceColumn

◆ ParseNamespaceItem

◆ ParseParamRefHook

◆ ParseState

◆ PostParseColumnRefHook

◆ PreParseColumnRefHook

Enumeration Type Documentation

◆ ParseExprKind

Function Documentation

◆ cancel_parser_errposition_callback()

◆ free_parsestate()

◆ make_const()

◆ make_parsestate()

◆ parser_errposition()

◆ setup_parser_errposition_callback()

◆ transformContainerSubscripts()

◆ transformContainerType()