#include "nodes/parsenodes.h"

Include dependency graph for parsetree.h:

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

Macros
#define	rt_fetch(rangetable_index, rangetable) ((RangeTblEntry *) list_nth(rangetable, (rangetable_index)-1))

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

Macro Definition Documentation

◆ rt_fetch

#define rt_fetch	(	rangetable_index,
		rangetable
	)	((RangeTblEntry *) list_nth(rangetable, (rangetable_index)-1))

Definition at line 31 of file parsetree.h.

Function Documentation

◆ get_parse_rowmark()

RowMarkClause* get_parse_rowmark	(	Query *	qry,
		Index	rtindex
	)

Definition at line 3459 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 3291 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:
  
             /*
              * Subselect, Table Functions, Values, CTE 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(), RangeTblEntry::relid, RTE_CTE, RTE_FUNCTION, 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 3253 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(), RangeTblEntry::relid, RTE_RELATION, RangeTblEntry::rtekind, and strVal.

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

◆ get_tle_by_resno()

TargetEntry* get_tle_by_resno	(	List *	tlist,
		AttrNumber	resno
	)

Definition at line 3439 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(), pullup_replace_vars_callback(), ReplaceVarsFromTargetList_callback(), resolve_special_varno(), rewriteTargetView(), show_grouping_set_keys(), and show_sort_group_keys().

Macros