foreach(lc, rtable)
{
- RangeTblEntry *rte = castNode(RangeTblEntry, lfirst(lc));
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
APP_JUMB(rte->rtekind);
switch (rte->rtekind)
JumbleExpr(jstate, (Node *) caseexpr->arg);
foreach(temp, caseexpr->args)
{
- CaseWhen *when = castNode(CaseWhen, lfirst(temp));
+ CaseWhen *when = lfirst_node(CaseWhen, temp);
JumbleExpr(jstate, (Node *) when->expr);
JumbleExpr(jstate, (Node *) when->result);
foreach(lc, tlist)
{
- TargetEntry *tle = castNode(TargetEntry, lfirst(lc));
+ TargetEntry *tle = lfirst_node(TargetEntry, lc);
if (i > 0)
appendStringInfoString(buf, ", ");
*/
foreach(lc, scan_clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
/* Ignore any pseudoconstants, they're dealt with elsewhere */
if (rinfo->pseudoconstant)
EState *estate = fsstate->ss.ps.state;
TargetEntry *tle;
- tle = castNode(TargetEntry, list_nth(fsplan->fdw_scan_tlist,
- errpos->cur_attno - 1));
+ tle = list_nth_node(TargetEntry, fsplan->fdw_scan_tlist,
+ errpos->cur_attno - 1);
/*
* Target list can have Vars and expressions. For Vars, we can get
objlist = castNode(List, object);
domaddr = get_object_address_type(OBJECT_DOMAIN,
- castNode(TypeName, linitial(objlist)),
+ linitial_node(TypeName, objlist),
missing_ok);
constrname = strVal(lsecond(objlist));
break;
case OBJECT_CAST:
{
- TypeName *sourcetype = castNode(TypeName, linitial(castNode(List, object)));
- TypeName *targettype = castNode(TypeName, lsecond(castNode(List, object)));
+ TypeName *sourcetype = linitial_node(TypeName, castNode(List, object));
+ TypeName *targettype = lsecond_node(TypeName, castNode(List, object));
Oid sourcetypeid;
Oid targettypeid;
break;
case OBJECT_TRANSFORM:
{
- TypeName *typename = castNode(TypeName, linitial(castNode(List, object)));
+ TypeName *typename = linitial_node(TypeName, castNode(List, object));
char *langname = strVal(lsecond(castNode(List, object)));
Oid type_id = LookupTypeNameOid(NULL, typename, missing_ok);
Oid lang_id = get_language_oid(langname, missing_ok);
{
ObjectAddress typaddr;
- typenames[i] = castNode(TypeName, lfirst(cell));
+ typenames[i] = lfirst_node(TypeName, cell);
typaddr = get_object_address_type(OBJECT_TYPE, typenames[i], missing_ok);
typeoids[i] = typaddr.objectId;
if (++i >= 2)
case OBJECT_CAST:
{
/* We can only check permissions on the source/target types */
- TypeName *sourcetype = castNode(TypeName, linitial(castNode(List, object)));
- TypeName *targettype = castNode(TypeName, lsecond(castNode(List, object)));
+ TypeName *sourcetype = linitial_node(TypeName, castNode(List, object));
+ TypeName *targettype = lsecond_node(TypeName, castNode(List, object));
Oid sourcetypeid = typenameTypeId(NULL, sourcetype);
Oid targettypeid = typenameTypeId(NULL, targettype);
break;
case OBJECT_TRANSFORM:
{
- TypeName *typename = castNode(TypeName, linitial(castNode(List, object)));
+ TypeName *typename = linitial_node(TypeName, castNode(List, object));
Oid typeid = typenameTypeId(NULL, typename);
if (!pg_type_ownercheck(typeid, roleid))
querytree_list = NIL;
foreach(lc, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(lc));
+ RawStmt *parsetree = lfirst_node(RawStmt, lc);
List *querytree_sublist;
querytree_sublist = pg_analyze_and_rewrite_params(parsetree,
aggKind = AGGKIND_ORDERED_SET;
else
numDirectArgs = 0;
- args = castNode(List, linitial(args));
+ args = linitial_node(List, args);
}
/* Examine aggregate's definition clauses */
foreach(pl, parameters)
{
- DefElem *defel = castNode(DefElem, lfirst(pl));
+ DefElem *defel = lfirst_node(DefElem, pl);
/*
* sfunc1, stype1, and initcond1 are accepted as obsolete spellings
List *parentPendingActions;
List *parentPendingNotifies;
- parentPendingActions = castNode(List, linitial(upperPendingActions));
+ parentPendingActions = linitial_node(List, upperPendingActions);
upperPendingActions = list_delete_first(upperPendingActions);
Assert(list_length(upperPendingActions) ==
*/
pendingActions = list_concat(parentPendingActions, pendingActions);
- parentPendingNotifies = castNode(List, linitial(upperPendingNotifies));
+ parentPendingNotifies = linitial_node(List, upperPendingNotifies);
upperPendingNotifies = list_delete_first(upperPendingNotifies);
Assert(list_length(upperPendingNotifies) ==
*/
while (list_length(upperPendingActions) > my_level - 2)
{
- pendingActions = castNode(List, linitial(upperPendingActions));
+ pendingActions = linitial_node(List, upperPendingActions);
upperPendingActions = list_delete_first(upperPendingActions);
}
while (list_length(upperPendingNotifies) > my_level - 2)
{
- pendingNotifies = castNode(List, linitial(upperPendingNotifies));
+ pendingNotifies = linitial_node(List, upperPendingNotifies);
upperPendingNotifies = list_delete_first(upperPendingNotifies);
}
}
foreach(pl, parameters)
{
- DefElem *defel = castNode(DefElem, lfirst(pl));
+ DefElem *defel = lfirst_node(DefElem, pl);
DefElem **defelp;
if (pg_strcasecmp(defel->defname, "from") == 0)
/* Extract options from the statement node tree */
foreach(option, options)
{
- DefElem *defel = castNode(DefElem, lfirst(option));
+ DefElem *defel = lfirst_node(DefElem, option);
if (strcmp(defel->defname, "format") == 0)
{
/* examine queries to determine which error message to issue */
foreach(lc, rewritten)
{
- Query *q = castNode(Query, lfirst(lc));
+ Query *q = lfirst_node(Query, lc);
if (q->querySource == QSRC_QUAL_INSTEAD_RULE)
ereport(ERROR,
errmsg("multi-statement DO INSTEAD rules are not supported for COPY")));
}
- query = castNode(Query, linitial(rewritten));
+ query = linitial_node(Query, rewritten);
/* The grammar allows SELECT INTO, but we don't support that */
if (query->utilityStmt != NULL &&
elog(ERROR, "unexpected rewrite result for %s",
is_matview ? "CREATE MATERIALIZED VIEW" :
"CREATE TABLE AS SELECT");
- query = castNode(Query, linitial(rewritten));
+ query = linitial_node(Query, rewritten);
Assert(query->commandType == CMD_SELECT);
/* plan the query --- note we disallow parallelism */
foreach(l, typenames)
{
- TypeName *typeName = castNode(TypeName, lfirst(l));
+ TypeName *typeName = lfirst_node(TypeName, l);
if (typeName != NULL)
{
{
/* XXX quote or no quote? */
msg = gettext_noop("cast from type %s to type %s does not exist, skipping");
- name = TypeNameToString(castNode(TypeName, linitial(castNode(List, object))));
- args = TypeNameToString(castNode(TypeName, lsecond(castNode(List, object))));
+ name = TypeNameToString(linitial_node(TypeName, castNode(List, object)));
+ args = TypeNameToString(lsecond_node(TypeName, castNode(List, object)));
}
}
break;
if (!type_in_list_does_not_exist_skipping(list_make1(linitial(castNode(List, object))), &msg, &name))
{
msg = gettext_noop("transform for type %s language \"%s\" does not exist, skipping");
- name = TypeNameToString(castNode(TypeName, linitial(castNode(List, object))));
+ name = TypeNameToString(linitial_node(TypeName, castNode(List, object)));
args = strVal(lsecond(castNode(List, object)));
}
break;
/* Explain every plan */
foreach(l, rewritten)
{
- ExplainOneQuery(castNode(Query, lfirst(l)),
+ ExplainOneQuery(lfirst_node(Query, l),
CURSOR_OPT_PARALLEL_OK, NULL, es,
queryString, params, queryEnv);
rewritten = QueryRewrite(castNode(Query, copyObject(ctas->query)));
Assert(list_length(rewritten) == 1);
- ExplainOneQuery(castNode(Query, linitial(rewritten)),
+ ExplainOneQuery(linitial_node(Query, rewritten),
0, ctas->into, es,
queryString, params, queryEnv);
}
rewritten = QueryRewrite(castNode(Query, copyObject(dcs->query)));
Assert(list_length(rewritten) == 1);
- ExplainOneQuery(castNode(Query, linitial(rewritten)),
+ ExplainOneQuery(linitial_node(Query, rewritten),
dcs->options, NULL, es,
queryString, params, queryEnv);
}
*/
foreach(lc1, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(lc1));
+ RawStmt *parsetree = lfirst_node(RawStmt, lc1);
List *stmt_list;
ListCell *lc2;
foreach(lc2, stmt_list)
{
- PlannedStmt *stmt = castNode(PlannedStmt, lfirst(lc2));
+ PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2);
CommandCounterIncrement();
*/
foreach(lc2, raw_parsetree_list)
{
- RawStmt *rs = castNode(RawStmt, lfirst(lc2));
+ RawStmt *rs = lfirst_node(RawStmt, lc2);
CreateForeignTableStmt *cstmt = (CreateForeignTableStmt *) rs->stmt;
PlannedStmt *pstmt;
foreach(l, set_items)
{
- VariableSetStmt *sstmt = castNode(VariableSetStmt, lfirst(l));
+ VariableSetStmt *sstmt = lfirst_node(VariableSetStmt, l);
if (sstmt->kind == VAR_RESET_ALL)
a = NULL;
foreach(lc, castNode(List, transformDefElem))
{
- Oid typeid = typenameTypeId(NULL, lfirst(lc));
+ Oid typeid = typenameTypeId(NULL,
+ lfirst_node(TypeName, lc));
Oid elt = get_base_element_type(typeid);
typeid = elt ? elt : typeid;
* The stored query was rewritten at the time of the MV definition, but
* has not been scribbled on by the planner.
*/
- dataQuery = castNode(Query, linitial(actions));
+ dataQuery = linitial_node(Query, actions);
/*
* Check for active uses of the relation in the current transaction, such
*/
foreach(l, stmt->items)
{
- CreateOpClassItem *item = castNode(CreateOpClassItem, lfirst(l));
+ CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
Oid operOid;
Oid funcOid;
Oid sortfamilyOid;
*/
foreach(l, items)
{
- CreateOpClassItem *item = castNode(CreateOpClassItem, lfirst(l));
+ CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
Oid operOid;
Oid funcOid;
Oid sortfamilyOid;
*/
foreach(l, items)
{
- CreateOpClassItem *item = castNode(CreateOpClassItem, lfirst(l));
+ CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
Oid lefttype,
righttype;
OpFamilyMember *member;
if (list_length(rewritten) != 1)
elog(ERROR, "non-SELECT statement in DECLARE CURSOR");
- query = castNode(Query, linitial(rewritten));
+ query = linitial_node(Query, rewritten);
if (query->commandType != CMD_SELECT)
elog(ERROR, "non-SELECT statement in DECLARE CURSOR");
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("prepared statement is not a SELECT")));
- pstmt = castNode(PlannedStmt, linitial(plan_list));
+ pstmt = linitial_node(PlannedStmt, plan_list);
if (pstmt->commandType != CMD_SELECT)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
/* Explain each query */
foreach(p, plan_list)
{
- PlannedStmt *pstmt = castNode(PlannedStmt, lfirst(p));
+ PlannedStmt *pstmt = lfirst_node(PlannedStmt, p);
if (pstmt->commandType != CMD_UTILITY)
ExplainOnePlan(pstmt, into, es, query_string, paramLI, queryEnv,
foreach(option, castNode(List, def))
{
- DefElem *defel = castNode(DefElem, lfirst(option));
+ DefElem *defel = lfirst_node(DefElem, option);
if (strcmp(defel->defname, "generated") == 0)
{
querytree_list = NIL;
foreach(list_item, raw_parsetree_list)
{
- RawStmt *rs = castNode(RawStmt, lfirst(list_item));
+ RawStmt *rs = lfirst_node(RawStmt, list_item);
Node *stmt = rs->stmt;
if (IsA(stmt, IndexStmt))
foreach(lc, varList)
{
- TriggerTransition *tt = castNode(TriggerTransition, lfirst(lc));
+ TriggerTransition *tt = lfirst_node(TriggerTransition, lc);
if (!(tt->isTable))
ereport(ERROR,
foreach(l, memberNames)
{
- RoleSpec *rolespec = castNode(RoleSpec, lfirst(l));
+ RoleSpec *rolespec = lfirst_node(RoleSpec, l);
Oid roleid;
roleid = get_rolespec_oid(rolespec, false);
foreach(targetList, viewParse->targetList)
{
- TargetEntry *te = castNode(TargetEntry, lfirst(targetList));
+ TargetEntry *te = lfirst_node(TargetEntry, targetList);
/* junk columns don't get aliases */
if (te->resjunk)
/* Now compile each tlist column */
foreach(lc, targetList)
{
- TargetEntry *tle = castNode(TargetEntry, lfirst(lc));
+ TargetEntry *tle = lfirst_node(TargetEntry, lc);
Var *variable = NULL;
AttrNumber attnum = 0;
bool isSafeVar = false;
foreach(lc, tupleTable)
{
- TupleTableSlot *slot = castNode(TupleTableSlot, lfirst(lc));
+ TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
/* Always release resources and reset the slot to empty */
ExecClearTuple(slot);
foreach(tl, targetlist)
{
- TargetEntry *curTle = castNode(TargetEntry, lfirst(tl));
+ TargetEntry *curTle = lfirst_node(TargetEntry, tl);
if (!curTle->resjunk)
len++;
foreach(lc1, queryTree_list)
{
- List *qtlist = castNode(List, lfirst(lc1));
+ List *qtlist = lfirst_node(List, lc1);
execution_state *firstes = NULL;
execution_state *preves = NULL;
ListCell *lc2;
foreach(lc2, qtlist)
{
- Query *queryTree = castNode(Query, lfirst(lc2));
+ Query *queryTree = lfirst_node(Query, lc2);
PlannedStmt *stmt;
execution_state *newes;
flat_query_list = NIL;
foreach(lc, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(lc));
+ RawStmt *parsetree = lfirst_node(RawStmt, lc);
List *queryTree_sublist;
queryTree_sublist = pg_analyze_and_rewrite_params(parsetree,
parse = NULL;
foreach(lc, queryTreeList)
{
- Query *q = castNode(Query, lfirst(lc));
+ Query *q = lfirst_node(Query, lc);
if (q->canSetTag)
parse = q;
if (phaseidx > 0)
{
- aggnode = castNode(Agg, list_nth(node->chain, phaseidx - 1));
+ aggnode = list_nth_node(Agg, node->chain, phaseidx - 1);
sortnode = castNode(Sort, aggnode->plan.lefttree);
}
else
*/
foreach(arg, pertrans->aggref->args)
{
- TargetEntry *source_tle = castNode(TargetEntry, lfirst(arg));
+ TargetEntry *source_tle = lfirst_node(TargetEntry, arg);
TargetEntry *tle;
tle = flatCopyTargetEntry(source_tle);
hoperators = NIL;
foreach(l, node->hashclauses)
{
- OpExpr *hclause = castNode(OpExpr, lfirst(l));
+ OpExpr *hclause = lfirst_node(OpExpr, l);
lclauses = lappend(lclauses, ExecInitExpr(linitial(hclause->args),
(PlanState *) hjstate));
epq_arowmarks = NIL;
foreach(lc, node->rowMarks)
{
- PlanRowMark *rc = castNode(PlanRowMark, lfirst(lc));
+ PlanRowMark *rc = lfirst_node(PlanRowMark, lc);
ExecRowMark *erm;
ExecAuxRowMark *aerm;
*/
foreach(l, node->rowMarks)
{
- PlanRowMark *rc = castNode(PlanRowMark, lfirst(l));
+ PlanRowMark *rc = lfirst_node(PlanRowMark, l);
ExecRowMark *erm;
/* ignore "parent" rowmarks; they are irrelevant at runtime */
i = 1;
foreach(l, oplist)
{
- OpExpr *opexpr = castNode(OpExpr, lfirst(l));
+ OpExpr *opexpr = lfirst_node(OpExpr, l);
Expr *expr;
TargetEntry *tle;
Oid rhs_eq_oper;
*/
foreach(lc, asplan->subplans)
{
- SubPlan *sp = castNode(SubPlan, lfirst(lc));
+ SubPlan *sp = lfirst_node(SubPlan, lc);
SubPlanState *sps = ExecInitSubPlan(sp, parent);
asstate->subplans = lappend(asstate->subplans, sps);
bool *isNull)
{
/* Just pass control to the active subplan */
- SubPlanState *activesp = castNode(SubPlanState,
- list_nth(node->subplans, node->active));
+ SubPlanState *activesp = list_nth_node(SubPlanState,
+ node->subplans, node->active);
return ExecSubPlan(activesp, econtext, isNull);
}
if (!(portal->cursorOptions & (CURSOR_OPT_SCROLL | CURSOR_OPT_NO_SCROLL)))
{
if (list_length(stmt_list) == 1 &&
- castNode(PlannedStmt, linitial(stmt_list))->commandType != CMD_UTILITY &&
- castNode(PlannedStmt, linitial(stmt_list))->rowMarks == NIL &&
- ExecSupportsBackwardScan(castNode(PlannedStmt, linitial(stmt_list))->planTree))
+ linitial_node(PlannedStmt, stmt_list)->commandType != CMD_UTILITY &&
+ linitial_node(PlannedStmt, stmt_list)->rowMarks == NIL &&
+ ExecSupportsBackwardScan(linitial_node(PlannedStmt, stmt_list)->planTree))
portal->cursorOptions |= CURSOR_OPT_SCROLL;
else
portal->cursorOptions |= CURSOR_OPT_NO_SCROLL;
if (portal->cursorOptions & CURSOR_OPT_SCROLL)
{
if (list_length(stmt_list) == 1 &&
- castNode(PlannedStmt, linitial(stmt_list))->commandType != CMD_UTILITY &&
- castNode(PlannedStmt, linitial(stmt_list))->rowMarks != NIL)
+ linitial_node(PlannedStmt, stmt_list)->commandType != CMD_UTILITY &&
+ linitial_node(PlannedStmt, stmt_list)->rowMarks != NIL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE is not supported"),
foreach(lc, stmt_list)
{
- PlannedStmt *pstmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *pstmt = lfirst_node(PlannedStmt, lc);
if (!CommandIsReadOnly(pstmt))
{
foreach(list_item, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(list_item));
+ RawStmt *parsetree = lfirst_node(RawStmt, list_item);
List *stmt_list;
CachedPlanSource *plansource;
foreach(list_item, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(list_item));
+ RawStmt *parsetree = lfirst_node(RawStmt, list_item);
CachedPlanSource *plansource;
plansource = CreateOneShotCachedPlan(parsetree,
foreach(lc2, stmt_list)
{
- PlannedStmt *stmt = castNode(PlannedStmt, lfirst(lc2));
+ PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2);
bool canSetTag = stmt->canSetTag;
DestReceiver *dest;
if (!qtree || !IsA(qtree, Query))
elog(ERROR, "cannot get type for untransformed sublink");
- tent = castNode(TargetEntry, linitial(qtree->targetList));
+ tent = linitial_node(TargetEntry, qtree->targetList);
Assert(!tent->resjunk);
type = exprType((Node *) tent->expr);
if (sublink->subLinkType == ARRAY_SUBLINK)
if (!qtree || !IsA(qtree, Query))
elog(ERROR, "cannot get type for untransformed sublink");
- tent = castNode(TargetEntry, linitial(qtree->targetList));
+ tent = linitial_node(TargetEntry, qtree->targetList);
Assert(!tent->resjunk);
return exprTypmod((Node *) tent->expr);
/* note we don't need to care if it's an array */
return -1; /* no point in trying harder */
foreach(arg, cexpr->args)
{
- CaseWhen *w = castNode(CaseWhen, lfirst(arg));
+ CaseWhen *w = lfirst_node(CaseWhen, arg);
if (exprType((Node *) w->result) != casetype)
return -1;
if (!qtree || !IsA(qtree, Query))
elog(ERROR, "cannot get collation for untransformed sublink");
- tent = castNode(TargetEntry, linitial(qtree->targetList));
+ tent = linitial_node(TargetEntry, qtree->targetList);
Assert(!tent->resjunk);
coll = exprCollation((Node *) tent->expr);
/* collation doesn't change if it's converted to array */
if (!qtree || !IsA(qtree, Query))
elog(ERROR, "cannot set collation for untransformed sublink");
- tent = castNode(TargetEntry, linitial(qtree->targetList));
+ tent = linitial_node(TargetEntry, qtree->targetList);
Assert(!tent->resjunk);
Assert(collation == exprCollation((Node *) tent->expr));
}
/* we assume walker doesn't care about CaseWhens, either */
foreach(temp, caseexpr->args)
{
- CaseWhen *when = castNode(CaseWhen, lfirst(temp));
+ CaseWhen *when = lfirst_node(CaseWhen, temp);
if (walker(when->expr, context))
return true;
/* we assume walker doesn't care about CaseWhens, either */
foreach(temp, caseexpr->args)
{
- CaseWhen *when = castNode(CaseWhen, lfirst(temp));
+ CaseWhen *when = lfirst_node(CaseWhen, temp);
if (walker(when->expr, context))
return true;
foreach(lc, plans)
{
- SubPlanState *sps = castNode(SubPlanState, lfirst(lc));
+ SubPlanState *sps = lfirst_node(SubPlanState, lc);
if (walker(sps->planstate, context))
return true;
foreach(lc, qual_clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
if (rinfo->pseudoconstant)
continue; /* we may drop pseudoconstants here */
*/
foreach(lc, windowFuncs)
{
- WindowFunc *wfunc = castNode(WindowFunc, lfirst(lc));
+ WindowFunc *wfunc = lfirst_node(WindowFunc, lc);
Cost wfunccost;
QualCost argcosts;
innerbucketsize = 1.0;
foreach(hcl, hashclauses)
{
- RestrictInfo *restrictinfo = castNode(RestrictInfo, lfirst(hcl));
+ RestrictInfo *restrictinfo = lfirst_node(RestrictInfo, hcl);
Selectivity thisbucketsize;
/*
joinquals = NIL;
foreach(l, restrictlist)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
if (!rinfo->is_pushed_down)
joinquals = lappend(joinquals, rinfo);
/* Grovel through the clauses to separate into two lists */
foreach(l, restrictlist)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
if (rinfo->is_pushed_down)
pushedquals = lappend(pushedquals, rinfo);
*/
foreach(lc, subroot->parse->targetList)
{
- TargetEntry *te = castNode(TargetEntry, lfirst(lc));
+ TargetEntry *te = lfirst_node(TargetEntry, lc);
Node *texpr = (Node *) te->expr;
int32 item_width = 0;
foreach(lc, clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
List *pathlist;
Path *bitmapqual;
ListCell *j;
foreach(lc, clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
match_clause_to_index(index, rinfo, clauseset);
}
*/
foreach(lc, restrictlist)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
if (only_pushed_down && !rinfo->is_pushed_down)
continue;
*/
foreach(l, clause_list)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
Oid op;
Var *var;
qpqual = NIL;
foreach(l, scan_clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
if (rinfo->pseudoconstant)
continue; /* we may drop pseudoconstants here */
qpqual = NIL;
foreach(l, scan_clauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
Node *clause = (Node *) rinfo->clause;
if (rinfo->pseudoconstant)
i = 0;
foreach(lc, best_path->path_mergeclauses)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
EquivalenceClass *oeclass;
EquivalenceClass *ieclass;
PathKey *opathkey;
forboth(lcc, index_path->indexquals, lci, index_path->indexqualcols)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lcc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lcc);
int indexcol = lfirst_int(lci);
Node *clause;
window_target = copy_pathtarget(window_target);
foreach(lc2, wflists->windowFuncs[wc->winref])
{
- WindowFunc *wfunc = castNode(WindowFunc, lfirst(lc2));
+ WindowFunc *wfunc = lfirst_node(WindowFunc, lc2);
add_column_to_pathtarget(window_target, (Expr *) wfunc, 0);
window_target->width += get_typavgwidth(wfunc->wintype, -1);
*/
foreach(lc, root->rowMarks)
{
- PlanRowMark *rc = castNode(PlanRowMark, lfirst(lc));
+ PlanRowMark *rc = lfirst_node(PlanRowMark, lc);
PlanRowMark *newrc;
/* flat copy is enough since all fields are scalars */
/* In cases such as EXISTS, tlist might be empty; arbitrarily use VOID */
if (plan->targetlist)
{
- TargetEntry *tent = castNode(TargetEntry, linitial(plan->targetlist));
+ TargetEntry *tent = linitial_node(TargetEntry, plan->targetlist);
if (!tent->resjunk)
{
attno = InvalidAttrNumber;
foreach(lc, translated_vars)
{
- Var *var = castNode(Var, lfirst(lc));
+ Var *var = lfirst_node(Var, lc);
attno++;
if (var == NULL) /* ignore dropped columns */
const_true_cond = false;
foreach(arg, caseexpr->args)
{
- CaseWhen *oldcasewhen = castNode(CaseWhen, lfirst(arg));
+ CaseWhen *oldcasewhen = lfirst_node(CaseWhen, arg);
Node *casecond;
Node *caseresult;
foreach(lc2, andargs)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lc2));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc2);
if (restriction_is_or_clause(rinfo))
{
foreach(l, restrictinfo_list)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
Assert(!rinfo->pseudoconstant);
foreach(l, restrictinfo_list)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
if (rinfo->pseudoconstant == pseudoconstant)
result = lappend(result, rinfo->clause);
foreach(l, restrictinfo_list)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(l));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
if (rinfo->is_pushed_down)
{
AttrNumber attr_num;
TargetEntry *tle;
- col = castNode(ResTarget, lfirst(icols));
+ col = lfirst_node(ResTarget, icols);
attr_num = (AttrNumber) lfirst_int(attnos);
tle = makeTargetEntry(expr,
Expr *expr = (Expr *) lfirst(lc);
ResTarget *col;
- col = castNode(ResTarget, lfirst(icols));
+ col = lfirst_node(ResTarget, icols);
expr = transformAssignedExpr(pstate, expr,
EXPR_KIND_INSERT_TARGET,
}
if (orig_tl == NULL)
elog(ERROR, "UPDATE target count mismatch --- internal error");
- origTarget = castNode(ResTarget, lfirst(orig_tl));
+ origTarget = lfirst_node(ResTarget, orig_tl);
attrno = attnameAttNum(pstate->p_target_relation,
origTarget->name, true);
if ($1 != NIL)
{
/* update length of previous stmt */
- updateRawStmtEnd(castNode(RawStmt, llast($1)), @2);
+ updateRawStmtEnd(llast_node(RawStmt, $1), @2);
}
if ($3 != NULL)
$$ = lappend($1, makeRawStmt($3, @2 + 1));
if (qtree->targetList == NIL)
return false;
- tent = castNode(TargetEntry, linitial(qtree->targetList));
+ tent = linitial_node(TargetEntry, qtree->targetList);
if (tent->resjunk)
return false;
foreach(lc, expr->args)
{
- CaseWhen *when = castNode(CaseWhen, lfirst(lc));
+ CaseWhen *when = lfirst_node(CaseWhen, lc);
/*
* The condition expressions mustn't affect
/* Process aggregated args, holding resjunk ones at arm's length */
foreach(lc, aggref->args)
{
- TargetEntry *tle = castNode(TargetEntry, lfirst(lc));
+ TargetEntry *tle = lfirst_node(TargetEntry, lc);
if (tle->resjunk)
assign_expr_collations(loccontext->pstate, (Node *) tle);
/* Process aggregated args appropriately */
foreach(lc, aggref->args)
{
- TargetEntry *tle = castNode(TargetEntry, lfirst(lc));
+ TargetEntry *tle = lfirst_node(TargetEntry, lc);
if (merge_sort_collations)
(void) assign_collations_walker((Node *) tle, loccontext);
resultexprs = NIL;
foreach(l, c->args)
{
- CaseWhen *w = castNode(CaseWhen, lfirst(l));
+ CaseWhen *w = lfirst_node(CaseWhen, l);
CaseWhen *neww = makeNode(CaseWhen);
Node *warg;
foreach(lc, x->named_args)
{
- ResTarget *r = castNode(ResTarget, lfirst(lc));
+ ResTarget *r = lfirst_node(ResTarget, lc);
Node *expr;
char *argname;
*/
foreach(idx, indirection)
{
- A_Indices *ai = castNode(A_Indices, lfirst(idx));
+ A_Indices *ai = lfirst_node(A_Indices, idx);
Node *subexpr;
if (isSlice)
JoinExpr *j;
if (rtindex > 0 && rtindex <= list_length(pstate->p_joinexprs))
- j = castNode(JoinExpr, list_nth(pstate->p_joinexprs, rtindex - 1));
+ j = list_nth_node(JoinExpr, pstate->p_joinexprs, rtindex - 1);
else
j = NULL;
if (j == NULL)
initStringInfo(&string);
foreach(l, typenames)
{
- TypeName *typeName = castNode(TypeName, lfirst(l));
+ TypeName *typeName = lfirst_node(TypeName, l);
if (l != list_head(typenames))
appendStringInfoChar(&string, ',');
*/
if (list_length(raw_parsetree_list) != 1)
goto fail;
- stmt = (SelectStmt *) castNode(RawStmt, linitial(raw_parsetree_list))->stmt;
+ stmt = (SelectStmt *) linitial_node(RawStmt, raw_parsetree_list)->stmt;
if (stmt == NULL ||
!IsA(stmt, SelectStmt) ||
stmt->distinctClause != NIL ||
foreach(option, seqoptions)
{
- DefElem *defel = castNode(DefElem, lfirst(option));
+ DefElem *defel = lfirst_node(DefElem, option);
if (strcmp(defel->defname, "sequence_name") == 0)
{
foreach(clist, column->constraints)
{
- Constraint *constraint = castNode(Constraint, lfirst(clist));
+ Constraint *constraint = lfirst_node(Constraint, clist);
switch (constraint->contype)
{
*/
foreach(lc, cxt->ixconstraints)
{
- Constraint *constraint = castNode(Constraint, lfirst(lc));
+ Constraint *constraint = lfirst_node(Constraint, lc);
Assert(constraint->contype == CONSTR_PRIMARY ||
constraint->contype == CONSTR_UNIQUE ||
List *opname;
Assert(list_length(pair) == 2);
- elem = castNode(IndexElem, linitial(pair));
- opname = castNode(List, lsecond(pair));
+ elem = linitial_node(IndexElem, pair);
+ opname = lsecond_node(List, pair);
index->indexParams = lappend(index->indexParams, elem);
index->excludeOpNames = lappend(index->excludeOpNames, opname);
foreach(columns, cxt->columns)
{
- column = castNode(ColumnDef, lfirst(columns));
+ column = lfirst_node(ColumnDef, columns);
if (strcmp(column->colname, key) == 0)
{
found = true;
foreach(inher, cxt->inhRelations)
{
- RangeVar *inh = castNode(RangeVar, lfirst(inher));
+ RangeVar *inh = lfirst_node(RangeVar, inher);
Relation rel;
int count;
*/
foreach(lc, castNode(List, cmd->def))
{
- DefElem *def = castNode(DefElem, lfirst(lc));
+ DefElem *def = lfirst_node(DefElem, lc);
if (strcmp(def->defname, "generated") == 0)
newdef = lappend(newdef, def);
*/
foreach(l, cxt.alist)
{
- IndexStmt *idxstmt = castNode(IndexStmt, lfirst(l));
+ IndexStmt *idxstmt = lfirst_node(IndexStmt, l);
idxstmt = transformIndexStmt(relid, idxstmt, queryString);
newcmd = makeNode(AlterTableCmd);
if (event_qual != NULL)
{
/* Find query containing OLD/NEW rtable entries */
- Query *qry = castNode(Query, linitial(action));
+ Query *qry = linitial_node(Query, action);
qry = getInsertSelectQuery(qry, NULL);
recordDependencyOnExpr(&myself, event_qual, qry->rtable,
*/
foreach(l, action)
{
- query = castNode(Query, lfirst(l));
+ query = lfirst_node(Query, l);
if (query->resultRelation == 0)
continue;
/* Don't be fooled by INSERT/SELECT */
/*
* ... the one action must be a SELECT, ...
*/
- query = castNode(Query, linitial(action));
+ query = linitial_node(Query, action);
if (!is_instead ||
query->commandType != CMD_SELECT)
ereport(ERROR,
foreach(l, action)
{
- query = castNode(Query, lfirst(l));
+ query = lfirst_node(Query, l);
if (!query->returningList)
continue;
* there should be a single base relation.
*/
Assert(list_length(viewquery->jointree->fromlist) == 1);
- rtr = castNode(RangeTblRef, linitial(viewquery->jointree->fromlist));
+ rtr = linitial_node(RangeTblRef, viewquery->jointree->fromlist);
/* Initialize the optional return values */
if (updatable_cols != NULL)
foreach(lc, targetlist)
{
- TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ TargetEntry *tle = lfirst_node(TargetEntry, lc);
Var *var;
if (tle->resjunk)
* view contains a single base relation.
*/
Assert(list_length(viewquery->jointree->fromlist) == 1);
- rtr = castNode(RangeTblRef, linitial(viewquery->jointree->fromlist));
+ rtr = linitial_node(RangeTblRef, viewquery->jointree->fromlist);
base_rt_index = rtr->rtindex;
base_rte = rt_fetch(base_rt_index, viewquery->rtable);
*/
foreach(lc1, parsetree->cteList)
{
- CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc1);
+ CommonTableExpr *cte = lfirst_node(CommonTableExpr, lc1);
Query *ctequery = castNode(Query, cte->ctequery);
List *newstuff;
if (list_length(newstuff) == 1)
{
/* Push the single Query back into the CTE node */
- ctequery = castNode(Query, linitial(newstuff));
+ ctequery = linitial_node(Query, newstuff);
/* WITH queries should never be canSetTag */
Assert(!ctequery->canSetTag);
cte->ctequery = (Node *) ctequery;
foreach(query_list, querytrees)
{
- Query *query = castNode(Query, lfirst(query_list));
+ Query *query = lfirst_node(Query, query_list);
PlannedStmt *stmt;
if (query->commandType == CMD_UTILITY)
*/
foreach(parsetree_item, parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(parsetree_item));
+ RawStmt *parsetree = lfirst_node(RawStmt, parsetree_item);
bool snapshot_set = false;
const char *commandTag;
char completionTag[COMPLETION_TAG_BUFSIZE];
bool snapshot_set = false;
int i;
- raw_parse_tree = castNode(RawStmt, linitial(parsetree_list));
+ raw_parse_tree = linitial_node(RawStmt, parsetree_list);
/*
* Get the command name for possible use in status display.
foreach(parsetree_item, raw_parsetree_list)
{
- RawStmt *parsetree = castNode(RawStmt, lfirst(parsetree_item));
+ RawStmt *parsetree = lfirst_node(RawStmt, parsetree_item);
if (IsA(parsetree->stmt, ExecuteStmt))
{
{
if (list_length(pstmts) == 1)
{
- PlannedStmt *pstmt = castNode(PlannedStmt, linitial(pstmts));
+ PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
if (pstmt->commandType == CMD_UTILITY &&
IsTransactionExitStmt(pstmt->utilityStmt))
{
if (list_length(pstmts) == 1)
{
- PlannedStmt *pstmt = castNode(PlannedStmt, linitial(pstmts));
+ PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
if (pstmt->commandType == CMD_UTILITY &&
IsA(pstmt->utilityStmt, TransactionStmt))
* Create QueryDesc in portal's context; for the moment, set
* the destination to DestNone.
*/
- queryDesc = CreateQueryDesc(castNode(PlannedStmt, linitial(portal->stmts)),
+ queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts),
portal->sourceText,
GetActiveSnapshot(),
InvalidSnapshot,
break;
case PORTAL_UTIL_SELECT:
- PortalRunUtility(portal, castNode(PlannedStmt, linitial(portal->stmts)),
+ PortalRunUtility(portal, linitial_node(PlannedStmt, portal->stmts),
isTopLevel, true, treceiver, completionTag);
break;
*/
foreach(stmtlist_item, portal->stmts)
{
- PlannedStmt *pstmt = castNode(PlannedStmt, lfirst(stmtlist_item));
+ PlannedStmt *pstmt = lfirst_node(PlannedStmt, stmtlist_item);
/*
* If we got a cancel signal in prior command, quit
appendStringInfoString(buf, "(alternatives: ");
foreach(lc, asplan->subplans)
{
- SubPlan *splan = castNode(SubPlan, lfirst(lc));
+ SubPlan *splan = lfirst_node(SubPlan, lc);
if (splan->useHashTable)
appendStringInfo(buf, "hashed %s", splan->plan_name);
get_rule_expr((Node *) linitial(xexpr->args),
context, true);
- con = castNode(Const, lsecond(xexpr->args));
+ con = lsecond_node(Const, xexpr->args);
Assert(!con->constisnull);
if (DatumGetBool(con->constvalue))
appendStringInfoString(buf,
else
get_rule_expr((Node *) con, context, false);
- con = castNode(Const, lthird(xexpr->args));
+ con = lthird_node(Const, xexpr->args);
if (con->constisnull)
/* suppress STANDALONE NO VALUE */ ;
else
*/
if (DO_AGGSPLIT_COMBINE(aggref->aggsplit))
{
- TargetEntry *tle = castNode(TargetEntry, linitial(aggref->args));
+ TargetEntry *tle = linitial_node(TargetEntry, aggref->args);
Assert(list_length(aggref->args) == 1);
resolve_special_varno((Node *) tle->expr, context, original_aggref,
sep = "";
foreach(l, ((BoolExpr *) sublink->testexpr)->args)
{
- OpExpr *opexpr = castNode(OpExpr, lfirst(l));
+ OpExpr *opexpr = lfirst_node(OpExpr, l);
appendStringInfoString(buf, sep);
get_rule_expr(linitial(opexpr->args), context, true);
forboth(lcc, path->indexquals, lci, path->indexqualcols)
{
- RestrictInfo *rinfo = castNode(RestrictInfo, lfirst(lcc));
+ RestrictInfo *rinfo = lfirst_node(RestrictInfo, lcc);
int indexcol = lfirst_int(lci);
Expr *clause;
Node *leftop,
is_transient = false;
foreach(lc, plist)
{
- PlannedStmt *plannedstmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
if (plannedstmt->commandType == CMD_UTILITY)
continue; /* Ignore utility statements */
foreach(lc, plan->stmt_list)
{
- PlannedStmt *plannedstmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
if (plannedstmt->commandType == CMD_UTILITY)
continue; /* Ignore utility statements */
foreach(lc, stmts)
{
- Query *stmt = castNode(Query, lfirst(lc));
+ Query *stmt = lfirst_node(Query, lc);
if (stmt->canSetTag)
return stmt;
foreach(lc1, stmt_list)
{
- PlannedStmt *plannedstmt = castNode(PlannedStmt, lfirst(lc1));
+ PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc1);
int rt_index;
ListCell *lc2;
foreach(lc, stmt_list)
{
- Query *query = castNode(Query, lfirst(lc));
+ Query *query = lfirst_node(Query, lc);
if (query->commandType == CMD_UTILITY)
{
/* Recurse into subquery-in-WITH */
foreach(lc, parsetree->cteList)
{
- CommonTableExpr *cte = castNode(CommonTableExpr, lfirst(lc));
+ CommonTableExpr *cte = lfirst_node(CommonTableExpr, lc);
ScanQueryForLocks(castNode(Query, cte->ctequery), acquire);
}
{
case PORTAL_ONE_SELECT:
case PORTAL_ONE_MOD_WITH:
- query = castNode(Query, linitial(stmt_list));
+ query = linitial_node(Query, stmt_list);
return ExecCleanTypeFromTL(query->targetList, false);
case PORTAL_ONE_RETURNING:
return ExecCleanTypeFromTL(query->returningList, false);
case PORTAL_UTIL_SELECT:
- query = castNode(Query, linitial(stmt_list));
+ query = linitial_node(Query, stmt_list);
Assert(query->utilityStmt);
return UtilityTupleDescriptor(query->utilityStmt);
foreach(lc, plansource->gplan->stmt_list)
{
- PlannedStmt *plannedstmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
if (plannedstmt->commandType == CMD_UTILITY)
continue; /* Ignore utility statements */
{
foreach(lc, plansource->gplan->stmt_list)
{
- PlannedStmt *plannedstmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
ListCell *lc3;
if (plannedstmt->commandType == CMD_UTILITY)
*/
foreach(lc, plansource->query_list)
{
- Query *query = castNode(Query, lfirst(lc));
+ Query *query = lfirst_node(Query, lc);
if (query->commandType != CMD_UTILITY ||
UtilityContainsQuery(query->utilityStmt))
}
else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
{
- A_Const *con = castNode(A_Const, linitial(stmt->args));
+ A_Const *con = linitial_node(A_Const, stmt->args);
if (stmt->is_local)
ereport(ERROR,
foreach(lc, portal->stmts)
{
- PlannedStmt *stmt = castNode(PlannedStmt, lfirst(lc));
+ PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
if (stmt->canSetTag)
return stmt;
#define lfirst(lc) ((lc)->data.ptr_value)
#define lfirst_int(lc) ((lc)->data.int_value)
#define lfirst_oid(lc) ((lc)->data.oid_value)
+#define lfirst_node(type,lc) castNode(type, lfirst(lc))
#define linitial(l) lfirst(list_head(l))
#define linitial_int(l) lfirst_int(list_head(l))
#define linitial_oid(l) lfirst_oid(list_head(l))
+#define linitial_node(type,l) castNode(type, linitial(l))
#define lsecond(l) lfirst(lnext(list_head(l)))
#define lsecond_int(l) lfirst_int(lnext(list_head(l)))
#define lsecond_oid(l) lfirst_oid(lnext(list_head(l)))
+#define lsecond_node(type,l) castNode(type, lsecond(l))
#define lthird(l) lfirst(lnext(lnext(list_head(l))))
#define lthird_int(l) lfirst_int(lnext(lnext(list_head(l))))
#define lthird_oid(l) lfirst_oid(lnext(lnext(list_head(l))))
+#define lthird_node(type,l) castNode(type, lthird(l))
#define lfourth(l) lfirst(lnext(lnext(lnext(list_head(l)))))
#define lfourth_int(l) lfirst_int(lnext(lnext(lnext(list_head(l)))))
#define lfourth_oid(l) lfirst_oid(lnext(lnext(lnext(list_head(l)))))
+#define lfourth_node(type,l) castNode(type, lfourth(l))
#define llast(l) lfirst(list_tail(l))
#define llast_int(l) lfirst_int(list_tail(l))
#define llast_oid(l) lfirst_oid(list_tail(l))
+#define llast_node(type,l) castNode(type, llast(l))
/*
* Convenience macros for building fixed-length lists
extern void *list_nth(const List *list, int n);
extern int list_nth_int(const List *list, int n);
extern Oid list_nth_oid(const List *list, int n);
+#define list_nth_node(type,list,n) castNode(type, list_nth(list, n))
extern bool list_member(const List *list, const void *datum);
extern bool list_member_ptr(const List *list, const void *datum);
foreach(l2, plansource->query_list)
{
- Query *q = castNode(Query, lfirst(l2));
+ Query *q = lfirst_node(Query, l2);
if (q->canSetTag)
{
*/
if (list_length(cplan->stmt_list) != 1)
return;
- stmt = castNode(PlannedStmt, linitial(cplan->stmt_list));
+ stmt = linitial_node(PlannedStmt, cplan->stmt_list);
/*
* 2. It must be a RESULT plan --> no scan's required
projects / postgresql.git / commitdiff