#include "postgres.h"
#include <ctype.h>
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/heap.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_enr.h"
#include "parser/parse_relation.h"
#include "parser/parse_type.h"
#include "parser/parsetree.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
#include "utils/varlena.h"

Include dependency graph for parse_relation.c:

Data Structures
struct	FuzzyAttrMatchState

Macros
#define	MAX_FUZZY_DISTANCE 3

Functions
static ParseNamespaceItem *	scanNameSpaceForRefname (ParseState pstate, const char refname, int location)

static ParseNamespaceItem *	scanNameSpaceForRelid (ParseState *pstate, Oid relid, int location)

static void	check_lateral_ref_ok (ParseState pstate, ParseNamespaceItem nsitem, int location)

static int	scanRTEForColumn (ParseState pstate, RangeTblEntry rte, Alias eref, const char colname, int location, int fuzzy_rte_penalty, FuzzyAttrMatchState *fuzzystate)

static void	markRTEForSelectPriv (ParseState *pstate, int rtindex, AttrNumber col)

static void	expandRelation (Oid relid, Alias eref, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List colnames, List *colvars)

static void	expandTupleDesc (TupleDesc tupdesc, Alias eref, int count, int offset, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List colnames, List *colvars)

static int	specialAttNum (const char *attname)

static bool	rte_visible_if_lateral (ParseState pstate, RangeTblEntry rte)

static bool	rte_visible_if_qualified (ParseState pstate, RangeTblEntry rte)

static bool	isQueryUsingTempRelation_walker (Node node, void context)

ParseNamespaceItem *	refnameNamespaceItem (ParseState pstate, const char schemaname, const char refname, int location, int sublevels_up)

CommonTableExpr *	scanNameSpaceForCTE (ParseState pstate, const char refname, Index *ctelevelsup)

static bool	isFutureCTE (ParseState pstate, const char refname)

bool	scanNameSpaceForENR (ParseState pstate, const char refname)

static RangeTblEntry *	searchRangeTableForRel (ParseState pstate, RangeVar relation)

void	checkNameSpaceConflicts (ParseState pstate, List namespace1, List *namespace2)

ParseNamespaceItem *	GetNSItemByRangeTablePosn (ParseState *pstate, int varno, int sublevels_up)

RangeTblEntry *	GetRTEByRangeTablePosn (ParseState *pstate, int varno, int sublevels_up)

CommonTableExpr *	GetCTEForRTE (ParseState pstate, RangeTblEntry rte, int rtelevelsup)

static void	updateFuzzyAttrMatchState (int fuzzy_rte_penalty, FuzzyAttrMatchState fuzzystate, RangeTblEntry rte, const char actual, const char match, int attnum)

Node *	scanNSItemForColumn (ParseState pstate, ParseNamespaceItem nsitem, int sublevels_up, const char *colname, int location)

Node *	colNameToVar (ParseState pstate, const char colname, bool localonly, int location)

static FuzzyAttrMatchState *	searchRangeTableForCol (ParseState pstate, const char alias, const char *colname, int location)

void	markNullableIfNeeded (ParseState pstate, Var var)

void	markVarForSelectPriv (ParseState pstate, Var var)

static void	buildRelationAliases (TupleDesc tupdesc, Alias alias, Alias eref)

static char *	chooseScalarFunctionAlias (Node funcexpr, char funcname, Alias *alias, int nfuncs)

static ParseNamespaceItem *	buildNSItemFromTupleDesc (RangeTblEntry rte, Index rtindex, RTEPermissionInfo perminfo, TupleDesc tupdesc)

static ParseNamespaceItem *	buildNSItemFromLists (RangeTblEntry rte, Index rtindex, List coltypes, List coltypmods, List colcollations)

Relation	parserOpenTable (ParseState pstate, const RangeVar relation, int lockmode)

ParseNamespaceItem *	addRangeTableEntry (ParseState pstate, RangeVar relation, Alias *alias, bool inh, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForRelation (ParseState pstate, Relation rel, int lockmode, Alias alias, bool inh, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForSubquery (ParseState pstate, Query subquery, Alias *alias, bool lateral, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForFunction (ParseState pstate, List funcnames, List funcexprs, List coldeflists, RangeFunction *rangefunc, bool lateral, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForTableFunc (ParseState pstate, TableFunc tf, Alias *alias, bool lateral, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForValues (ParseState pstate, List exprs, List coltypes, List coltypmods, List colcollations, Alias alias, bool lateral, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForJoin (ParseState pstate, List colnames, ParseNamespaceColumn nscolumns, JoinType jointype, int nummergedcols, List aliasvars, List leftcols, List rightcols, Alias join_using_alias, Alias alias, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForCTE (ParseState pstate, CommonTableExpr cte, Index levelsup, RangeVar *rv, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForENR (ParseState pstate, RangeVar rv, bool inFromCl)

ParseNamespaceItem *	addRangeTableEntryForGroup (ParseState pstate, List groupClauses)

bool	isLockedRefname (ParseState pstate, const char refname)

void	addNSItemToQuery (ParseState pstate, ParseNamespaceItem nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)

void	expandRTE (RangeTblEntry rte, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List colnames, List *colvars)

List *	expandNSItemVars (ParseState pstate, ParseNamespaceItem nsitem, int sublevels_up, int location, List **colnames)

List *	expandNSItemAttrs (ParseState pstate, ParseNamespaceItem nsitem, int sublevels_up, bool require_col_privs, int location)

char *	get_rte_attribute_name (RangeTblEntry *rte, AttrNumber attnum)

bool	get_rte_attribute_is_dropped (RangeTblEntry *rte, AttrNumber attnum)

TargetEntry *	get_tle_by_resno (List *tlist, AttrNumber resno)

RowMarkClause *	get_parse_rowmark (Query *qry, Index rtindex)

int	attnameAttNum (Relation rd, const char *attname, bool sysColOK)

const NameData *	attnumAttName (Relation rd, int attid)

Oid	attnumTypeId (Relation rd, int attid)

Oid	attnumCollationId (Relation rd, int attid)

void	errorMissingRTE (ParseState pstate, RangeVar relation)

void	errorMissingColumn (ParseState pstate, const char relname, const char *colname, int location)

static ParseNamespaceItem *	findNSItemForRTE (ParseState pstate, RangeTblEntry rte)

bool	isQueryUsingTempRelation (Query *query)

RTEPermissionInfo *	addRTEPermissionInfo (List *rteperminfos, RangeTblEntry rte)

RTEPermissionInfo *	getRTEPermissionInfo (List rteperminfos, RangeTblEntry rte)

Macro Definition Documentation

◆ MAX_FUZZY_DISTANCE

#define MAX_FUZZY_DISTANCE 3

Definition at line 75 of file parse_relation.c.

Function Documentation

◆ addNSItemToQuery()

void addNSItemToQuery	(	ParseState *	pstate,
		ParseNamespaceItem *	nsitem,
		bool	addToJoinList,
		bool	addToRelNameSpace,
		bool	addToVarNameSpace
	)

Definition at line 2710 of file parse_relation.c.

{
    if (addToJoinList)
    {
        RangeTblRef *rtr = makeNode(RangeTblRef);
 
        rtr->rtindex = nsitem->p_rtindex;
        pstate->p_joinlist = lappend(pstate->p_joinlist, rtr);
    }
    if (addToRelNameSpace || addToVarNameSpace)
    {
        /* Set the new nsitem's visibility flags correctly */
        nsitem->p_rel_visible = addToRelNameSpace;
        nsitem->p_cols_visible = addToVarNameSpace;
        nsitem->p_lateral_only = false;
        nsitem->p_lateral_ok = true;
        pstate->p_namespace = lappend(pstate->p_namespace, nsitem);
    }
}

References lappend(), makeNode, ParseNamespaceItem::p_cols_visible, ParseState::p_joinlist, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseState::p_namespace, ParseNamespaceItem::p_rel_visible, ParseNamespaceItem::p_rtindex, and RangeTblRef::rtindex.

Referenced by addNSItemForReturning(), AddRelationNewConstraints(), AlterPolicy(), CreatePolicy(), CreateTriggerFiringOn(), DefineRelation(), DoCopy(), setTargetTable(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformAlterTableStmt(), transformIndexStmt(), transformInsertStmt(), transformMergeStmt(), transformOnConflictClause(), transformPartitionSpec(), TransformPubWhereClauses(), transformRuleStmt(), transformSetOperationStmt(), transformStatsStmt(), and transformValuesClause().

◆ addRangeTableEntry()

ParseNamespaceItem * addRangeTableEntry	(	ParseState *	pstate,
		RangeVar *	relation,
		Alias *	alias,
		bool	inh,
		bool	inFromCl
	)

Definition at line 1487 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    RTEPermissionInfo *perminfo;
    char       *refname = alias ? alias->aliasname : relation->relname;
    LOCKMODE    lockmode;
    Relation    rel;
    ParseNamespaceItem *nsitem;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_RELATION;
    rte->alias = alias;
 
    /*
     * Identify the type of lock we'll need on this relation.  It's not the
     * query's target table (that case is handled elsewhere), so we need
     * either RowShareLock if it's locked by FOR UPDATE/SHARE, or plain
     * AccessShareLock otherwise.
     */
    lockmode = isLockedRefname(pstate, refname) ? RowShareLock : AccessShareLock;
 
    /*
     * Get the rel's OID.  This access also ensures that we have an up-to-date
     * relcache entry for the rel.  Since this is typically the first access
     * to a rel in a statement, we must open the rel with the proper lockmode.
     */
    rel = parserOpenTable(pstate, relation, lockmode);
    rte->relid = RelationGetRelid(rel);
    rte->inh = inh;
    rte->relkind = rel->rd_rel->relkind;
    rte->rellockmode = lockmode;
 
    /*
     * Build the list of effective column names using user-supplied aliases
     * and/or actual column names.
     */
    rte->eref = makeAlias(refname, NIL);
    buildRelationAliases(rel->rd_att, alias, rte->eref);
 
    /*
     * Set flags and initialize access permissions.
     *
     * The initial default on access checks is always check-for-READ-access,
     * which is the right thing for all except target tables.
     */
    rte->lateral = false;
    rte->inFromCl = inFromCl;
 
    perminfo = addRTEPermissionInfo(&pstate->p_rteperminfos, rte);
    perminfo->requiredPerms = ACL_SELECT;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    nsitem = buildNSItemFromTupleDesc(rte, list_length(pstate->p_rtable),
                                      perminfo, rel->rd_att);
 
    /*
     * Drop the rel refcount, but keep the access lock till end of transaction
     * so that the table can't be deleted or have its schema modified
     * underneath us.
     */
    table_close(rel, NoLock);
 
    return nsitem;
}

References AccessShareLock, ACL_SELECT, addRTEPermissionInfo(), Alias::aliasname, Assert(), buildNSItemFromTupleDesc(), buildRelationAliases(), RangeTblEntry::inh, isLockedRefname(), lappend(), list_length(), makeAlias(), makeNode, NIL, NoLock, ParseState::p_rtable, ParseState::p_rteperminfos, parserOpenTable(), RelationData::rd_att, RelationData::rd_rel, RelationGetRelid, RangeVar::relname, RTEPermissionInfo::requiredPerms, RowShareLock, RTE_RELATION, RangeTblEntry::rtekind, and table_close().

Referenced by transformTableEntry().

◆ addRangeTableEntryForCTE()

ParseNamespaceItem * addRangeTableEntryForCTE	(	ParseState *	pstate,
		CommonTableExpr *	cte,
		Index	levelsup,
		RangeVar *	rv,
		bool	inFromCl
	)

Definition at line 2332 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *alias = rv->alias;
    char       *refname = alias ? alias->aliasname : cte->ctename;
    Alias      *eref;
    int         numaliases;
    int         varattno;
    ListCell   *lc;
    int         n_dontexpand_columns = 0;
    ParseNamespaceItem *psi;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_CTE;
    rte->ctename = cte->ctename;
    rte->ctelevelsup = levelsup;
 
    /* Self-reference if and only if CTE's parse analysis isn't completed */
    rte->self_reference = !IsA(cte->ctequery, Query);
    Assert(cte->cterecursive || !rte->self_reference);
    /* Bump the CTE's refcount if this isn't a self-reference */
    if (!rte->self_reference)
        cte->cterefcount++;
 
    /*
     * We throw error if the CTE is INSERT/UPDATE/DELETE/MERGE without
     * RETURNING.  This won't get checked in case of a self-reference, but
     * that's OK because data-modifying CTEs aren't allowed to be recursive
     * anyhow.
     */
    if (IsA(cte->ctequery, Query))
    {
        Query      *ctequery = (Query *) cte->ctequery;
 
        if (ctequery->commandType != CMD_SELECT &&
            ctequery->returningList == NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("WITH query \"%s\" does not have a RETURNING clause",
                            cte->ctename),
                     parser_errposition(pstate, rv->location)));
    }
 
    rte->coltypes = list_copy(cte->ctecoltypes);
    rte->coltypmods = list_copy(cte->ctecoltypmods);
    rte->colcollations = list_copy(cte->ctecolcollations);
 
    rte->alias = alias;
    if (alias)
        eref = copyObject(alias);
    else
        eref = makeAlias(refname, NIL);
    numaliases = list_length(eref->colnames);
 
    /* fill in any unspecified alias columns */
    varattno = 0;
    foreach(lc, cte->ctecolnames)
    {
        varattno++;
        if (varattno > numaliases)
            eref->colnames = lappend(eref->colnames, lfirst(lc));
    }
    if (varattno < numaliases)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("table \"%s\" has %d columns available but %d columns specified",
                        refname, varattno, numaliases)));
 
    rte->eref = eref;
 
    if (cte->search_clause)
    {
        rte->eref->colnames = lappend(rte->eref->colnames, makeString(cte->search_clause->search_seq_column));
        if (cte->search_clause->search_breadth_first)
            rte->coltypes = lappend_oid(rte->coltypes, RECORDOID);
        else
            rte->coltypes = lappend_oid(rte->coltypes, RECORDARRAYOID);
        rte->coltypmods = lappend_int(rte->coltypmods, -1);
        rte->colcollations = lappend_oid(rte->colcollations, InvalidOid);
 
        n_dontexpand_columns += 1;
    }
 
    if (cte->cycle_clause)
    {
        rte->eref->colnames = lappend(rte->eref->colnames, makeString(cte->cycle_clause->cycle_mark_column));
        rte->coltypes = lappend_oid(rte->coltypes, cte->cycle_clause->cycle_mark_type);
        rte->coltypmods = lappend_int(rte->coltypmods, cte->cycle_clause->cycle_mark_typmod);
        rte->colcollations = lappend_oid(rte->colcollations, cte->cycle_clause->cycle_mark_collation);
 
        rte->eref->colnames = lappend(rte->eref->colnames, makeString(cte->cycle_clause->cycle_path_column));
        rte->coltypes = lappend_oid(rte->coltypes, RECORDARRAYOID);
        rte->coltypmods = lappend_int(rte->coltypmods, -1);
        rte->colcollations = lappend_oid(rte->colcollations, InvalidOid);
 
        n_dontexpand_columns += 2;
    }
 
    /*
     * Set flags and access permissions.
     *
     * Subqueries are never checked for access rights, so no need to perform
     * addRTEPermissionInfo().
     */
    rte->lateral = false;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    psi = buildNSItemFromLists(rte, list_length(pstate->p_rtable),
                               rte->coltypes, rte->coltypmods,
                               rte->colcollations);
 
    /*
     * The columns added by search and cycle clauses are not included in star
     * expansion in queries contained in the CTE.
     */
    if (rte->ctelevelsup > 0)
        for (int i = 0; i < n_dontexpand_columns; i++)
            psi->p_nscolumns[list_length(psi->p_names->colnames) - 1 - i].p_dontexpand = true;
 
    return psi;
}

References RangeVar::alias, Alias::aliasname, Assert(), buildNSItemFromLists(), CMD_SELECT, Alias::colnames, Query::commandType, copyObject, RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, CommonTableExpr::ctename, CommonTableExpr::ctequery, ereport, errcode(), errmsg(), ERROR, i, if(), InvalidOid, IsA, lappend(), lappend_int(), lappend_oid(), lfirst, list_copy(), list_length(), RangeVar::location, makeAlias(), makeNode, makeString(), NIL, ParseNamespaceColumn::p_dontexpand, ParseNamespaceItem::p_names, ParseNamespaceItem::p_nscolumns, ParseState::p_rtable, parser_errposition(), Query::returningList, RTE_CTE, and RangeTblEntry::rtekind.

Referenced by getNSItemForSpecialRelationTypes().

◆ addRangeTableEntryForENR()

ParseNamespaceItem * addRangeTableEntryForENR	(	ParseState *	pstate,
		RangeVar *	rv,
		bool	inFromCl
	)

Definition at line 2484 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *alias = rv->alias;
    char       *refname = alias ? alias->aliasname : rv->relname;
    EphemeralNamedRelationMetadata enrmd;
    TupleDesc   tupdesc;
    int         attno;
 
    Assert(pstate != NULL);
    enrmd = get_visible_ENR(pstate, rv->relname);
    Assert(enrmd != NULL);
 
    switch (enrmd->enrtype)
    {
        case ENR_NAMED_TUPLESTORE:
            rte->rtekind = RTE_NAMEDTUPLESTORE;
            break;
 
        default:
            elog(ERROR, "unexpected enrtype: %d", enrmd->enrtype);
            return NULL;        /* for fussy compilers */
    }
 
    /*
     * Record dependency on a relation.  This allows plans to be invalidated
     * if they access transition tables linked to a table that is altered.
     */
    rte->relid = enrmd->reliddesc;
 
    /*
     * Build the list of effective column names using user-supplied aliases
     * and/or actual column names.
     */
    tupdesc = ENRMetadataGetTupDesc(enrmd);
    rte->eref = makeAlias(refname, NIL);
    buildRelationAliases(tupdesc, alias, rte->eref);
 
    /* Record additional data for ENR, including column type info */
    rte->enrname = enrmd->name;
    rte->enrtuples = enrmd->enrtuples;
    rte->coltypes = NIL;
    rte->coltypmods = NIL;
    rte->colcollations = NIL;
    for (attno = 1; attno <= tupdesc->natts; ++attno)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, attno - 1);
 
        if (att->attisdropped)
        {
            /* Record zeroes for a dropped column */
            rte->coltypes = lappend_oid(rte->coltypes, InvalidOid);
            rte->coltypmods = lappend_int(rte->coltypmods, 0);
            rte->colcollations = lappend_oid(rte->colcollations, InvalidOid);
        }
        else
        {
            /* Let's just make sure we can tell this isn't dropped */
            if (att->atttypid == InvalidOid)
                elog(ERROR, "atttypid is invalid for non-dropped column in \"%s\"",
                     rv->relname);
            rte->coltypes = lappend_oid(rte->coltypes, att->atttypid);
            rte->coltypmods = lappend_int(rte->coltypmods, att->atttypmod);
            rte->colcollations = lappend_oid(rte->colcollations,
                                             att->attcollation);
        }
    }
 
    /*
     * Set flags and access permissions.
     *
     * ENRs are never checked for access rights, so no need to perform
     * addRTEPermissionInfo().
     */
    rte->lateral = false;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    return buildNSItemFromTupleDesc(rte, list_length(pstate->p_rtable), NULL,
                                    tupdesc);
}

References RangeVar::alias, Alias::aliasname, Assert(), buildNSItemFromTupleDesc(), buildRelationAliases(), elog, ENR_NAMED_TUPLESTORE, ENRMetadataGetTupDesc(), RangeTblEntry::enrname, EphemeralNamedRelationMetadataData::enrtuples, EphemeralNamedRelationMetadataData::enrtype, ERROR, get_visible_ENR(), InvalidOid, lappend(), lappend_int(), lappend_oid(), list_length(), makeAlias(), makeNode, EphemeralNamedRelationMetadataData::name, TupleDescData::natts, NIL, ParseState::p_rtable, EphemeralNamedRelationMetadataData::reliddesc, RangeVar::relname, RTE_NAMEDTUPLESTORE, RangeTblEntry::rtekind, and TupleDescAttr().

Referenced by getNSItemForSpecialRelationTypes().

◆ addRangeTableEntryForFunction()

ParseNamespaceItem * addRangeTableEntryForFunction	(	ParseState *	pstate,
		List *	funcnames,
		List *	funcexprs,
		List *	coldeflists,
		RangeFunction *	rangefunc,
		bool	lateral,
		bool	inFromCl
	)

Definition at line 1751 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *alias = rangefunc->alias;
    Alias      *eref;
    char       *aliasname;
    int         nfuncs = list_length(funcexprs);
    TupleDesc  *functupdescs;
    TupleDesc   tupdesc;
    ListCell   *lc1,
               *lc2,
               *lc3;
    int         i;
    int         j;
    int         funcno;
    int         natts,
                totalatts;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_FUNCTION;
    rte->relid = InvalidOid;
    rte->subquery = NULL;
    rte->functions = NIL;       /* we'll fill this list below */
    rte->funcordinality = rangefunc->ordinality;
    rte->alias = alias;
 
    /*
     * Choose the RTE alias name.  We default to using the first function's
     * name even when there's more than one; which is maybe arguable but beats
     * using something constant like "table".
     */
    if (alias)
        aliasname = alias->aliasname;
    else
        aliasname = linitial(funcnames);
 
    eref = makeAlias(aliasname, NIL);
    rte->eref = eref;
 
    /* Process each function ... */
    functupdescs = (TupleDesc *) palloc(nfuncs * sizeof(TupleDesc));
 
    totalatts = 0;
    funcno = 0;
    forthree(lc1, funcexprs, lc2, funcnames, lc3, coldeflists)
    {
        Node       *funcexpr = (Node *) lfirst(lc1);
        char       *funcname = (char *) lfirst(lc2);
        List       *coldeflist = (List *) lfirst(lc3);
        RangeTblFunction *rtfunc = makeNode(RangeTblFunction);
        TypeFuncClass functypclass;
        Oid         funcrettype;
 
        /* Initialize RangeTblFunction node */
        rtfunc->funcexpr = funcexpr;
        rtfunc->funccolnames = NIL;
        rtfunc->funccoltypes = NIL;
        rtfunc->funccoltypmods = NIL;
        rtfunc->funccolcollations = NIL;
        rtfunc->funcparams = NULL;  /* not set until planning */
 
        /*
         * Now determine if the function returns a simple or composite type.
         */
        functypclass = get_expr_result_type(funcexpr,
                                            &funcrettype,
                                            &tupdesc);
 
        /*
         * A coldeflist is required if the function returns RECORD and hasn't
         * got a predetermined record type, and is prohibited otherwise.  This
         * can be a bit confusing, so we expend some effort on delivering a
         * relevant error message.
         */
        if (coldeflist != NIL)
        {
            switch (functypclass)
            {
                case TYPEFUNC_RECORD:
                    /* ok */
                    break;
                case TYPEFUNC_COMPOSITE:
                case TYPEFUNC_COMPOSITE_DOMAIN:
 
                    /*
                     * If the function's raw result type is RECORD, we must
                     * have resolved it using its OUT parameters.  Otherwise,
                     * it must have a named composite type.
                     */
                    if (exprType(funcexpr) == RECORDOID)
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("a column definition list is redundant for a function with OUT parameters"),
                                 parser_errposition(pstate,
                                                    exprLocation((Node *) coldeflist))));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("a column definition list is redundant for a function returning a named composite type"),
                                 parser_errposition(pstate,
                                                    exprLocation((Node *) coldeflist))));
                    break;
                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("a column definition list is only allowed for functions returning \"record\""),
                             parser_errposition(pstate,
                                                exprLocation((Node *) coldeflist))));
                    break;
            }
        }
        else
        {
            if (functypclass == TYPEFUNC_RECORD)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("a column definition list is required for functions returning \"record\""),
                         parser_errposition(pstate, exprLocation(funcexpr))));
        }
 
        if (functypclass == TYPEFUNC_COMPOSITE ||
            functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
        {
            /* Composite data type, e.g. a table's row type */
            Assert(tupdesc);
        }
        else if (functypclass == TYPEFUNC_SCALAR)
        {
            /* Base data type, i.e. scalar */
            tupdesc = CreateTemplateTupleDesc(1);
            TupleDescInitEntry(tupdesc,
                               (AttrNumber) 1,
                               chooseScalarFunctionAlias(funcexpr, funcname,
                                                         alias, nfuncs),
                               funcrettype,
                               exprTypmod(funcexpr),
                               0);
            TupleDescInitEntryCollation(tupdesc,
                                        (AttrNumber) 1,
                                        exprCollation(funcexpr));
        }
        else if (functypclass == TYPEFUNC_RECORD)
        {
            ListCell   *col;
 
            /*
             * Use the column definition list to construct a tupdesc and fill
             * in the RangeTblFunction's lists.  Limit number of columns to
             * MaxHeapAttributeNumber, because CheckAttributeNamesTypes will.
             */
            if (list_length(coldeflist) > MaxHeapAttributeNumber)
                ereport(ERROR,
                        (errcode(ERRCODE_TOO_MANY_COLUMNS),
                         errmsg("column definition lists can have at most %d entries",
                                MaxHeapAttributeNumber),
                         parser_errposition(pstate,
                                            exprLocation((Node *) coldeflist))));
            tupdesc = CreateTemplateTupleDesc(list_length(coldeflist));
            i = 1;
            foreach(col, coldeflist)
            {
                ColumnDef  *n = (ColumnDef *) lfirst(col);
                char       *attrname;
                Oid         attrtype;
                int32       attrtypmod;
                Oid         attrcollation;
 
                attrname = n->colname;
                if (n->typeName->setof)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("column \"%s\" cannot be declared SETOF",
                                    attrname),
                             parser_errposition(pstate, n->location)));
                typenameTypeIdAndMod(pstate, n->typeName,
                                     &attrtype, &attrtypmod);
                attrcollation = GetColumnDefCollation(pstate, n, attrtype);
                TupleDescInitEntry(tupdesc,
                                   (AttrNumber) i,
                                   attrname,
                                   attrtype,
                                   attrtypmod,
                                   0);
                TupleDescInitEntryCollation(tupdesc,
                                            (AttrNumber) i,
                                            attrcollation);
                rtfunc->funccolnames = lappend(rtfunc->funccolnames,
                                               makeString(pstrdup(attrname)));
                rtfunc->funccoltypes = lappend_oid(rtfunc->funccoltypes,
                                                   attrtype);
                rtfunc->funccoltypmods = lappend_int(rtfunc->funccoltypmods,
                                                     attrtypmod);
                rtfunc->funccolcollations = lappend_oid(rtfunc->funccolcollations,
                                                        attrcollation);
 
                i++;
            }
 
            /*
             * Ensure that the coldeflist defines a legal set of names (no
             * duplicates, but we needn't worry about system column names) and
             * datatypes.  Although we mostly can't allow pseudo-types, it
             * seems safe to allow RECORD and RECORD[], since values within
             * those type classes are self-identifying at runtime, and the
             * coldeflist doesn't represent anything that will be visible to
             * other sessions.
             */
            CheckAttributeNamesTypes(tupdesc, RELKIND_COMPOSITE_TYPE,
                                     CHKATYPE_ANYRECORD);
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("function \"%s\" in FROM has unsupported return type %s",
                            funcname, format_type_be(funcrettype)),
                     parser_errposition(pstate, exprLocation(funcexpr))));
 
        /* Finish off the RangeTblFunction and add it to the RTE's list */
        rtfunc->funccolcount = tupdesc->natts;
        rte->functions = lappend(rte->functions, rtfunc);
 
        /* Save the tupdesc for use below */
        functupdescs[funcno] = tupdesc;
        totalatts += tupdesc->natts;
        funcno++;
    }
 
    /*
     * If there's more than one function, or we want an ordinality column, we
     * have to produce a merged tupdesc.
     */
    if (nfuncs > 1 || rangefunc->ordinality)
    {
        if (rangefunc->ordinality)
            totalatts++;
 
        /* Disallow more columns than will fit in a tuple */
        if (totalatts > MaxTupleAttributeNumber)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_COLUMNS),
                     errmsg("functions in FROM can return at most %d columns",
                            MaxTupleAttributeNumber),
                     parser_errposition(pstate,
                                        exprLocation((Node *) funcexprs))));
 
        /* Merge the tuple descs of each function into a composite one */
        tupdesc = CreateTemplateTupleDesc(totalatts);
        natts = 0;
        for (i = 0; i < nfuncs; i++)
        {
            for (j = 1; j <= functupdescs[i]->natts; j++)
                TupleDescCopyEntry(tupdesc, ++natts, functupdescs[i], j);
        }
 
        /* Add the ordinality column if needed */
        if (rangefunc->ordinality)
        {
            TupleDescInitEntry(tupdesc,
                               (AttrNumber) ++natts,
                               "ordinality",
                               INT8OID,
                               -1,
                               0);
            /* no need to set collation */
        }
 
        Assert(natts == totalatts);
    }
    else
    {
        /* We can just use the single function's tupdesc as-is */
        tupdesc = functupdescs[0];
    }
 
    /* Use the tupdesc while assigning column aliases for the RTE */
    buildRelationAliases(tupdesc, alias, eref);
 
    /*
     * Set flags and access permissions.
     *
     * Functions are never checked for access rights (at least, not by
     * ExecCheckPermissions()), so no need to perform addRTEPermissionInfo().
     */
    rte->lateral = lateral;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    return buildNSItemFromTupleDesc(rte, list_length(pstate->p_rtable), NULL,
                                    tupdesc);
}

References RangeFunction::alias, Alias::aliasname, Assert(), buildNSItemFromTupleDesc(), buildRelationAliases(), CheckAttributeNamesTypes(), CHKATYPE_ANYRECORD, chooseScalarFunctionAlias(), ColumnDef::colname, CreateTemplateTupleDesc(), ereport, errcode(), errmsg(), ERROR, exprCollation(), exprLocation(), exprType(), exprTypmod(), format_type_be(), forthree, RangeTblFunction::funcexpr, funcname, RangeTblEntry::funcordinality, RangeTblEntry::functions, get_expr_result_type(), GetColumnDefCollation(), i, InvalidOid, j, lappend(), lappend_int(), lappend_oid(), lfirst, linitial, list_length(), ColumnDef::location, makeAlias(), makeNode, makeString(), MaxHeapAttributeNumber, MaxTupleAttributeNumber, TupleDescData::natts, NIL, RangeFunction::ordinality, ParseState::p_rtable, palloc(), parser_errposition(), pstrdup(), RTE_FUNCTION, RangeTblEntry::rtekind, TypeName::setof, RangeTblEntry::subquery, TupleDescCopyEntry(), TupleDescInitEntry(), TupleDescInitEntryCollation(), TYPEFUNC_COMPOSITE, TYPEFUNC_COMPOSITE_DOMAIN, TYPEFUNC_RECORD, TYPEFUNC_SCALAR, ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by transformRangeFunction().

◆ addRangeTableEntryForGroup()

ParseNamespaceItem * addRangeTableEntryForGroup	(	ParseState *	pstate,
		List *	groupClauses
	)

Definition at line 2583 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *eref;
    List       *groupexprs;
    List       *coltypes,
               *coltypmods,
               *colcollations;
    ListCell   *lc;
    ParseNamespaceItem *nsitem;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_GROUP;
    rte->alias = NULL;
 
    eref = makeAlias("*GROUP*", NIL);
 
    /* fill in any unspecified alias columns, and extract column type info */
    groupexprs = NIL;
    coltypes = coltypmods = colcollations = NIL;
    foreach(lc, groupClauses)
    {
        TargetEntry *te = (TargetEntry *) lfirst(lc);
        char       *colname = te->resname ? pstrdup(te->resname) : "?column?";
 
        eref->colnames = lappend(eref->colnames, makeString(colname));
 
        groupexprs = lappend(groupexprs, copyObject(te->expr));
 
        coltypes = lappend_oid(coltypes,
                               exprType((Node *) te->expr));
        coltypmods = lappend_int(coltypmods,
                                 exprTypmod((Node *) te->expr));
        colcollations = lappend_oid(colcollations,
                                    exprCollation((Node *) te->expr));
    }
 
    rte->eref = eref;
    rte->groupexprs = groupexprs;
 
    /*
     * Set flags.
     *
     * The grouping step is never checked for access rights, so no need to
     * perform addRTEPermissionInfo().
     */
    rte->lateral = false;
    rte->inFromCl = false;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    nsitem = buildNSItemFromLists(rte, list_length(pstate->p_rtable),
                                  coltypes, coltypmods, colcollations);
 
    return nsitem;
}

References Assert(), buildNSItemFromLists(), Alias::colnames, copyObject, TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), lappend(), lappend_int(), lappend_oid(), lfirst, list_length(), makeAlias(), makeNode, makeString(), NIL, ParseState::p_rtable, pstrdup(), RTE_GROUP, and RangeTblEntry::rtekind.

Referenced by parseCheckAggregates().

◆ addRangeTableEntryForJoin()

ParseNamespaceItem * addRangeTableEntryForJoin	(	ParseState *	pstate,
		List *	colnames,
		ParseNamespaceColumn *	nscolumns,
		JoinType	jointype,
		int	nummergedcols,
		List *	aliasvars,
		List *	leftcols,
		List *	rightcols,
		Alias *	join_using_alias,
		Alias *	alias,
		bool	inFromCl
	)

Definition at line 2233 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *eref;
    int         numaliases;
    ParseNamespaceItem *nsitem;
 
    Assert(pstate != NULL);
 
    /*
     * Fail if join has too many columns --- we must be able to reference any
     * of the columns with an AttrNumber.
     */
    if (list_length(aliasvars) > MaxAttrNumber)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("joins can have at most %d columns",
                        MaxAttrNumber)));
 
    rte->rtekind = RTE_JOIN;
    rte->relid = InvalidOid;
    rte->subquery = NULL;
    rte->jointype = jointype;
    rte->joinmergedcols = nummergedcols;
    rte->joinaliasvars = aliasvars;
    rte->joinleftcols = leftcols;
    rte->joinrightcols = rightcols;
    rte->join_using_alias = join_using_alias;
    rte->alias = alias;
 
    eref = alias ? copyObject(alias) : makeAlias("unnamed_join", NIL);
    numaliases = list_length(eref->colnames);
 
    /* fill in any unspecified alias columns */
    if (numaliases < list_length(colnames))
        eref->colnames = list_concat(eref->colnames,
                                     list_copy_tail(colnames, numaliases));
 
    if (numaliases > list_length(colnames))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("join expression \"%s\" has %d columns available but %d columns specified",
                        eref->aliasname, list_length(colnames), numaliases)));
 
    rte->eref = eref;
 
    /*
     * Set flags and access permissions.
     *
     * Joins are never checked for access rights, so no need to perform
     * addRTEPermissionInfo().
     */
    rte->lateral = false;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem));
    nsitem->p_names = rte->eref;
    nsitem->p_rte = rte;
    nsitem->p_perminfo = NULL;
    nsitem->p_rtindex = list_length(pstate->p_rtable);
    nsitem->p_nscolumns = nscolumns;
    /* set default visibility flags; might get changed later */
    nsitem->p_rel_visible = true;
    nsitem->p_cols_visible = true;
    nsitem->p_lateral_only = false;
    nsitem->p_lateral_ok = true;
    nsitem->p_returning_type = VAR_RETURNING_DEFAULT;
 
    return nsitem;
}

Referenced by transformFromClauseItem(), and transformSetOperationStmt().

◆ addRangeTableEntryForRelation()

ParseNamespaceItem * addRangeTableEntryForRelation	(	ParseState *	pstate,
		Relation	rel,
		int	lockmode,
		Alias *	alias,
		bool	inh,
		bool	inFromCl
	)

Definition at line 1584 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    RTEPermissionInfo *perminfo;
    char       *refname = alias ? alias->aliasname : RelationGetRelationName(rel);
 
    Assert(pstate != NULL);
 
    Assert(lockmode == AccessShareLock ||
           lockmode == RowShareLock ||
           lockmode == RowExclusiveLock);
    Assert(CheckRelationLockedByMe(rel, lockmode, true));
 
    rte->rtekind = RTE_RELATION;
    rte->alias = alias;
    rte->relid = RelationGetRelid(rel);
    rte->inh = inh;
    rte->relkind = rel->rd_rel->relkind;
    rte->rellockmode = lockmode;
 
    /*
     * Build the list of effective column names using user-supplied aliases
     * and/or actual column names.
     */
    rte->eref = makeAlias(refname, NIL);
    buildRelationAliases(rel->rd_att, alias, rte->eref);
 
    /*
     * Set flags and initialize access permissions.
     *
     * The initial default on access checks is always check-for-READ-access,
     * which is the right thing for all except target tables.
     */
    rte->lateral = false;
    rte->inFromCl = inFromCl;
 
    perminfo = addRTEPermissionInfo(&pstate->p_rteperminfos, rte);
    perminfo->requiredPerms = ACL_SELECT;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    return buildNSItemFromTupleDesc(rte, list_length(pstate->p_rtable),
                                    perminfo, rel->rd_att);
}

References AccessShareLock, ACL_SELECT, addRTEPermissionInfo(), Alias::aliasname, Assert(), buildNSItemFromTupleDesc(), buildRelationAliases(), CheckRelationLockedByMe(), RangeTblEntry::inh, lappend(), list_length(), makeAlias(), makeNode, NIL, ParseState::p_rtable, ParseState::p_rteperminfos, RelationData::rd_att, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RTEPermissionInfo::requiredPerms, RowExclusiveLock, RowShareLock, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by AddRelationNewConstraints(), AlterPolicy(), copy_table(), CreatePolicy(), CreateTriggerFiringOn(), DefineRelation(), DoCopy(), rewriteTargetView(), setTargetTable(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformAlterTableStmt(), transformIndexStmt(), transformOnConflictClause(), transformPartitionSpec(), TransformPubWhereClauses(), transformRuleStmt(), and transformStatsStmt().

◆ addRangeTableEntryForSubquery()

ParseNamespaceItem * addRangeTableEntryForSubquery	(	ParseState *	pstate,
		Query *	subquery,
		Alias *	alias,
		bool	lateral,
		bool	inFromCl
	)

Definition at line 1655 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    Alias      *eref;
    int         numaliases;
    List       *coltypes,
               *coltypmods,
               *colcollations;
    int         varattno;
    ListCell   *tlistitem;
    ParseNamespaceItem *nsitem;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_SUBQUERY;
    rte->subquery = subquery;
    rte->alias = alias;
 
    eref = alias ? copyObject(alias) : makeAlias("unnamed_subquery", NIL);
    numaliases = list_length(eref->colnames);
 
    /* fill in any unspecified alias columns, and extract column type info */
    coltypes = coltypmods = colcollations = NIL;
    varattno = 0;
    foreach(tlistitem, subquery->targetList)
    {
        TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
 
        if (te->resjunk)
            continue;
        varattno++;
        Assert(varattno == te->resno);
        if (varattno > numaliases)
        {
            char       *attrname;
 
            attrname = pstrdup(te->resname);
            eref->colnames = lappend(eref->colnames, makeString(attrname));
        }
        coltypes = lappend_oid(coltypes,
                               exprType((Node *) te->expr));
        coltypmods = lappend_int(coltypmods,
                                 exprTypmod((Node *) te->expr));
        colcollations = lappend_oid(colcollations,
                                    exprCollation((Node *) te->expr));
    }
    if (varattno < numaliases)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("table \"%s\" has %d columns available but %d columns specified",
                        eref->aliasname, varattno, numaliases)));
 
    rte->eref = eref;
 
    /*
     * Set flags.
     *
     * Subqueries are never checked for access rights, so no need to perform
     * addRTEPermissionInfo().
     */
    rte->lateral = lateral;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    nsitem = buildNSItemFromLists(rte, list_length(pstate->p_rtable),
                                  coltypes, coltypmods, colcollations);
 
    /*
     * Mark it visible as a relation name only if it had a user-written alias.
     */
    nsitem->p_rel_visible = (alias != NULL);
 
    return nsitem;
}

References Alias::aliasname, Assert(), buildNSItemFromLists(), Alias::colnames, copyObject, ereport, errcode(), errmsg(), ERROR, TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), lappend(), lappend_int(), lappend_oid(), lfirst, list_length(), makeAlias(), makeNode, makeString(), NIL, ParseNamespaceItem::p_rel_visible, ParseState::p_rtable, pstrdup(), TargetEntry::resno, RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblEntry::subquery, and Query::targetList.

Referenced by convert_ANY_sublink_to_join(), transformInsertStmt(), transformRangeSubselect(), and transformSetOperationTree().

◆ addRangeTableEntryForTableFunc()

ParseNamespaceItem * addRangeTableEntryForTableFunc	(	ParseState *	pstate,
		TableFunc *	tf,
		Alias *	alias,
		bool	lateral,
		bool	inFromCl
	)

Definition at line 2066 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    char       *refname;
    Alias      *eref;
    int         numaliases;
 
    Assert(pstate != NULL);
 
    /* Disallow more columns than will fit in a tuple */
    if (list_length(tf->colnames) > MaxTupleAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("functions in FROM can return at most %d columns",
                        MaxTupleAttributeNumber),
                 parser_errposition(pstate,
                                    exprLocation((Node *) tf))));
    Assert(list_length(tf->coltypes) == list_length(tf->colnames));
    Assert(list_length(tf->coltypmods) == list_length(tf->colnames));
    Assert(list_length(tf->colcollations) == list_length(tf->colnames));
 
    rte->rtekind = RTE_TABLEFUNC;
    rte->relid = InvalidOid;
    rte->subquery = NULL;
    rte->tablefunc = tf;
    rte->coltypes = tf->coltypes;
    rte->coltypmods = tf->coltypmods;
    rte->colcollations = tf->colcollations;
    rte->alias = alias;
 
    refname = alias ? alias->aliasname :
        pstrdup(tf->functype == TFT_XMLTABLE ? "xmltable" : "json_table");
    eref = alias ? copyObject(alias) : makeAlias(refname, NIL);
    numaliases = list_length(eref->colnames);
 
    /* fill in any unspecified alias columns */
    if (numaliases < list_length(tf->colnames))
        eref->colnames = list_concat(eref->colnames,
                                     list_copy_tail(tf->colnames, numaliases));
 
    if (numaliases > list_length(tf->colnames))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("%s function has %d columns available but %d columns specified",
                        tf->functype == TFT_XMLTABLE ? "XMLTABLE" : "JSON_TABLE",
                        list_length(tf->colnames), numaliases)));
 
    rte->eref = eref;
 
    /*
     * Set flags and access permissions.
     *
     * Tablefuncs are never checked for access rights (at least, not by
     * ExecCheckPermissions()), so no need to perform addRTEPermissionInfo().
     */
    rte->lateral = lateral;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    return buildNSItemFromLists(rte, list_length(pstate->p_rtable),
                                rte->coltypes, rte->coltypmods,
                                rte->colcollations);
}

References Alias::aliasname, Assert(), buildNSItemFromLists(), Alias::colnames, copyObject, ereport, errcode(), errmsg(), ERROR, exprLocation(), TableFunc::functype, InvalidOid, lappend(), list_concat(), list_copy_tail(), list_length(), makeAlias(), makeNode, MaxTupleAttributeNumber, NIL, ParseState::p_rtable, parser_errposition(), pstrdup(), RTE_TABLEFUNC, RangeTblEntry::rtekind, RangeTblEntry::subquery, RangeTblEntry::tablefunc, and TFT_XMLTABLE.

Referenced by transformJsonTable(), and transformRangeTableFunc().

◆ addRangeTableEntryForValues()

ParseNamespaceItem * addRangeTableEntryForValues	(	ParseState *	pstate,
		List *	exprs,
		List *	coltypes,
		List *	coltypmods,
		List *	colcollations,
		Alias *	alias,
		bool	lateral,
		bool	inFromCl
	)

Definition at line 2151 of file parse_relation.c.

{
    RangeTblEntry *rte = makeNode(RangeTblEntry);
    char       *refname = alias ? alias->aliasname : pstrdup("*VALUES*");
    Alias      *eref;
    int         numaliases;
    int         numcolumns;
 
    Assert(pstate != NULL);
 
    rte->rtekind = RTE_VALUES;
    rte->relid = InvalidOid;
    rte->subquery = NULL;
    rte->values_lists = exprs;
    rte->coltypes = coltypes;
    rte->coltypmods = coltypmods;
    rte->colcollations = colcollations;
    rte->alias = alias;
 
    eref = alias ? copyObject(alias) : makeAlias(refname, NIL);
 
    /* fill in any unspecified alias columns */
    numcolumns = list_length((List *) linitial(exprs));
    numaliases = list_length(eref->colnames);
    while (numaliases < numcolumns)
    {
        char        attrname[64];
 
        numaliases++;
        snprintf(attrname, sizeof(attrname), "column%d", numaliases);
        eref->colnames = lappend(eref->colnames,
                                 makeString(pstrdup(attrname)));
    }
    if (numcolumns < numaliases)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("VALUES lists \"%s\" have %d columns available but %d columns specified",
                        refname, numcolumns, numaliases)));
 
    rte->eref = eref;
 
    /*
     * Set flags and access permissions.
     *
     * Subqueries are never checked for access rights, so no need to perform
     * addRTEPermissionInfo().
     */
    rte->lateral = lateral;
    rte->inFromCl = inFromCl;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.  But we don't add it to the join list --- caller must do that if
     * appropriate.
     */
    pstate->p_rtable = lappend(pstate->p_rtable, rte);
 
    /*
     * Build a ParseNamespaceItem, but don't add it to the pstate's namespace
     * list --- caller must do that if appropriate.
     */
    return buildNSItemFromLists(rte, list_length(pstate->p_rtable),
                                rte->coltypes, rte->coltypmods,
                                rte->colcollations);
}

References Alias::aliasname, Assert(), buildNSItemFromLists(), Alias::colnames, copyObject, ereport, errcode(), errmsg(), ERROR, InvalidOid, lappend(), linitial, list_length(), makeAlias(), makeNode, makeString(), NIL, ParseState::p_rtable, pstrdup(), RTE_VALUES, RangeTblEntry::rtekind, snprintf, RangeTblEntry::subquery, and RangeTblEntry::values_lists.

Referenced by transformValuesClause().

◆ addRTEPermissionInfo()

RTEPermissionInfo * addRTEPermissionInfo	(	List **	rteperminfos,
		RangeTblEntry *	rte
	)

Definition at line 3980 of file parse_relation.c.

{
    RTEPermissionInfo *perminfo;
 
    Assert(OidIsValid(rte->relid));
    Assert(rte->perminfoindex == 0);
 
    /* Nope, so make one and add to the list. */
    perminfo = makeNode(RTEPermissionInfo);
    perminfo->relid = rte->relid;
    perminfo->inh = rte->inh;
    /* Other information is set by fetching the node as and where needed. */
 
    *rteperminfos = lappend(*rteperminfos, perminfo);
 
    /* Note its index (1-based!) */
    rte->perminfoindex = list_length(*rteperminfos);
 
    return perminfo;
}

References Assert(), RangeTblEntry::inh, RTEPermissionInfo::inh, lappend(), list_length(), makeNode, OidIsValid, and RTEPermissionInfo::relid.

Referenced by add_rte_to_flat_rtable(), addRangeTableEntry(), addRangeTableEntryForRelation(), create_edata_for_relation(), create_estate_for_relation(), plan_cluster_use_sort(), plan_create_index_workers(), and rewriteTargetView().

◆ attnameAttNum()

int attnameAttNum	(	Relation	rd,
		const char *	attname,
		bool	sysColOK
	)

Definition at line 3589 of file parse_relation.c.

{
    int         i;
 
    for (i = 0; i < RelationGetNumberOfAttributes(rd); i++)
    {
        Form_pg_attribute att = TupleDescAttr(rd->rd_att, i);
 
        if (namestrcmp(&(att->attname), attname) == 0 && !att->attisdropped)
            return i + 1;
    }
 
    if (sysColOK)
    {
        if ((i = specialAttNum(attname)) != InvalidAttrNumber)
            return i;
    }
 
    /* on failure */
    return InvalidAttrNumber;
}

References attname, i, InvalidAttrNumber, namestrcmp(), RelationData::rd_att, RelationGetNumberOfAttributes, specialAttNum(), and TupleDescAttr().

Referenced by checkInsertTargets(), CreateTriggerFiringOn(), do_analyze_rel(), and transformUpdateTargetList().

◆ attnumAttName()

const NameData * attnumAttName	(	Relation	rd,
		int	attid
	)

Definition at line 3639 of file parse_relation.c.

{
    if (attid <= 0)
    {
        const FormData_pg_attribute *sysatt;
 
        sysatt = SystemAttributeDefinition(attid);
        return &sysatt->attname;
    }
    if (attid > rd->rd_att->natts)
        elog(ERROR, "invalid attribute number %d", attid);
    return &TupleDescAttr(rd->rd_att, attid - 1)->attname;
}

References elog, ERROR, FormData_pg_attribute, TupleDescData::natts, RelationData::rd_att, SystemAttributeDefinition(), and TupleDescAttr().

Referenced by transformFkeyGetPrimaryKey().

◆ attnumCollationId()

Oid attnumCollationId	(	Relation	rd,
		int	attid
	)

Definition at line 3681 of file parse_relation.c.

{
    if (attid <= 0)
    {
        /* All system attributes are of noncollatable types. */
        return InvalidOid;
    }
    if (attid > rd->rd_att->natts)
        elog(ERROR, "invalid attribute number %d", attid);
    return TupleDescAttr(rd->rd_att, attid - 1)->attcollation;
}

References elog, ERROR, InvalidOid, TupleDescData::natts, RelationData::rd_att, and TupleDescAttr().

Referenced by transformFkeyGetPrimaryKey().

◆ attnumTypeId()

Oid attnumTypeId	(	Relation	rd,
		int	attid
	)

Definition at line 3661 of file parse_relation.c.

{
    if (attid <= 0)
    {
        const FormData_pg_attribute *sysatt;
 
        sysatt = SystemAttributeDefinition(attid);
        return sysatt->atttypid;
    }
    if (attid > rd->rd_att->natts)
        elog(ERROR, "invalid attribute number %d", attid);
    return TupleDescAttr(rd->rd_att, attid - 1)->atttypid;
}

References elog, ERROR, FormData_pg_attribute, TupleDescData::natts, RelationData::rd_att, SystemAttributeDefinition(), and TupleDescAttr().

Referenced by transformAssignedExpr(), and transformFkeyGetPrimaryKey().

◆ buildNSItemFromLists()

static ParseNamespaceItem * buildNSItemFromLists	(	RangeTblEntry *	rte,
		Index	rtindex,
		List *	coltypes,
		List *	coltypmods,
		List *	colcollations
	)

static

Definition at line 1370 of file parse_relation.c.

{
    ParseNamespaceItem *nsitem;
    ParseNamespaceColumn *nscolumns;
    int         maxattrs = list_length(coltypes);
    int         varattno;
    ListCell   *lct;
    ListCell   *lcm;
    ListCell   *lcc;
 
    /* colnames must have the same number of entries as the nsitem */
    Assert(maxattrs == list_length(rte->eref->colnames));
 
    Assert(maxattrs == list_length(coltypmods));
    Assert(maxattrs == list_length(colcollations));
 
    /* extract per-column data from the lists */
    nscolumns = (ParseNamespaceColumn *)
        palloc0(maxattrs * sizeof(ParseNamespaceColumn));
 
    varattno = 0;
    forthree(lct, coltypes,
             lcm, coltypmods,
             lcc, colcollations)
    {
        nscolumns[varattno].p_varno = rtindex;
        nscolumns[varattno].p_varattno = varattno + 1;
        nscolumns[varattno].p_vartype = lfirst_oid(lct);
        nscolumns[varattno].p_vartypmod = lfirst_int(lcm);
        nscolumns[varattno].p_varcollid = lfirst_oid(lcc);
        nscolumns[varattno].p_varnosyn = rtindex;
        nscolumns[varattno].p_varattnosyn = varattno + 1;
        varattno++;
    }
 
    /* ... and build the nsitem */
    nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem));
    nsitem->p_names = rte->eref;
    nsitem->p_rte = rte;
    nsitem->p_rtindex = rtindex;
    nsitem->p_perminfo = NULL;
    nsitem->p_nscolumns = nscolumns;
    /* set default visibility flags; might get changed later */
    nsitem->p_rel_visible = true;
    nsitem->p_cols_visible = true;
    nsitem->p_lateral_only = false;
    nsitem->p_lateral_ok = true;
    nsitem->p_returning_type = VAR_RETURNING_DEFAULT;
 
    return nsitem;
}

Referenced by addRangeTableEntryForCTE(), addRangeTableEntryForGroup(), addRangeTableEntryForSubquery(), addRangeTableEntryForTableFunc(), and addRangeTableEntryForValues().

◆ buildNSItemFromTupleDesc()

static ParseNamespaceItem * buildNSItemFromTupleDesc	(	RangeTblEntry *	rte,
		Index	rtindex,
		RTEPermissionInfo *	perminfo,
		TupleDesc	tupdesc
	)

static

Definition at line 1309 of file parse_relation.c.

{
    ParseNamespaceItem *nsitem;
    ParseNamespaceColumn *nscolumns;
    int         maxattrs = tupdesc->natts;
    int         varattno;
 
    /* colnames must have the same number of entries as the nsitem */
    Assert(maxattrs == list_length(rte->eref->colnames));
 
    /* extract per-column data from the tupdesc */
    nscolumns = (ParseNamespaceColumn *)
        palloc0(maxattrs * sizeof(ParseNamespaceColumn));
 
    for (varattno = 0; varattno < maxattrs; varattno++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
 
        /* For a dropped column, just leave the entry as zeroes */
        if (attr->attisdropped)
            continue;
 
        nscolumns[varattno].p_varno = rtindex;
        nscolumns[varattno].p_varattno = varattno + 1;
        nscolumns[varattno].p_vartype = attr->atttypid;
        nscolumns[varattno].p_vartypmod = attr->atttypmod;
        nscolumns[varattno].p_varcollid = attr->attcollation;
        nscolumns[varattno].p_varnosyn = rtindex;
        nscolumns[varattno].p_varattnosyn = varattno + 1;
    }
 
    /* ... and build the nsitem */
    nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem));
    nsitem->p_names = rte->eref;
    nsitem->p_rte = rte;
    nsitem->p_rtindex = rtindex;
    nsitem->p_perminfo = perminfo;
    nsitem->p_nscolumns = nscolumns;
    /* set default visibility flags; might get changed later */
    nsitem->p_rel_visible = true;
    nsitem->p_cols_visible = true;
    nsitem->p_lateral_only = false;
    nsitem->p_lateral_ok = true;
    nsitem->p_returning_type = VAR_RETURNING_DEFAULT;
 
    return nsitem;
}

Referenced by addRangeTableEntry(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), and addRangeTableEntryForRelation().

◆ buildRelationAliases()

static void buildRelationAliases	(	TupleDesc	tupdesc,
		Alias *	alias,
		Alias *	eref
	)

static

Definition at line 1192 of file parse_relation.c.

{
    int         maxattrs = tupdesc->natts;
    List       *aliaslist;
    ListCell   *aliaslc;
    int         numaliases;
    int         varattno;
    int         numdropped = 0;
 
    Assert(eref->colnames == NIL);
 
    if (alias)
    {
        aliaslist = alias->colnames;
        aliaslc = list_head(aliaslist);
        numaliases = list_length(aliaslist);
        /* We'll rebuild the alias colname list */
        alias->colnames = NIL;
    }
    else
    {
        aliaslist = NIL;
        aliaslc = NULL;
        numaliases = 0;
    }
 
    for (varattno = 0; varattno < maxattrs; varattno++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
        String     *attrname;
 
        if (attr->attisdropped)
        {
            /* Always insert an empty string for a dropped column */
            attrname = makeString(pstrdup(""));
            if (aliaslc)
                alias->colnames = lappend(alias->colnames, attrname);
            numdropped++;
        }
        else if (aliaslc)
        {
            /* Use the next user-supplied alias */
            attrname = lfirst_node(String, aliaslc);
            aliaslc = lnext(aliaslist, aliaslc);
            alias->colnames = lappend(alias->colnames, attrname);
        }
        else
        {
            attrname = makeString(pstrdup(NameStr(attr->attname)));
            /* we're done with the alias if any */
        }
 
        eref->colnames = lappend(eref->colnames, attrname);
    }
 
    /* Too many user-supplied aliases? */
    if (aliaslc)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("table \"%s\" has %d columns available but %d columns specified",
                        eref->aliasname, maxattrs - numdropped, numaliases)));
}

References Alias::aliasname, Assert(), Alias::colnames, ereport, errcode(), errmsg(), ERROR, lappend(), lfirst_node, list_head(), list_length(), lnext(), makeString(), NameStr, TupleDescData::natts, NIL, pstrdup(), and TupleDescAttr().

Referenced by addRangeTableEntry(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), and addRangeTableEntryForRelation().

◆ check_lateral_ref_ok()

static void check_lateral_ref_ok	(	ParseState *	pstate,
		ParseNamespaceItem *	nsitem,
		int	location
	)

static

Definition at line 491 of file parse_relation.c.

{
    if (nsitem->p_lateral_only && !nsitem->p_lateral_ok)
    {
        /* SQL:2008 demands this be an error, not an invisible item */
        RangeTblEntry *rte = nsitem->p_rte;
        char       *refname = nsitem->p_names->aliasname;
 
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("invalid reference to FROM-clause entry for table \"%s\"",
                        refname),
                 (pstate->p_target_nsitem != NULL &&
                  rte == pstate->p_target_nsitem->p_rte) ?
                 errhint("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
                         refname) :
                 errdetail("The combining JOIN type must be INNER or LEFT for a LATERAL reference."),
                 parser_errposition(pstate, location)));
    }
}

References Alias::aliasname, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseNamespaceItem::p_names, ParseNamespaceItem::p_rte, ParseState::p_target_nsitem, and parser_errposition().

Referenced by colNameToVar(), scanNameSpaceForRefname(), and scanNameSpaceForRelid().

◆ checkNameSpaceConflicts()

void checkNameSpaceConflicts	(	ParseState *	pstate,
		List *	namespace1,
		List *	namespace2
	)

Definition at line 442 of file parse_relation.c.

{
    ListCell   *l1;
 
    foreach(l1, namespace1)
    {
        ParseNamespaceItem *nsitem1 = (ParseNamespaceItem *) lfirst(l1);
        RangeTblEntry *rte1 = nsitem1->p_rte;
        const char *aliasname1 = nsitem1->p_names->aliasname;
        ListCell   *l2;
 
        if (!nsitem1->p_rel_visible)
            continue;
 
        foreach(l2, namespace2)
        {
            ParseNamespaceItem *nsitem2 = (ParseNamespaceItem *) lfirst(l2);
            RangeTblEntry *rte2 = nsitem2->p_rte;
            const char *aliasname2 = nsitem2->p_names->aliasname;
 
            if (!nsitem2->p_rel_visible)
                continue;
            if (strcmp(aliasname2, aliasname1) != 0)
                continue;       /* definitely no conflict */
            if (rte1->rtekind == RTE_RELATION && rte1->alias == NULL &&
                rte2->rtekind == RTE_RELATION && rte2->alias == NULL &&
                rte1->relid != rte2->relid)
                continue;       /* no conflict per SQL rule */
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_ALIAS),
                     errmsg("table name \"%s\" specified more than once",
                            aliasname1)));
        }
    }
}

References Alias::aliasname, ereport, errcode(), errmsg(), ERROR, lfirst, ParseNamespaceItem::p_names, ParseNamespaceItem::p_rel_visible, ParseNamespaceItem::p_rte, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by transformFromClause(), and transformFromClauseItem().

◆ chooseScalarFunctionAlias()

static char * chooseScalarFunctionAlias	(	Node *	funcexpr,
		char *	funcname,
		Alias *	alias,
		int	nfuncs
	)

static

Definition at line 1269 of file parse_relation.c.

{
    char       *pname;
 
    /*
     * If the expression is a simple function call, and the function has a
     * single OUT parameter that is named, use the parameter's name.
     */
    if (funcexpr && IsA(funcexpr, FuncExpr))
    {
        pname = get_func_result_name(((FuncExpr *) funcexpr)->funcid);
        if (pname)
            return pname;
    }
 
    /*
     * If there's just one function in the RTE, and the user gave an RTE alias
     * name, use that name.  (This makes FROM func() AS foo use "foo" as the
     * column name as well as the table alias.)
     */
    if (nfuncs == 1 && alias)
        return alias->aliasname;
 
    /*
     * Otherwise use the function name.
     */
    return funcname;
}

References Alias::aliasname, funcname, get_func_result_name(), and IsA.

Referenced by addRangeTableEntryForFunction().

◆ colNameToVar()

Node * colNameToVar	(	ParseState *	pstate,
		const char *	colname,
		bool	localonly,
		int	location
	)

Definition at line 898 of file parse_relation.c.

{
    Node       *result = NULL;
    int         sublevels_up = 0;
    ParseState *orig_pstate = pstate;
 
    while (pstate != NULL)
    {
        ListCell   *l;
 
        foreach(l, pstate->p_namespace)
        {
            ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
            Node       *newresult;
 
            /* Ignore table-only items */
            if (!nsitem->p_cols_visible)
                continue;
            /* If not inside LATERAL, ignore lateral-only items */
            if (nsitem->p_lateral_only && !pstate->p_lateral_active)
                continue;
 
            /* use orig_pstate here for consistency with other callers */
            newresult = scanNSItemForColumn(orig_pstate, nsitem, sublevels_up,
                                            colname, location);
 
            if (newresult)
            {
                if (result)
                    ereport(ERROR,
                            (errcode(ERRCODE_AMBIGUOUS_COLUMN),
                             errmsg("column reference \"%s\" is ambiguous",
                                    colname),
                             parser_errposition(pstate, location)));
                check_lateral_ref_ok(pstate, nsitem, location);
                result = newresult;
            }
        }
 
        if (result != NULL || localonly)
            break;              /* found, or don't want to look at parent */
 
        pstate = pstate->parentParseState;
        sublevels_up++;
    }
 
    return result;
}

References check_lateral_ref_ok(), ereport, errcode(), errmsg(), ERROR, lfirst, ParseNamespaceItem::p_cols_visible, ParseState::p_lateral_active, ParseNamespaceItem::p_lateral_only, ParseState::p_namespace, ParseState::parentParseState, parser_errposition(), and scanNSItemForColumn().

Referenced by findTargetlistEntrySQL92(), and transformColumnRef().

◆ errorMissingColumn()

void errorMissingColumn	(	ParseState *	pstate,
		const char *	relname,
		const char *	colname,
		int	location
	)

Definition at line 3771 of file parse_relation.c.

{
    FuzzyAttrMatchState *state;
 
    /*
     * Search the entire rtable looking for possible matches.  If we find one,
     * emit a hint about it.
     */
    state = searchRangeTableForCol(pstate, relname, colname, location);
 
    /*
     * If there are exact match(es), they must be inaccessible for some
     * reason.
     */
    if (state->rexact1)
    {
        /*
         * We don't try too hard when there's multiple inaccessible exact
         * matches, but at least be sure that we don't misleadingly suggest
         * that there's only one.
         */
        if (state->rexact2)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     relname ?
                     errmsg("column %s.%s does not exist", relname, colname) :
                     errmsg("column \"%s\" does not exist", colname),
                     errdetail("There are columns named \"%s\", but they are in tables that cannot be referenced from this part of the query.",
                               colname),
                     !relname ? errhint("Try using a table-qualified name.") : 0,
                     parser_errposition(pstate, location)));
        /* Single exact match, so try to determine why it's inaccessible. */
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 relname ?
                 errmsg("column %s.%s does not exist", relname, colname) :
                 errmsg("column \"%s\" does not exist", colname),
                 errdetail("There is a column named \"%s\" in table \"%s\", but it cannot be referenced from this part of the query.",
                           colname, state->rexact1->eref->aliasname),
                 rte_visible_if_lateral(pstate, state->rexact1) ?
                 errhint("To reference that column, you must mark this subquery with LATERAL.") :
                 (!relname && rte_visible_if_qualified(pstate, state->rexact1)) ?
                 errhint("To reference that column, you must use a table-qualified name.") : 0,
                 parser_errposition(pstate, location)));
    }
 
    if (!state->rsecond)
    {
        /* If we found no match at all, we have little to report */
        if (!state->rfirst)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     relname ?
                     errmsg("column %s.%s does not exist", relname, colname) :
                     errmsg("column \"%s\" does not exist", colname),
                     parser_errposition(pstate, location)));
        /* Handle case where we have a single alternative spelling to offer */
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 relname ?
                 errmsg("column %s.%s does not exist", relname, colname) :
                 errmsg("column \"%s\" does not exist", colname),
                 errhint("Perhaps you meant to reference the column \"%s.%s\".",
                         state->rfirst->eref->aliasname,
                         strVal(list_nth(state->rfirst->eref->colnames,
                                         state->first - 1))),
                 parser_errposition(pstate, location)));
    }
    else
    {
        /* Handle case where there are two equally useful column hints */
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 relname ?
                 errmsg("column %s.%s does not exist", relname, colname) :
                 errmsg("column \"%s\" does not exist", colname),
                 errhint("Perhaps you meant to reference the column \"%s.%s\" or the column \"%s.%s\".",
                         state->rfirst->eref->aliasname,
                         strVal(list_nth(state->rfirst->eref->colnames,
                                         state->first - 1)),
                         state->rsecond->eref->aliasname,
                         strVal(list_nth(state->rsecond->eref->colnames,
                                         state->second - 1))),
                 parser_errposition(pstate, location)));
    }
}

References ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, list_nth(), parser_errposition(), relname, rte_visible_if_lateral(), rte_visible_if_qualified(), searchRangeTableForCol(), and strVal.

Referenced by transformColumnRef().

◆ errorMissingRTE()

void errorMissingRTE	(	ParseState *	pstate,
		RangeVar *	relation
	)

Definition at line 3700 of file parse_relation.c.

{
    RangeTblEntry *rte;
    const char *badAlias = NULL;
 
    /*
     * Check to see if there are any potential matches in the query's
     * rangetable.  (Note: cases involving a bad schema name in the RangeVar
     * will throw error immediately here.  That seems OK.)
     */
    rte = searchRangeTableForRel(pstate, relation);
 
    /*
     * If we found a match that has an alias and the alias is visible in the
     * namespace, then the problem is probably use of the relation's real name
     * instead of its alias, ie "SELECT foo.* FROM foo f". This mistake is
     * common enough to justify a specific hint.
     *
     * If we found a match that doesn't meet those criteria, assume the
     * problem is illegal use of a relation outside its scope, as in the
     * MySQL-ism "SELECT ... FROM a, b LEFT JOIN c ON (a.x = c.y)".
     */
    if (rte && rte->alias &&
        strcmp(rte->eref->aliasname, relation->relname) != 0)
    {
        ParseNamespaceItem *nsitem;
        int         sublevels_up;
 
        nsitem = refnameNamespaceItem(pstate, NULL, rte->eref->aliasname,
                                      relation->location,
                                      &sublevels_up);
        if (nsitem && nsitem->p_rte == rte)
            badAlias = rte->eref->aliasname;
    }
 
    /* If it looks like the user forgot to use an alias, hint about that */
    if (badAlias)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("invalid reference to FROM-clause entry for table \"%s\"",
                        relation->relname),
                 errhint("Perhaps you meant to reference the table alias \"%s\".",
                         badAlias),
                 parser_errposition(pstate, relation->location)));
    /* Hint about case where we found an (inaccessible) exact match */
    else if (rte)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("invalid reference to FROM-clause entry for table \"%s\"",
                        relation->relname),
                 errdetail("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
                           rte->eref->aliasname),
                 rte_visible_if_lateral(pstate, rte) ?
                 errhint("To reference that table, you must mark this subquery with LATERAL.") : 0,
                 parser_errposition(pstate, relation->location)));
    /* Else, we have nothing to offer but the bald statement of error */
    else
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("missing FROM-clause entry for table \"%s\"",
                        relation->relname),
                 parser_errposition(pstate, relation->location)));
}

References ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errdetail(), errhint(), errmsg(), ERROR, RangeVar::location, ParseNamespaceItem::p_rte, parser_errposition(), refnameNamespaceItem(), RangeVar::relname, rte_visible_if_lateral(), and searchRangeTableForRel().

Referenced by ExpandColumnRefStar(), and transformColumnRef().

◆ expandNSItemAttrs()

List * expandNSItemAttrs	(	ParseState *	pstate,
		ParseNamespaceItem *	nsitem,
		int	sublevels_up,
		bool	require_col_privs,
		int	location
	)

Definition at line 3292 of file parse_relation.c.

{
    RangeTblEntry *rte = nsitem->p_rte;
    RTEPermissionInfo *perminfo = nsitem->p_perminfo;
    List       *names,
               *vars;
    ListCell   *name,
               *var;
    List       *te_list = NIL;
 
    vars = expandNSItemVars(pstate, nsitem, sublevels_up, location, &names);
 
    /*
     * Require read access to the table.  This is normally redundant with the
     * markVarForSelectPriv calls below, but not if the table has zero
     * columns.  We need not do anything if the nsitem is for a join: its
     * component tables will have been marked ACL_SELECT when they were added
     * to the rangetable.  (This step changes things only for the target
     * relation of UPDATE/DELETE, which cannot be under a join.)
     */
    if (rte->rtekind == RTE_RELATION)
    {
        Assert(perminfo != NULL);
        perminfo->requiredPerms |= ACL_SELECT;
    }
 
    forboth(name, names, var, vars)
    {
        char       *label = strVal(lfirst(name));
        Var        *varnode = (Var *) lfirst(var);
        TargetEntry *te;
 
        te = makeTargetEntry((Expr *) varnode,
                             (AttrNumber) pstate->p_next_resno++,
                             label,
                             false);
        te_list = lappend(te_list, te);
 
        if (require_col_privs)
        {
            /* Require read access to each column */
            markVarForSelectPriv(pstate, varnode);
        }
    }
 
    Assert(name == NULL && var == NULL);    /* lists not the same length? */
 
    return te_list;
}

References ACL_SELECT, Assert(), expandNSItemVars(), forboth, label, lappend(), lfirst, makeTargetEntry(), markVarForSelectPriv(), name, NIL, ParseState::p_next_resno, ParseNamespaceItem::p_perminfo, ParseNamespaceItem::p_rte, RTEPermissionInfo::requiredPerms, RTE_RELATION, RangeTblEntry::rtekind, and strVal.

Referenced by ExpandAllTables(), ExpandSingleTable(), and transformValuesClause().

◆ expandNSItemVars()

List * expandNSItemVars	(	ParseState *	pstate,
		ParseNamespaceItem *	nsitem,
		int	sublevels_up,
		int	location,
		List **	colnames
	)

Definition at line 3227 of file parse_relation.c.

{
    List       *result = NIL;
    int         colindex;
    ListCell   *lc;
 
    if (colnames)
        *colnames = NIL;
    colindex = 0;
    foreach(lc, nsitem->p_names->colnames)
    {
        String     *colnameval = lfirst(lc);
        const char *colname = strVal(colnameval);
        ParseNamespaceColumn *nscol = nsitem->p_nscolumns + colindex;
 
        if (nscol->p_dontexpand)
        {
            /* skip */
        }
        else if (colname[0])
        {
            Var        *var;
 
            Assert(nscol->p_varno > 0);
            var = makeVar(nscol->p_varno,
                          nscol->p_varattno,
                          nscol->p_vartype,
                          nscol->p_vartypmod,
                          nscol->p_varcollid,
                          sublevels_up);
            /* makeVar doesn't offer parameters for these, so set by hand: */
            var->varreturningtype = nscol->p_varreturningtype;
            var->varnosyn = nscol->p_varnosyn;
            var->varattnosyn = nscol->p_varattnosyn;
            var->location = location;
 
            /* ... and update varnullingrels */
            markNullableIfNeeded(pstate, var);
 
            result = lappend(result, var);
            if (colnames)
                *colnames = lappend(*colnames, colnameval);
        }
        else
        {
            /* dropped column, ignore */
            Assert(nscol->p_varno == 0);
        }
        colindex++;
    }
    return result;
}

Referenced by coerce_record_to_complex(), expandNSItemAttrs(), and ExpandSingleTable().

◆ expandRelation()

static void expandRelation	(	Oid	relid,
		Alias *	eref,
		int	rtindex,
		int	sublevels_up,
		VarReturningType	returning_type,
		int	location,
		bool	include_dropped,
		List **	colnames,
		List **	colvars
	)

static

Definition at line 3118 of file parse_relation.c.

{
    Relation    rel;
 
    /* Get the tupledesc and turn it over to expandTupleDesc */
    rel = relation_open(relid, AccessShareLock);
    expandTupleDesc(rel->rd_att, eref, rel->rd_att->natts, 0,
                    rtindex, sublevels_up, returning_type,
                    location, include_dropped,
                    colnames, colvars);
    relation_close(rel, AccessShareLock);
}

References AccessShareLock, expandTupleDesc(), TupleDescData::natts, RelationData::rd_att, relation_close(), and relation_open().

Referenced by expandRTE().

◆ expandRTE()

void expandRTE	(	RangeTblEntry *	rte,
		int	rtindex,
		int	sublevels_up,
		VarReturningType	returning_type,
		int	location,
		bool	include_dropped,
		List **	colnames,
		List **	colvars
	)

Definition at line 2751 of file parse_relation.c.

{
    int         varattno;
 
    if (colnames)
        *colnames = NIL;
    if (colvars)
        *colvars = NIL;
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            /* Ordinary relation RTE */
            expandRelation(rte->relid, rte->eref,
                           rtindex, sublevels_up, returning_type, location,
                           include_dropped, colnames, colvars);
            break;
        case RTE_SUBQUERY:
            {
                /* Subquery RTE */
                ListCell   *aliasp_item = list_head(rte->eref->colnames);
                ListCell   *tlistitem;
 
                varattno = 0;
                foreach(tlistitem, rte->subquery->targetList)
                {
                    TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
 
                    if (te->resjunk)
                        continue;
                    varattno++;
                    Assert(varattno == te->resno);
 
                    /*
                     * Formerly it was possible for the subquery tlist to have
                     * more non-junk entries than the colnames list does (if
                     * this RTE has been expanded from a view that has more
                     * columns than it did when the current query was parsed).
                     * Now that ApplyRetrieveRule cleans up such cases, we
                     * shouldn't see that anymore, but let's just check.
                     */
                    if (!aliasp_item)
                        elog(ERROR, "too few column names for subquery %s",
                             rte->eref->aliasname);
 
                    if (colnames)
                    {
                        char       *label = strVal(lfirst(aliasp_item));
 
                        *colnames = lappend(*colnames, makeString(pstrdup(label)));
                    }
 
                    if (colvars)
                    {
                        Var        *varnode;
 
                        varnode = makeVar(rtindex, varattno,
                                          exprType((Node *) te->expr),
                                          exprTypmod((Node *) te->expr),
                                          exprCollation((Node *) te->expr),
                                          sublevels_up);
                        varnode->varreturningtype = returning_type;
                        varnode->location = location;
 
                        *colvars = lappend(*colvars, varnode);
                    }
 
                    aliasp_item = lnext(rte->eref->colnames, aliasp_item);
                }
            }
            break;
        case RTE_FUNCTION:
            {
                /* Function RTE */
                int         atts_done = 0;
                ListCell   *lc;
 
                foreach(lc, rte->functions)
                {
                    RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
                    TypeFuncClass functypclass;
                    Oid         funcrettype = InvalidOid;
                    TupleDesc   tupdesc = NULL;
 
                    /* If it has a coldeflist, it returns RECORD */
                    if (rtfunc->funccolnames != NIL)
                        functypclass = TYPEFUNC_RECORD;
                    else
                        functypclass = get_expr_result_type(rtfunc->funcexpr,
                                                            &funcrettype,
                                                            &tupdesc);
 
                    if (functypclass == TYPEFUNC_COMPOSITE ||
                        functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
                    {
                        /* Composite data type, e.g. a table's row type */
                        Assert(tupdesc);
                        expandTupleDesc(tupdesc, rte->eref,
                                        rtfunc->funccolcount, atts_done,
                                        rtindex, sublevels_up,
                                        returning_type, location,
                                        include_dropped, colnames, colvars);
                    }
                    else if (functypclass == TYPEFUNC_SCALAR)
                    {
                        /* Base data type, i.e. scalar */
                        if (colnames)
                            *colnames = lappend(*colnames,
                                                list_nth(rte->eref->colnames,
                                                         atts_done));
 
                        if (colvars)
                        {
                            Var        *varnode;
 
                            varnode = makeVar(rtindex, atts_done + 1,
                                              funcrettype,
                                              exprTypmod(rtfunc->funcexpr),
                                              exprCollation(rtfunc->funcexpr),
                                              sublevels_up);
                            varnode->varreturningtype = returning_type;
                            varnode->location = location;
 
                            *colvars = lappend(*colvars, varnode);
                        }
                    }
                    else if (functypclass == TYPEFUNC_RECORD)
                    {
                        if (colnames)
                        {
                            List       *namelist;
 
                            /* extract appropriate subset of column list */
                            namelist = list_copy_tail(rte->eref->colnames,
                                                      atts_done);
                            namelist = list_truncate(namelist,
                                                     rtfunc->funccolcount);
                            *colnames = list_concat(*colnames, namelist);
                        }
 
                        if (colvars)
                        {
                            ListCell   *l1;
                            ListCell   *l2;
                            ListCell   *l3;
                            int         attnum = atts_done;
 
                            forthree(l1, rtfunc->funccoltypes,
                                     l2, rtfunc->funccoltypmods,
                                     l3, rtfunc->funccolcollations)
                            {
                                Oid         attrtype = lfirst_oid(l1);
                                int32       attrtypmod = lfirst_int(l2);
                                Oid         attrcollation = lfirst_oid(l3);
                                Var        *varnode;
 
                                attnum++;
                                varnode = makeVar(rtindex,
                                                  attnum,
                                                  attrtype,
                                                  attrtypmod,
                                                  attrcollation,
                                                  sublevels_up);
                                varnode->varreturningtype = returning_type;
                                varnode->location = location;
                                *colvars = lappend(*colvars, varnode);
                            }
                        }
                    }
                    else
                    {
                        /* addRangeTableEntryForFunction should've caught this */
                        elog(ERROR, "function in FROM has unsupported return type");
                    }
                    atts_done += rtfunc->funccolcount;
                }
 
                /* Append the ordinality column if any */
                if (rte->funcordinality)
                {
                    if (colnames)
                        *colnames = lappend(*colnames,
                                            llast(rte->eref->colnames));
 
                    if (colvars)
                    {
                        Var        *varnode = makeVar(rtindex,
                                                      atts_done + 1,
                                                      INT8OID,
                                                      -1,
                                                      InvalidOid,
                                                      sublevels_up);
 
                        varnode->varreturningtype = returning_type;
                        *colvars = lappend(*colvars, varnode);
                    }
                }
            }
            break;
        case RTE_JOIN:
            {
                /* Join RTE */
                ListCell   *colname;
                ListCell   *aliasvar;
 
                Assert(list_length(rte->eref->colnames) == list_length(rte->joinaliasvars));
 
                varattno = 0;
                forboth(colname, rte->eref->colnames, aliasvar, rte->joinaliasvars)
                {
                    Node       *avar = (Node *) lfirst(aliasvar);
 
                    varattno++;
 
                    /*
                     * During ordinary parsing, there will never be any
                     * deleted columns in the join.  While this function is
                     * also used by the rewriter and planner, they do not
                     * currently call it on any JOIN RTEs.  Therefore, this
                     * next bit is dead code, but it seems prudent to handle
                     * the case correctly anyway.
                     */
                    if (avar == NULL)
                    {
                        if (include_dropped)
                        {
                            if (colnames)
                                *colnames = lappend(*colnames,
                                                    makeString(pstrdup("")));
                            if (colvars)
                            {
                                /*
                                 * Can't use join's column type here (it might
                                 * be dropped!); but it doesn't really matter
                                 * what type the Const claims to be.
                                 */
                                *colvars = lappend(*colvars,
                                                   makeNullConst(INT4OID, -1,
                                                                 InvalidOid));
                            }
                        }
                        continue;
                    }
 
                    if (colnames)
                    {
                        char       *label = strVal(lfirst(colname));
 
                        *colnames = lappend(*colnames,
                                            makeString(pstrdup(label)));
                    }
 
                    if (colvars)
                    {
                        Var        *varnode;
 
                        /*
                         * If the joinaliasvars entry is a simple Var, just
                         * copy it (with adjustment of varlevelsup and
                         * location); otherwise it is a JOIN USING column and
                         * we must generate a join alias Var.  This matches
                         * the results that expansion of "join.*" by
                         * expandNSItemVars would have produced, if we had
                         * access to the ParseNamespaceItem for the join.
                         */
                        if (IsA(avar, Var))
                        {
                            varnode = copyObject((Var *) avar);
                            varnode->varlevelsup = sublevels_up;
                        }
                        else
                            varnode = makeVar(rtindex, varattno,
                                              exprType(avar),
                                              exprTypmod(avar),
                                              exprCollation(avar),
                                              sublevels_up);
                        varnode->varreturningtype = returning_type;
                        varnode->location = location;
 
                        *colvars = lappend(*colvars, varnode);
                    }
                }
            }
            break;
        case RTE_TABLEFUNC:
        case RTE_VALUES:
        case RTE_CTE:
        case RTE_NAMEDTUPLESTORE:
            {
                /* Tablefunc, Values, CTE, or ENR RTE */
                ListCell   *aliasp_item = list_head(rte->eref->colnames);
                ListCell   *lct;
                ListCell   *lcm;
                ListCell   *lcc;
 
                varattno = 0;
                forthree(lct, rte->coltypes,
                         lcm, rte->coltypmods,
                         lcc, rte->colcollations)
                {
                    Oid         coltype = lfirst_oid(lct);
                    int32       coltypmod = lfirst_int(lcm);
                    Oid         colcoll = lfirst_oid(lcc);
 
                    varattno++;
 
                    if (colnames)
                    {
                        /* Assume there is one alias per output column */
                        if (OidIsValid(coltype))
                        {
                            char       *label = strVal(lfirst(aliasp_item));
 
                            *colnames = lappend(*colnames,
                                                makeString(pstrdup(label)));
                        }
                        else if (include_dropped)
                            *colnames = lappend(*colnames,
                                                makeString(pstrdup("")));
 
                        aliasp_item = lnext(rte->eref->colnames, aliasp_item);
                    }
 
                    if (colvars)
                    {
                        if (OidIsValid(coltype))
                        {
                            Var        *varnode;
 
                            varnode = makeVar(rtindex, varattno,
                                              coltype, coltypmod, colcoll,
                                              sublevels_up);
                            varnode->varreturningtype = returning_type;
                            varnode->location = location;
 
                            *colvars = lappend(*colvars, varnode);
                        }
                        else if (include_dropped)
                        {
                            /*
                             * It doesn't really matter what type the Const
                             * claims to be.
                             */
                            *colvars = lappend(*colvars,
                                               makeNullConst(INT4OID, -1,
                                                             InvalidOid));
                        }
                    }
                }
            }
            break;
        case RTE_RESULT:
        case RTE_GROUP:
            /* These expose no columns, so nothing to do */
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
    }
}

References Assert(), attnum, copyObject, elog, ERROR, expandRelation(), expandTupleDesc(), TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), forboth, forthree, RangeTblFunction::funcexpr, RangeTblEntry::funcordinality, RangeTblEntry::functions, get_expr_result_type(), InvalidOid, IsA, label, lappend(), lfirst, lfirst_int, lfirst_oid, list_concat(), list_copy_tail(), list_head(), list_length(), list_nth(), list_truncate(), llast, lnext(), Var::location, makeNullConst(), makeString(), makeVar(), NIL, OidIsValid, pstrdup(), TargetEntry::resno, RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, strVal, RangeTblEntry::subquery, Query::targetList, TYPEFUNC_COMPOSITE, TYPEFUNC_COMPOSITE_DOMAIN, TYPEFUNC_RECORD, TYPEFUNC_SCALAR, Var::varlevelsup, and Var::varreturningtype.

Referenced by build_physical_tlist(), expandRecordVariable(), ReplaceVarFromTargetList(), set_relation_column_names(), and transformWholeRowRef().

◆ expandTupleDesc()

static void expandTupleDesc	(	TupleDesc	tupdesc,
		Alias *	eref,
		int	count,
		int	offset,
		int	rtindex,
		int	sublevels_up,
		VarReturningType	returning_type,
		int	location,
		bool	include_dropped,
		List **	colnames,
		List **	colvars
	)

static

Definition at line 3144 of file parse_relation.c.

{
    ListCell   *aliascell;
    int         varattno;
 
    aliascell = (offset < list_length(eref->colnames)) ?
        list_nth_cell(eref->colnames, offset) : NULL;
 
    Assert(count <= tupdesc->natts);
    for (varattno = 0; varattno < count; varattno++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
 
        if (attr->attisdropped)
        {
            if (include_dropped)
            {
                if (colnames)
                    *colnames = lappend(*colnames, makeString(pstrdup("")));
                if (colvars)
                {
                    /*
                     * can't use atttypid here, but it doesn't really matter
                     * what type the Const claims to be.
                     */
                    *colvars = lappend(*colvars,
                                       makeNullConst(INT4OID, -1, InvalidOid));
                }
            }
            if (aliascell)
                aliascell = lnext(eref->colnames, aliascell);
            continue;
        }
 
        if (colnames)
        {
            char       *label;
 
            if (aliascell)
            {
                label = strVal(lfirst(aliascell));
                aliascell = lnext(eref->colnames, aliascell);
            }
            else
            {
                /* If we run out of aliases, use the underlying name */
                label = NameStr(attr->attname);
            }
            *colnames = lappend(*colnames, makeString(pstrdup(label)));
        }
 
        if (colvars)
        {
            Var        *varnode;
 
            varnode = makeVar(rtindex, varattno + offset + 1,
                              attr->atttypid, attr->atttypmod,
                              attr->attcollation,
                              sublevels_up);
            varnode->varreturningtype = returning_type;
            varnode->location = location;
 
            *colvars = lappend(*colvars, varnode);
        }
    }
}

References Assert(), Alias::colnames, InvalidOid, label, lappend(), lfirst, list_length(), list_nth_cell(), lnext(), Var::location, makeNullConst(), makeString(), makeVar(), NameStr, pstrdup(), strVal, TupleDescAttr(), and Var::varreturningtype.

Referenced by expandRelation(), and expandRTE().

◆ findNSItemForRTE()

static ParseNamespaceItem * findNSItemForRTE	(	ParseState *	pstate,
		RangeTblEntry *	rte
	)

static

Definition at line 3864 of file parse_relation.c.

{
    while (pstate != NULL)
    {
        ListCell   *l;
 
        foreach(l, pstate->p_namespace)
        {
            ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 
            if (nsitem->p_rte == rte)
                return nsitem;
        }
        pstate = pstate->parentParseState;
    }
    return NULL;
}

References lfirst, ParseState::p_namespace, ParseNamespaceItem::p_rte, and ParseState::parentParseState.

Referenced by rte_visible_if_lateral(), and rte_visible_if_qualified().

◆ get_parse_rowmark()

RowMarkClause * get_parse_rowmark	(	Query *	qry,
		Index	rtindex
	)

Definition at line 3565 of file parse_relation.c.

{
    ListCell   *l;
 
    foreach(l, qry->rowMarks)
    {
        RowMarkClause *rc = (RowMarkClause *) lfirst(l);
 
        if (rc->rti == rtindex)
            return rc;
    }
    return NULL;
}

References lfirst, Query::rowMarks, and RowMarkClause::rti.

Referenced by AcquireRewriteLocks(), applyLockingClause(), and ApplyRetrieveRule().

◆ get_rte_attribute_is_dropped()

bool get_rte_attribute_is_dropped	(	RangeTblEntry *	rte,
		AttrNumber	attnum
	)

Definition at line 3396 of file parse_relation.c.

{
    bool        result;
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            {
                /*
                 * Plain relation RTE --- get the attribute's catalog entry
                 */
                HeapTuple   tp;
                Form_pg_attribute att_tup;
 
                tp = SearchSysCache2(ATTNUM,
                                     ObjectIdGetDatum(rte->relid),
                                     Int16GetDatum(attnum));
                if (!HeapTupleIsValid(tp))  /* shouldn't happen */
                    elog(ERROR, "cache lookup failed for attribute %d of relation %u",
                         attnum, rte->relid);
                att_tup = (Form_pg_attribute) GETSTRUCT(tp);
                result = att_tup->attisdropped;
                ReleaseSysCache(tp);
            }
            break;
        case RTE_SUBQUERY:
        case RTE_TABLEFUNC:
        case RTE_VALUES:
        case RTE_CTE:
        case RTE_GROUP:
 
            /*
             * Subselect, Table Functions, Values, CTE, GROUP RTEs never have
             * dropped columns
             */
            result = false;
            break;
        case RTE_NAMEDTUPLESTORE:
            {
                /* Check dropped-ness by testing for valid coltype */
                if (attnum <= 0 ||
                    attnum > list_length(rte->coltypes))
                    elog(ERROR, "invalid varattno %d", attnum);
                result = !OidIsValid((list_nth_oid(rte->coltypes, attnum - 1)));
            }
            break;
        case RTE_JOIN:
            {
                /*
                 * A join RTE would not have dropped columns when constructed,
                 * but one in a stored rule might contain columns that were
                 * dropped from the underlying tables, if said columns are
                 * nowhere explicitly referenced in the rule.  This will be
                 * signaled to us by a null pointer in the joinaliasvars list.
                 */
                Var        *aliasvar;
 
                if (attnum <= 0 ||
                    attnum > list_length(rte->joinaliasvars))
                    elog(ERROR, "invalid varattno %d", attnum);
                aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1);
 
                result = (aliasvar == NULL);
            }
            break;
        case RTE_FUNCTION:
            {
                /* Function RTE */
                ListCell   *lc;
                int         atts_done = 0;
 
                /*
                 * Dropped attributes are only possible with functions that
                 * return named composite types.  In such a case we have to
                 * look up the result type to see if it currently has this
                 * column dropped.  So first, loop over the funcs until we
                 * find the one that covers the requested column.
                 */
                foreach(lc, rte->functions)
                {
                    RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
 
                    if (attnum > atts_done &&
                        attnum <= atts_done + rtfunc->funccolcount)
                    {
                        TupleDesc   tupdesc;
 
                        /* If it has a coldeflist, it returns RECORD */
                        if (rtfunc->funccolnames != NIL)
                            return false;   /* can't have any dropped columns */
 
                        tupdesc = get_expr_result_tupdesc(rtfunc->funcexpr,
                                                          true);
                        if (tupdesc)
                        {
                            /* Composite data type, e.g. a table's row type */
                            Form_pg_attribute att_tup;
 
                            Assert(tupdesc);
                            Assert(attnum - atts_done <= tupdesc->natts);
                            att_tup = TupleDescAttr(tupdesc,
                                                    attnum - atts_done - 1);
                            return att_tup->attisdropped;
                        }
                        /* Otherwise, it can't have any dropped columns */
                        return false;
                    }
                    atts_done += rtfunc->funccolcount;
                }
 
                /* If we get here, must be looking for the ordinality column */
                if (rte->funcordinality && attnum == atts_done + 1)
                    return false;
 
                /* this probably can't happen ... */
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column %d of relation \"%s\" does not exist",
                                attnum,
                                rte->eref->aliasname)));
                result = false; /* keep compiler quiet */
            }
            break;
        case RTE_RESULT:
            /* this probably can't happen ... */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column %d of relation \"%s\" does not exist",
                            attnum,
                            rte->eref->aliasname)));
            result = false;     /* keep compiler quiet */
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
            result = false;     /* keep compiler quiet */
    }
 
    return result;
}

References Assert(), attnum, elog, ereport, errcode(), errmsg(), ERROR, RangeTblFunction::funcexpr, RangeTblEntry::funcordinality, RangeTblEntry::functions, get_expr_result_tupdesc(), GETSTRUCT(), HeapTupleIsValid, Int16GetDatum(), lfirst, list_length(), list_nth(), list_nth_oid(), NIL, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, SearchSysCache2(), and TupleDescAttr().

Referenced by AcquireRewriteLocks().

◆ get_rte_attribute_name()

char * get_rte_attribute_name	(	RangeTblEntry *	rte,
		AttrNumber	attnum
	)

Definition at line 3358 of file parse_relation.c.

{
    if (attnum == InvalidAttrNumber)
        return "*";
 
    /*
     * If there is a user-written column alias, use it.
     */
    if (rte->alias &&
        attnum > 0 && attnum <= list_length(rte->alias->colnames))
        return strVal(list_nth(rte->alias->colnames, attnum - 1));
 
    /*
     * If the RTE is a relation, go to the system catalogs not the
     * eref->colnames list.  This is a little slower but it will give the
     * right answer if the column has been renamed since the eref list was
     * built (which can easily happen for rules).
     */
    if (rte->rtekind == RTE_RELATION)
        return get_attname(rte->relid, attnum, false);
 
    /*
     * Otherwise use the column name from eref.  There should always be one.
     */
    if (attnum > 0 && attnum <= list_length(rte->eref->colnames))
        return strVal(list_nth(rte->eref->colnames, attnum - 1));
 
    /* else caller gave us a bogus attnum */
    elog(ERROR, "invalid attnum %d for rangetable entry %s",
         attnum, rte->eref->aliasname);
    return NULL;                /* keep compiler quiet */
}

References attnum, elog, ERROR, get_attname(), InvalidAttrNumber, list_length(), list_nth(), RTE_RELATION, RangeTblEntry::rtekind, and strVal.

Referenced by get_name_for_var_field(), get_variable(), print_expr(), and substitute_grouped_columns_mutator().

◆ get_tle_by_resno()

TargetEntry * get_tle_by_resno	(	List *	tlist,
		AttrNumber	resno
	)

Definition at line 3545 of file parse_relation.c.

{
    ListCell   *l;
 
    foreach(l, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->resno == resno)
            return tle;
    }
    return NULL;
}

References lfirst, and TargetEntry::resno.

Referenced by adjust_view_column_set(), count_rowexpr_columns(), create_unique_plan(), currtid_for_view(), examine_simple_variable(), expandRecordVariable(), get_name_for_var_field(), get_variable(), make_sort_from_groupcols(), markTargetListOrigin(), prepare_sort_from_pathkeys(), ReplaceVarFromTargetList(), resolve_special_varno(), rewriteTargetView(), show_grouping_set_keys(), show_sort_group_keys(), and show_window_keys().

◆ GetCTEForRTE()

CommonTableExpr * GetCTEForRTE	(	ParseState *	pstate,
		RangeTblEntry *	rte,
		int	rtelevelsup
	)

Definition at line 565 of file parse_relation.c.

{
    Index       levelsup;
    ListCell   *lc;
 
    Assert(rte->rtekind == RTE_CTE);
    levelsup = rte->ctelevelsup + rtelevelsup;
    while (levelsup-- > 0)
    {
        pstate = pstate->parentParseState;
        if (!pstate)            /* shouldn't happen */
            elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    }
    foreach(lc, pstate->p_ctenamespace)
    {
        CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 
        if (strcmp(cte->ctename, rte->ctename) == 0)
            return cte;
    }
    /* shouldn't happen */
    elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
    return NULL;                /* keep compiler quiet */
}

References Assert(), RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, CommonTableExpr::ctename, elog, ERROR, lfirst, ParseState::p_ctenamespace, ParseState::parentParseState, RTE_CTE, and RangeTblEntry::rtekind.

Referenced by expandRecordVariable(), and markTargetListOrigin().

◆ GetNSItemByRangeTablePosn()

ParseNamespaceItem * GetNSItemByRangeTablePosn	(	ParseState *	pstate,
		int	varno,
		int	sublevels_up
	)

Definition at line 518 of file parse_relation.c.

{
    ListCell   *lc;
 
    while (sublevels_up-- > 0)
    {
        pstate = pstate->parentParseState;
        Assert(pstate != NULL);
    }
    foreach(lc, pstate->p_namespace)
    {
        ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(lc);
 
        if (nsitem->p_rtindex == varno)
            return nsitem;
    }
    elog(ERROR, "nsitem not found (internal error)");
    return NULL;                /* keep compiler quiet */
}

References Assert(), elog, ERROR, lfirst, ParseState::p_namespace, ParseNamespaceItem::p_rtindex, and ParseState::parentParseState.

Referenced by coerce_record_to_complex(), ExpandRowReference(), ParseComplexProjection(), and transformMergeStmt().

◆ GetRTEByRangeTablePosn()

RangeTblEntry * GetRTEByRangeTablePosn	(	ParseState *	pstate,
		int	varno,
		int	sublevels_up
	)

Definition at line 545 of file parse_relation.c.

{
    while (sublevels_up-- > 0)
    {
        pstate = pstate->parentParseState;
        Assert(pstate != NULL);
    }
    Assert(varno > 0 && varno <= list_length(pstate->p_rtable));
    return rt_fetch(varno, pstate->p_rtable);
}

References Assert(), list_length(), ParseState::p_rtable, ParseState::parentParseState, and rt_fetch.

Referenced by count_rowexpr_columns(), expandRecordVariable(), markTargetListOrigin(), and unknown_attribute().

◆ getRTEPermissionInfo()

RTEPermissionInfo * getRTEPermissionInfo	(	List *	rteperminfos,
		RangeTblEntry *	rte
	)

Definition at line 4009 of file parse_relation.c.

{
    RTEPermissionInfo *perminfo;
 
    if (rte->perminfoindex == 0 ||
        rte->perminfoindex > list_length(rteperminfos))
        elog(ERROR, "invalid perminfoindex %u in RTE with relid %u",
             rte->perminfoindex, rte->relid);
    perminfo = list_nth_node(RTEPermissionInfo, rteperminfos,
                             rte->perminfoindex - 1);
    if (perminfo->relid != rte->relid)
        elog(ERROR, "permission info at index %u (with relid=%u) does not match provided RTE (with relid=%u)",
             rte->perminfoindex, perminfo->relid, rte->relid);
 
    return perminfo;
}

References elog, ERROR, list_length(), list_nth_node, and RTEPermissionInfo::relid.

Referenced by add_rte_to_flat_rtable(), build_simple_rel(), examine_simple_variable(), ExecCheckPermissions(), expand_inherited_rtentry(), get_rel_all_updated_cols(), get_row_security_policies(), GetResultRTEPermissionInfo(), markQueryForLocking(), markRTEForSelectPriv(), rewriteTargetView(), and transformLockingClause().

◆ isFutureCTE()

static bool isFutureCTE	(	ParseState *	pstate,
		const char *	refname
	)

static

Definition at line 321 of file parse_relation.c.

{
    for (; pstate != NULL; pstate = pstate->parentParseState)
    {
        ListCell   *lc;
 
        foreach(lc, pstate->p_future_ctes)
        {
            CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 
            if (strcmp(cte->ctename, refname) == 0)
                return true;
        }
    }
    return false;
}

References CommonTableExpr::ctename, lfirst, ParseState::p_future_ctes, and ParseState::parentParseState.

Referenced by parserOpenTable().

◆ isLockedRefname()

bool isLockedRefname	(	ParseState *	pstate,
		const char *	refname
	)

Definition at line 2666 of file parse_relation.c.

{
    ListCell   *l;
 
    /*
     * If we are in a subquery specified as locked FOR UPDATE/SHARE from
     * parent level, then act as though there's a generic FOR UPDATE here.
     */
    if (pstate->p_locked_from_parent)
        return true;
 
    foreach(l, pstate->p_locking_clause)
    {
        LockingClause *lc = (LockingClause *) lfirst(l);
 
        if (lc->lockedRels == NIL)
        {
            /* all tables used in query */
            return true;
        }
        else if (refname != NULL)
        {
            /* just the named tables */
            ListCell   *l2;
 
            foreach(l2, lc->lockedRels)
            {
                RangeVar   *thisrel = (RangeVar *) lfirst(l2);
 
                if (strcmp(refname, thisrel->relname) == 0)
                    return true;
            }
        }
    }
    return false;
}

References lfirst, LockingClause::lockedRels, NIL, ParseState::p_locked_from_parent, ParseState::p_locking_clause, and RangeVar::relname.

Referenced by addRangeTableEntry(), and transformRangeSubselect().

◆ isQueryUsingTempRelation()

bool isQueryUsingTempRelation ( Query * query )

Definition at line 3930 of file parse_relation.c.

{
    return isQueryUsingTempRelation_walker((Node *) query, NULL);
}

References isQueryUsingTempRelation_walker().

Referenced by DefineView(), and transformCreateTableAsStmt().

◆ isQueryUsingTempRelation_walker()

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

static

Definition at line 3936 of file parse_relation.c.

{
    if (node == NULL)
        return false;
 
    if (IsA(node, Query))
    {
        Query      *query = (Query *) node;
        ListCell   *rtable;
 
        foreach(rtable, query->rtable)
        {
            RangeTblEntry *rte = lfirst(rtable);
 
            if (rte->rtekind == RTE_RELATION)
            {
                Relation    rel = table_open(rte->relid, AccessShareLock);
                char        relpersistence = rel->rd_rel->relpersistence;
 
                table_close(rel, AccessShareLock);
                if (relpersistence == RELPERSISTENCE_TEMP)
                    return true;
            }
        }
 
        return query_tree_walker(query,
                                 isQueryUsingTempRelation_walker,
                                 context,
                                 QTW_IGNORE_JOINALIASES);
    }
 
    return expression_tree_walker(node,
                                  isQueryUsingTempRelation_walker,
                                  context);
}

References AccessShareLock, expression_tree_walker, IsA, isQueryUsingTempRelation_walker(), lfirst, QTW_IGNORE_JOINALIASES, query_tree_walker, RelationData::rd_rel, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, table_close(), and table_open().

Referenced by isQueryUsingTempRelation(), and isQueryUsingTempRelation_walker().

◆ markNullableIfNeeded()

void markNullableIfNeeded	(	ParseState *	pstate,
		Var *	var
	)

Definition at line 1050 of file parse_relation.c.

{
    int         rtindex = var->varno;
    Bitmapset  *relids;
 
    /* Find the appropriate pstate */
    for (int lv = 0; lv < var->varlevelsup; lv++)
        pstate = pstate->parentParseState;
 
    /* Find currently-relevant join relids for the Var's rel */
    if (rtindex > 0 && rtindex <= list_length(pstate->p_nullingrels))
        relids = (Bitmapset *) list_nth(pstate->p_nullingrels, rtindex - 1);
    else
        relids = NULL;
 
    /*
     * Merge with any already-declared nulling rels.  (Typically there won't
     * be any, but let's get it right if there are.)
     */
    if (relids != NULL)
        var->varnullingrels = bms_union(var->varnullingrels, relids);
}

References bms_union(), if(), list_length(), list_nth(), ParseState::p_nullingrels, ParseState::parentParseState, Var::varlevelsup, and Var::varno.

Referenced by buildVarFromNSColumn(), expandNSItemVars(), scanNSItemForColumn(), and transformWholeRowRef().

◆ markRTEForSelectPriv()

static void markRTEForSelectPriv	(	ParseState *	pstate,
		int	rtindex,
		AttrNumber	col
	)

static

Definition at line 1081 of file parse_relation.c.

{
    RangeTblEntry *rte = rt_fetch(rtindex, pstate->p_rtable);
 
    if (rte->rtekind == RTE_RELATION)
    {
        RTEPermissionInfo *perminfo;
 
        /* Make sure the rel as a whole is marked for SELECT access */
        perminfo = getRTEPermissionInfo(pstate->p_rteperminfos, rte);
        perminfo->requiredPerms |= ACL_SELECT;
        /* Must offset the attnum to fit in a bitmapset */
        perminfo->selectedCols =
            bms_add_member(perminfo->selectedCols,
                           col - FirstLowInvalidHeapAttributeNumber);
    }
    else if (rte->rtekind == RTE_JOIN)
    {
        if (col == InvalidAttrNumber)
        {
            /*
             * A whole-row reference to a join has to be treated as whole-row
             * references to the two inputs.
             */
            JoinExpr   *j;
 
            if (rtindex > 0 && rtindex <= list_length(pstate->p_joinexprs))
                j = list_nth_node(JoinExpr, pstate->p_joinexprs, rtindex - 1);
            else
                j = NULL;
            if (j == NULL)
                elog(ERROR, "could not find JoinExpr for whole-row reference");
 
            /* Note: we can't see FromExpr here */
            if (IsA(j->larg, RangeTblRef))
            {
                int         varno = ((RangeTblRef *) j->larg)->rtindex;
 
                markRTEForSelectPriv(pstate, varno, InvalidAttrNumber);
            }
            else if (IsA(j->larg, JoinExpr))
            {
                int         varno = ((JoinExpr *) j->larg)->rtindex;
 
                markRTEForSelectPriv(pstate, varno, InvalidAttrNumber);
            }
            else
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(j->larg));
            if (IsA(j->rarg, RangeTblRef))
            {
                int         varno = ((RangeTblRef *) j->rarg)->rtindex;
 
                markRTEForSelectPriv(pstate, varno, InvalidAttrNumber);
            }
            else if (IsA(j->rarg, JoinExpr))
            {
                int         varno = ((JoinExpr *) j->rarg)->rtindex;
 
                markRTEForSelectPriv(pstate, varno, InvalidAttrNumber);
            }
            else
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(j->rarg));
        }
        else
        {
            /*
             * Join alias Vars for ordinary columns must refer to merged JOIN
             * USING columns.  We don't need to do anything here, because the
             * join input columns will also be referenced in the join's qual
             * clause, and will get marked for select privilege there.
             */
        }
    }
    /* other RTE types don't require privilege marking */
}

References ACL_SELECT, bms_add_member(), elog, ERROR, FirstLowInvalidHeapAttributeNumber, getRTEPermissionInfo(), InvalidAttrNumber, IsA, j, list_length(), list_nth_node, markRTEForSelectPriv(), nodeTag, ParseState::p_joinexprs, ParseState::p_rtable, ParseState::p_rteperminfos, RTEPermissionInfo::requiredPerms, rt_fetch, RTE_JOIN, RTE_RELATION, RangeTblEntry::rtekind, and RTEPermissionInfo::selectedCols.

Referenced by markRTEForSelectPriv(), and markVarForSelectPriv().

◆ markVarForSelectPriv()

void markVarForSelectPriv	(	ParseState *	pstate,
		Var *	var
	)

Definition at line 1165 of file parse_relation.c.

{
    Index       lv;
 
    Assert(IsA(var, Var));
    /* Find the appropriate pstate if it's an uplevel Var */
    for (lv = 0; lv < var->varlevelsup; lv++)
        pstate = pstate->parentParseState;
    markRTEForSelectPriv(pstate, var->varno, var->varattno);
}

References Assert(), IsA, markRTEForSelectPriv(), ParseState::parentParseState, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by expandNSItemAttrs(), ExpandSingleTable(), scanNSItemForColumn(), transformJoinUsingClause(), and transformWholeRowRef().

◆ parserOpenTable()

Relation parserOpenTable	(	ParseState *	pstate,
		const RangeVar *	relation,
		int	lockmode
	)

Definition at line 1435 of file parse_relation.c.

{
    Relation    rel;
    ParseCallbackState pcbstate;
 
    setup_parser_errposition_callback(&pcbstate, pstate, relation->location);
    rel = table_openrv_extended(relation, lockmode, true);
    if (rel == NULL)
    {
        if (relation->schemaname)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("relation \"%s.%s\" does not exist",
                            relation->schemaname, relation->relname)));
        else
        {
            /*
             * An unqualified name might have been meant as a reference to
             * some not-yet-in-scope CTE.  The bare "does not exist" message
             * has proven remarkably unhelpful for figuring out such problems,
             * so we take pains to offer a specific hint.
             */
            if (isFutureCTE(pstate, relation->relname))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_TABLE),
                         errmsg("relation \"%s\" does not exist",
                                relation->relname),
                         errdetail("There is a WITH item named \"%s\", but it cannot be referenced from this part of the query.",
                                   relation->relname),
                         errhint("Use WITH RECURSIVE, or re-order the WITH items to remove forward references.")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_TABLE),
                         errmsg("relation \"%s\" does not exist",
                                relation->relname)));
        }
    }
    cancel_parser_errposition_callback(&pcbstate);
    return rel;
}

References cancel_parser_errposition_callback(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errdetail(), errhint(), errmsg(), ERROR, isFutureCTE(), RangeVar::location, RangeVar::relname, RangeVar::schemaname, setup_parser_errposition_callback(), and table_openrv_extended().

Referenced by addRangeTableEntry(), and setTargetTable().

◆ refnameNamespaceItem()

ParseNamespaceItem * refnameNamespaceItem	(	ParseState *	pstate,
		const char *	schemaname,
		const char *	refname,
		int	location,
		int *	sublevels_up
	)

Definition at line 134 of file parse_relation.c.

{
    Oid         relId = InvalidOid;
 
    if (sublevels_up)
        *sublevels_up = 0;
 
    if (schemaname != NULL)
    {
        Oid         namespaceId;
 
        /*
         * We can use LookupNamespaceNoError() here because we are only
         * interested in finding existing RTEs.  Checking USAGE permission on
         * the schema is unnecessary since it would have already been checked
         * when the RTE was made.  Furthermore, we want to report "RTE not
         * found", not "no permissions for schema", if the name happens to
         * match a schema name the user hasn't got access to.
         */
        namespaceId = LookupNamespaceNoError(schemaname);
        if (!OidIsValid(namespaceId))
            return NULL;
        relId = get_relname_relid(refname, namespaceId);
        if (!OidIsValid(relId))
            return NULL;
    }
 
    while (pstate != NULL)
    {
        ParseNamespaceItem *result;
 
        if (OidIsValid(relId))
            result = scanNameSpaceForRelid(pstate, relId, location);
        else
            result = scanNameSpaceForRefname(pstate, refname, location);
 
        if (result)
            return result;
 
        if (sublevels_up)
            (*sublevels_up)++;
        else
            break;
 
        pstate = pstate->parentParseState;
    }
    return NULL;
}

References get_relname_relid(), InvalidOid, LookupNamespaceNoError(), OidIsValid, ParseState::parentParseState, scanNameSpaceForRefname(), and scanNameSpaceForRelid().

Referenced by errorMissingRTE(), ExpandColumnRefStar(), transformColumnRef(), and transformReturningClause().

◆ rte_visible_if_lateral()

static bool rte_visible_if_lateral	(	ParseState *	pstate,
		RangeTblEntry *	rte
	)

static

Definition at line 3892 of file parse_relation.c.

{
    ParseNamespaceItem *nsitem;
 
    /* If LATERAL *is* active, we're clearly barking up the wrong tree */
    if (pstate->p_lateral_active)
        return false;
    nsitem = findNSItemForRTE(pstate, rte);
    if (nsitem)
    {
        /* Found it, report whether it's LATERAL-only */
        return nsitem->p_lateral_only && nsitem->p_lateral_ok;
    }
    return false;
}

References findNSItemForRTE(), ParseState::p_lateral_active, ParseNamespaceItem::p_lateral_ok, and ParseNamespaceItem::p_lateral_only.

Referenced by errorMissingColumn(), and errorMissingRTE().

◆ rte_visible_if_qualified()

static bool rte_visible_if_qualified	(	ParseState *	pstate,
		RangeTblEntry *	rte
	)

static

Definition at line 3912 of file parse_relation.c.

{
    ParseNamespaceItem *nsitem = findNSItemForRTE(pstate, rte);
 
    if (nsitem)
    {
        /* Found it, report whether it's relation-only */
        return nsitem->p_rel_visible && !nsitem->p_cols_visible;
    }
    return false;
}

References findNSItemForRTE(), ParseNamespaceItem::p_cols_visible, and ParseNamespaceItem::p_rel_visible.

Referenced by errorMissingColumn().

◆ scanNameSpaceForCTE()

CommonTableExpr * scanNameSpaceForCTE	(	ParseState *	pstate,
		const char *	refname,
		Index *	ctelevelsup
	)

Definition at line 290 of file parse_relation.c.

{
    Index       levelsup;
 
    for (levelsup = 0;
         pstate != NULL;
         pstate = pstate->parentParseState, levelsup++)
    {
        ListCell   *lc;
 
        foreach(lc, pstate->p_ctenamespace)
        {
            CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 
            if (strcmp(cte->ctename, refname) == 0)
            {
                *ctelevelsup = levelsup;
                return cte;
            }
        }
    }
    return NULL;
}

References CommonTableExpr::ctename, lfirst, ParseState::p_ctenamespace, and ParseState::parentParseState.

Referenced by getNSItemForSpecialRelationTypes(), and searchRangeTableForRel().

◆ scanNameSpaceForENR()

bool scanNameSpaceForENR	(	ParseState *	pstate,
		const char *	refname
	)

Definition at line 343 of file parse_relation.c.

{
    return name_matches_visible_ENR(pstate, refname);
}

References name_matches_visible_ENR().

Referenced by getNSItemForSpecialRelationTypes(), searchRangeTableForRel(), and setTargetTable().

◆ scanNameSpaceForRefname()

static ParseNamespaceItem * scanNameSpaceForRefname	(	ParseState *	pstate,
		const char *	refname,
		int	location
	)

static

Definition at line 205 of file parse_relation.c.

{
    ParseNamespaceItem *result = NULL;
    ListCell   *l;
 
    foreach(l, pstate->p_namespace)
    {
        ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 
        /* Ignore columns-only items */
        if (!nsitem->p_rel_visible)
            continue;
        /* If not inside LATERAL, ignore lateral-only items */
        if (nsitem->p_lateral_only && !pstate->p_lateral_active)
            continue;
 
        if (strcmp(nsitem->p_names->aliasname, refname) == 0)
        {
            if (result)
                ereport(ERROR,
                        (errcode(ERRCODE_AMBIGUOUS_ALIAS),
                         errmsg("table reference \"%s\" is ambiguous",
                                refname),
                         parser_errposition(pstate, location)));
            check_lateral_ref_ok(pstate, nsitem, location);
            result = nsitem;
        }
    }
    return result;
}

References Alias::aliasname, check_lateral_ref_ok(), ereport, errcode(), errmsg(), ERROR, lfirst, ParseState::p_lateral_active, ParseNamespaceItem::p_lateral_only, ParseNamespaceItem::p_names, ParseState::p_namespace, ParseNamespaceItem::p_rel_visible, and parser_errposition().

Referenced by refnameNamespaceItem().

◆ scanNameSpaceForRelid()

static ParseNamespaceItem * scanNameSpaceForRelid	(	ParseState *	pstate,
		Oid	relid,
		int	location
	)

static

Definition at line 245 of file parse_relation.c.

{
    ParseNamespaceItem *result = NULL;
    ListCell   *l;
 
    foreach(l, pstate->p_namespace)
    {
        ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
        RangeTblEntry *rte = nsitem->p_rte;
 
        /* Ignore columns-only items */
        if (!nsitem->p_rel_visible)
            continue;
        /* If not inside LATERAL, ignore lateral-only items */
        if (nsitem->p_lateral_only && !pstate->p_lateral_active)
            continue;
        /* Ignore OLD/NEW namespace items that can appear in RETURNING */
        if (nsitem->p_returning_type != VAR_RETURNING_DEFAULT)
            continue;
 
        /* yes, the test for alias == NULL should be there... */
        if (rte->rtekind == RTE_RELATION &&
            rte->relid == relid &&
            rte->alias == NULL)
        {
            if (result)
                ereport(ERROR,
                        (errcode(ERRCODE_AMBIGUOUS_ALIAS),
                         errmsg("table reference %u is ambiguous",
                                relid),
                         parser_errposition(pstate, location)));
            check_lateral_ref_ok(pstate, nsitem, location);
            result = nsitem;
        }
    }
    return result;
}

References check_lateral_ref_ok(), ereport, errcode(), errmsg(), ERROR, lfirst, ParseState::p_lateral_active, ParseNamespaceItem::p_lateral_only, ParseState::p_namespace, ParseNamespaceItem::p_rel_visible, ParseNamespaceItem::p_returning_type, ParseNamespaceItem::p_rte, parser_errposition(), RTE_RELATION, RangeTblEntry::rtekind, and VAR_RETURNING_DEFAULT.

Referenced by refnameNamespaceItem().

◆ scanNSItemForColumn()

Node * scanNSItemForColumn	(	ParseState *	pstate,
		ParseNamespaceItem *	nsitem,
		int	sublevels_up,
		const char *	colname,
		int	location
	)

Definition at line 688 of file parse_relation.c.

{
    RangeTblEntry *rte = nsitem->p_rte;
    int         attnum;
    Var        *var;
 
    /*
     * Scan the nsitem's column names (or aliases) for a match.  Complain if
     * multiple matches.
     */
    attnum = scanRTEForColumn(pstate, rte, nsitem->p_names,
                              colname, location,
                              0, NULL);
 
    if (attnum == InvalidAttrNumber)
        return NULL;            /* Return NULL if no match */
 
    /* In constraint check, no system column is allowed except tableOid */
    if (pstate->p_expr_kind == EXPR_KIND_CHECK_CONSTRAINT &&
        attnum < InvalidAttrNumber && attnum != TableOidAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("system column \"%s\" reference in check constraint is invalid",
                        colname),
                 parser_errposition(pstate, location)));
 
    /*
     * In generated column, no system column is allowed except tableOid.
     * (Required for stored generated, but we also do it for virtual generated
     * for now for consistency.)
     */
    if (pstate->p_expr_kind == EXPR_KIND_GENERATED_COLUMN &&
        attnum < InvalidAttrNumber && attnum != TableOidAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("cannot use system column \"%s\" in column generation expression",
                        colname),
                 parser_errposition(pstate, location)));
 
    /*
     * In a MERGE WHEN condition, no system column is allowed except tableOid
     */
    if (pstate->p_expr_kind == EXPR_KIND_MERGE_WHEN &&
        attnum < InvalidAttrNumber && attnum != TableOidAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("cannot use system column \"%s\" in MERGE WHEN condition",
                        colname),
                 parser_errposition(pstate, location)));
 
    /* Found a valid match, so build a Var */
    if (attnum > InvalidAttrNumber)
    {
        /* Get attribute data from the ParseNamespaceColumn array */
        ParseNamespaceColumn *nscol = &nsitem->p_nscolumns[attnum - 1];
 
        /* Complain if dropped column.  See notes in scanRTEForColumn. */
        if (nscol->p_varno == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            colname,
                            nsitem->p_names->aliasname)));
 
        var = makeVar(nscol->p_varno,
                      nscol->p_varattno,
                      nscol->p_vartype,
                      nscol->p_vartypmod,
                      nscol->p_varcollid,
                      sublevels_up);
        /* makeVar doesn't offer parameters for these, so set them by hand: */
        var->varnosyn = nscol->p_varnosyn;
        var->varattnosyn = nscol->p_varattnosyn;
    }
    else
    {
        /* System column, so use predetermined type data */
        const FormData_pg_attribute *sysatt;
 
        sysatt = SystemAttributeDefinition(attnum);
        var = makeVar(nsitem->p_rtindex,
                      attnum,
                      sysatt->atttypid,
                      sysatt->atttypmod,
                      sysatt->attcollation,
                      sublevels_up);
    }
    var->location = location;
 
    /* Mark Var for RETURNING OLD/NEW, as necessary */
    var->varreturningtype = nsitem->p_returning_type;
 
    /* Mark Var if it's nulled by any outer joins */
    markNullableIfNeeded(pstate, var);
 
    /* Require read access to the column */
    markVarForSelectPriv(pstate, var);
 
    return (Node *) var;
}

References Alias::aliasname, attnum, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_CHECK_CONSTRAINT, EXPR_KIND_GENERATED_COLUMN, EXPR_KIND_MERGE_WHEN, FormData_pg_attribute, InvalidAttrNumber, Var::location, makeVar(), markNullableIfNeeded(), markVarForSelectPriv(), ParseState::p_expr_kind, ParseNamespaceItem::p_names, ParseNamespaceItem::p_nscolumns, ParseNamespaceItem::p_returning_type, ParseNamespaceItem::p_rte, ParseNamespaceItem::p_rtindex, ParseNamespaceColumn::p_varattno, ParseNamespaceColumn::p_varattnosyn, ParseNamespaceColumn::p_varcollid, ParseNamespaceColumn::p_varno, ParseNamespaceColumn::p_varnosyn, ParseNamespaceColumn::p_vartype, ParseNamespaceColumn::p_vartypmod, parser_errposition(), scanRTEForColumn(), SystemAttributeDefinition(), TableOidAttributeNumber, and Var::varreturningtype.

Referenced by colNameToVar(), ParseComplexProjection(), and transformColumnRef().

◆ scanRTEForColumn()

static int scanRTEForColumn	(	ParseState *	pstate,
		RangeTblEntry *	rte,
		Alias *	eref,
		const char *	colname,
		int	location,
		int	fuzzy_rte_penalty,
		FuzzyAttrMatchState *	fuzzystate
	)

static

Definition at line 815 of file parse_relation.c.

{
    int         result = InvalidAttrNumber;
    int         attnum = 0;
    ListCell   *c;
 
    /*
     * Scan the user column names (or aliases) for a match. Complain if
     * multiple matches.
     *
     * Note: eref->colnames may include entries for dropped columns, but those
     * will be empty strings that cannot match any legal SQL identifier, so we
     * don't bother to test for that case here.
     *
     * Should this somehow go wrong and we try to access a dropped column,
     * we'll still catch it by virtue of the check in scanNSItemForColumn().
     * Callers interested in finding match with shortest distance need to
     * defend against this directly, though.
     */
    foreach(c, eref->colnames)
    {
        const char *attcolname = strVal(lfirst(c));
 
        attnum++;
        if (strcmp(attcolname, colname) == 0)
        {
            if (result)
                ereport(ERROR,
                        (errcode(ERRCODE_AMBIGUOUS_COLUMN),
                         errmsg("column reference \"%s\" is ambiguous",
                                colname),
                         parser_errposition(pstate, location)));
            result = attnum;
        }
 
        /* Update fuzzy match state, if provided. */
        if (fuzzystate != NULL)
            updateFuzzyAttrMatchState(fuzzy_rte_penalty, fuzzystate,
                                      rte, attcolname, colname, attnum);
    }
 
    /*
     * If we have a unique match, return it.  Note that this allows a user
     * alias to override a system column name (such as OID) without error.
     */
    if (result)
        return result;
 
    /*
     * If the RTE represents a real relation, consider system column names.
     * Composites are only used for pseudo-relations like ON CONFLICT's
     * excluded.
     */
    if (rte->rtekind == RTE_RELATION &&
        rte->relkind != RELKIND_COMPOSITE_TYPE)
    {
        /* quick check to see if name could be a system column */
        attnum = specialAttNum(colname);
        if (attnum != InvalidAttrNumber)
        {
            /* now check to see if column actually is defined */
            if (SearchSysCacheExists2(ATTNUM,
                                      ObjectIdGetDatum(rte->relid),
                                      Int16GetDatum(attnum)))
                result = attnum;
        }
    }
 
    return result;
}

References attnum, Alias::colnames, ereport, errcode(), errmsg(), ERROR, Int16GetDatum(), InvalidAttrNumber, lfirst, ObjectIdGetDatum(), parser_errposition(), RTE_RELATION, RangeTblEntry::rtekind, SearchSysCacheExists2, specialAttNum(), strVal, and updateFuzzyAttrMatchState().

Referenced by scanNSItemForColumn(), and searchRangeTableForCol().

◆ searchRangeTableForCol()

static FuzzyAttrMatchState * searchRangeTableForCol	(	ParseState *	pstate,
		const char *	alias,
		const char *	colname,
		int	location
	)

static

Definition at line 967 of file parse_relation.c.

{
    ParseState *orig_pstate = pstate;
    FuzzyAttrMatchState *fuzzystate = palloc(sizeof(FuzzyAttrMatchState));
 
    fuzzystate->distance = MAX_FUZZY_DISTANCE + 1;
    fuzzystate->rfirst = NULL;
    fuzzystate->rsecond = NULL;
    fuzzystate->rexact1 = NULL;
    fuzzystate->rexact2 = NULL;
 
    while (pstate != NULL)
    {
        ListCell   *l;
 
        foreach(l, pstate->p_rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
            int         fuzzy_rte_penalty = 0;
            int         attnum;
 
            /*
             * Typically, it is not useful to look for matches within join
             * RTEs; they effectively duplicate other RTEs for our purposes,
             * and if a match is chosen from a join RTE, an unhelpful alias is
             * displayed in the final diagnostic message.
             */
            if (rte->rtekind == RTE_JOIN)
                continue;
 
            /*
             * If the user didn't specify an alias, then matches against one
             * RTE are as good as another.  But if the user did specify an
             * alias, then we want at least a fuzzy - and preferably an exact
             * - match for the range table entry.
             */
            if (alias != NULL)
                fuzzy_rte_penalty =
                    varstr_levenshtein_less_equal(alias, strlen(alias),
                                                  rte->eref->aliasname,
                                                  strlen(rte->eref->aliasname),
                                                  1, 1, 1,
                                                  MAX_FUZZY_DISTANCE + 1,
                                                  true);
 
            /*
             * Scan for a matching column, and update fuzzystate.  Non-exact
             * matches are dealt with inside scanRTEForColumn, but exact
             * matches are handled here.  (There won't be more than one exact
             * match in the same RTE, else we'd have thrown error earlier.)
             */
            attnum = scanRTEForColumn(orig_pstate, rte, rte->eref,
                                      colname, location,
                                      fuzzy_rte_penalty, fuzzystate);
            if (attnum != InvalidAttrNumber && fuzzy_rte_penalty == 0)
            {
                if (fuzzystate->rexact1 == NULL)
                {
                    fuzzystate->rexact1 = rte;
                    fuzzystate->exact1 = attnum;
                }
                else
                {
                    /* Needn't worry about overwriting previous rexact2 */
                    fuzzystate->rexact2 = rte;
                    fuzzystate->exact2 = attnum;
                }
            }
        }
 
        pstate = pstate->parentParseState;
    }
 
    return fuzzystate;
}

References attnum, FuzzyAttrMatchState::distance, FuzzyAttrMatchState::exact1, FuzzyAttrMatchState::exact2, InvalidAttrNumber, lfirst, MAX_FUZZY_DISTANCE, ParseState::p_rtable, palloc(), ParseState::parentParseState, FuzzyAttrMatchState::rexact1, FuzzyAttrMatchState::rexact2, FuzzyAttrMatchState::rfirst, FuzzyAttrMatchState::rsecond, RTE_JOIN, RangeTblEntry::rtekind, scanRTEForColumn(), and varstr_levenshtein_less_equal().

Referenced by errorMissingColumn().

◆ searchRangeTableForRel()

static RangeTblEntry * searchRangeTableForRel	(	ParseState *	pstate,
		RangeVar *	relation
	)

static

Definition at line 364 of file parse_relation.c.

{
    const char *refname = relation->relname;
    Oid         relId = InvalidOid;
    CommonTableExpr *cte = NULL;
    bool        isenr = false;
    Index       ctelevelsup = 0;
    Index       levelsup;
 
    /*
     * If it's an unqualified name, check for possible CTE matches. A CTE
     * hides any real relation matches.  If no CTE, look for a matching
     * relation.
     *
     * NB: It's not critical that RangeVarGetRelid return the correct answer
     * here in the face of concurrent DDL.  If it doesn't, the worst case
     * scenario is a less-clear error message.  Also, the tables involved in
     * the query are already locked, which reduces the number of cases in
     * which surprising behavior can occur.  So we do the name lookup
     * unlocked.
     */
    if (!relation->schemaname)
    {
        cte = scanNameSpaceForCTE(pstate, refname, &ctelevelsup);
        if (!cte)
            isenr = scanNameSpaceForENR(pstate, refname);
    }
 
    if (!cte && !isenr)
        relId = RangeVarGetRelid(relation, NoLock, true);
 
    /* Now look for RTEs matching either the relation/CTE/ENR or the alias */
    for (levelsup = 0;
         pstate != NULL;
         pstate = pstate->parentParseState, levelsup++)
    {
        ListCell   *l;
 
        foreach(l, pstate->p_rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
 
            if (rte->rtekind == RTE_RELATION &&
                OidIsValid(relId) &&
                rte->relid == relId)
                return rte;
            if (rte->rtekind == RTE_CTE &&
                cte != NULL &&
                rte->ctelevelsup + levelsup == ctelevelsup &&
                strcmp(rte->ctename, refname) == 0)
                return rte;
            if (rte->rtekind == RTE_NAMEDTUPLESTORE &&
                isenr &&
                strcmp(rte->enrname, refname) == 0)
                return rte;
            if (strcmp(rte->eref->aliasname, refname) == 0)
                return rte;
        }
    }
    return NULL;
}

References RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, RangeTblEntry::enrname, InvalidOid, lfirst, NoLock, OidIsValid, ParseState::p_rtable, ParseState::parentParseState, RangeVarGetRelid, RangeVar::relname, RTE_CTE, RTE_NAMEDTUPLESTORE, RTE_RELATION, RangeTblEntry::rtekind, scanNameSpaceForCTE(), scanNameSpaceForENR(), and RangeVar::schemaname.

Referenced by errorMissingRTE().

◆ specialAttNum()

static int specialAttNum ( const char * attname )

static

Definition at line 3620 of file parse_relation.c.

{
    const FormData_pg_attribute *sysatt;
 
    sysatt = SystemAttributeByName(attname);
    if (sysatt != NULL)
        return sysatt->attnum;
    return InvalidAttrNumber;
}

References attname, FormData_pg_attribute, InvalidAttrNumber, and SystemAttributeByName().

Referenced by attnameAttNum(), and scanRTEForColumn().

◆ updateFuzzyAttrMatchState()

static void updateFuzzyAttrMatchState	(	int	fuzzy_rte_penalty,
		FuzzyAttrMatchState *	fuzzystate,
		RangeTblEntry *	rte,
		const char *	actual,
		const char *	match,
		int	attnum
	)

static

Definition at line 595 of file parse_relation.c.

{
    int         columndistance;
    int         matchlen;
 
    /* Bail before computing the Levenshtein distance if there's no hope. */
    if (fuzzy_rte_penalty > fuzzystate->distance)
        return;
 
    /*
     * Outright reject dropped columns, which can appear here with apparent
     * empty actual names, per remarks within scanRTEForColumn().
     */
    if (actual[0] == '\0')
        return;
 
    /* Use Levenshtein to compute match distance. */
    matchlen = strlen(match);
    columndistance =
        varstr_levenshtein_less_equal(actual, strlen(actual), match, matchlen,
                                      1, 1, 1,
                                      fuzzystate->distance + 1
                                      - fuzzy_rte_penalty,
                                      true);
 
    /*
     * If more than half the characters are different, don't treat it as a
     * match, to avoid making ridiculous suggestions.
     */
    if (columndistance > matchlen / 2)
        return;
 
    /*
     * From this point on, we can ignore the distinction between the RTE-name
     * distance and the column-name distance.
     */
    columndistance += fuzzy_rte_penalty;
 
    /*
     * If the new distance is less than or equal to that of the best match
     * found so far, update fuzzystate.
     */
    if (columndistance < fuzzystate->distance)
    {
        /* Store new lowest observed distance as first/only match */
        fuzzystate->distance = columndistance;
        fuzzystate->rfirst = rte;
        fuzzystate->first = attnum;
        fuzzystate->rsecond = NULL;
    }
    else if (columndistance == fuzzystate->distance)
    {
        /* If we already have a match of this distance, update state */
        if (fuzzystate->rsecond != NULL)
        {
            /*
             * Too many matches at same distance.  Clearly, this value of
             * distance is too low a bar, so drop these entries while keeping
             * the current distance value, so that only smaller distances will
             * be considered interesting.  Only if we find something of lower
             * distance will we re-populate rfirst (via the stanza above).
             */
            fuzzystate->rfirst = NULL;
            fuzzystate->rsecond = NULL;
        }
        else if (fuzzystate->rfirst != NULL)
        {
            /* Record as provisional second match */
            fuzzystate->rsecond = rte;
            fuzzystate->second = attnum;
        }
        else
        {
            /*
             * Do nothing.  When rfirst is NULL, distance is more than what we
             * want to consider acceptable, so we should ignore this match.
             */
        }
    }
}

References attnum, FuzzyAttrMatchState::distance, FuzzyAttrMatchState::first, FuzzyAttrMatchState::rfirst, FuzzyAttrMatchState::rsecond, FuzzyAttrMatchState::second, and varstr_levenshtein_less_equal().

Referenced by scanRTEForColumn().

Data Structures

Macros

Functions

Macro Definition Documentation

◆ MAX_FUZZY_DISTANCE

Function Documentation

◆ addNSItemToQuery()

◆ addRangeTableEntry()

◆ addRangeTableEntryForCTE()

◆ addRangeTableEntryForENR()

◆ addRangeTableEntryForFunction()

◆ addRangeTableEntryForGroup()

◆ addRangeTableEntryForJoin()

◆ addRangeTableEntryForRelation()

◆ addRangeTableEntryForSubquery()

◆ addRangeTableEntryForTableFunc()

◆ addRangeTableEntryForValues()

◆ addRTEPermissionInfo()

◆ attnameAttNum()

◆ attnumAttName()

◆ attnumCollationId()

◆ attnumTypeId()

◆ buildNSItemFromLists()

◆ buildNSItemFromTupleDesc()

◆ buildRelationAliases()

◆ check_lateral_ref_ok()

◆ checkNameSpaceConflicts()

◆ chooseScalarFunctionAlias()

◆ colNameToVar()

◆ errorMissingColumn()

◆ errorMissingRTE()

◆ expandNSItemAttrs()

◆ expandNSItemVars()

◆ expandRelation()

◆ expandRTE()

◆ expandTupleDesc()

◆ findNSItemForRTE()

◆ get_parse_rowmark()

◆ get_rte_attribute_is_dropped()

◆ get_rte_attribute_name()

◆ get_tle_by_resno()

◆ GetCTEForRTE()

◆ GetNSItemByRangeTablePosn()

◆ GetRTEByRangeTablePosn()

◆ getRTEPermissionInfo()

◆ isFutureCTE()

◆ isLockedRefname()

◆ isQueryUsingTempRelation()

◆ isQueryUsingTempRelation_walker()

◆ markNullableIfNeeded()

◆ markRTEForSelectPriv()

◆ markVarForSelectPriv()

◆ parserOpenTable()

◆ refnameNamespaceItem()

◆ rte_visible_if_lateral()

◆ rte_visible_if_qualified()

◆ scanNameSpaceForCTE()

◆ scanNameSpaceForENR()

◆ scanNameSpaceForRefname()

◆ scanNameSpaceForRelid()

◆ scanNSItemForColumn()

◆ scanRTEForColumn()

◆ searchRangeTableForCol()

◆ searchRangeTableForRel()

◆ specialAttNum()

◆ updateFuzzyAttrMatchState()