forboth(lp, glob->subplans, lr, glob->subroots)
{
Plan *subplan = (Plan *) lfirst(lp);
- PlannerInfo *subroot = (PlannerInfo *) lfirst(lr);
+ PlannerInfo *subroot = lfirst_node(PlannerInfo, lr);
SS_finalize_plan(subroot, subplan);
}
forboth(lp, glob->subplans, lr, glob->subroots)
{
Plan *subplan = (Plan *) lfirst(lp);
- PlannerInfo *subroot = (PlannerInfo *) lfirst(lr);
+ PlannerInfo *subroot = lfirst_node(PlannerInfo, lr);
lfirst(lp) = set_plan_references(subroot, subplan);
}
hasOuterJoins = false;
foreach(l, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
if (rte->rtekind == RTE_JOIN)
{
newWithCheckOptions = NIL;
foreach(l, parse->withCheckOptions)
{
- WithCheckOption *wco = (WithCheckOption *) lfirst(l);
+ WithCheckOption *wco = lfirst_node(WithCheckOption, l);
wco->qual = preprocess_expression(root, wco->qual,
EXPRKIND_QUAL);
foreach(l, parse->windowClause)
{
- WindowClause *wc = (WindowClause *) lfirst(l);
+ WindowClause *wc = lfirst_node(WindowClause, l);
/* partitionClause/orderClause are sort/group expressions */
wc->startOffset = preprocess_expression(root, wc->startOffset,
/* Also need to preprocess expressions within RTEs */
foreach(l, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
int kind;
ListCell *lcsq;
rti = 1;
foreach(lc, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
if (rte->rtekind == RTE_SUBQUERY)
subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
{
foreach(lc, root->append_rel_list)
{
- AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
+ AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
*/
foreach(lc, root->append_rel_list)
{
- AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
+ AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
PlannerInfo *subroot;
RangeTblEntry *child_rte;
RelOptInfo *sub_final_rel;
subroot->append_rel_list = NIL;
foreach(lc2, root->append_rel_list)
{
- AppendRelInfo *appinfo2 = (AppendRelInfo *) lfirst(lc2);
+ AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
appinfo2 = copyObject(appinfo2);
rti = 1;
foreach(lr, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(lr);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
if (bms_is_member(rti, subqueryRTindexes))
{
foreach(lc2, subroot->append_rel_list)
{
- AppendRelInfo *appinfo2 = (AppendRelInfo *) lfirst(lc2);
+ AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
if (bms_is_member(appinfo2->child_relid,
modifiableARIindexes))
rti = 1;
foreach(lc, final_rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
root->simple_rte_array[rti++] = rte;
}
/*------
translator: %s is a SQL row locking clause such as FOR UPDATE */
errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
- LCS_asString(((RowMarkClause *)
- linitial(parse->rowMarks))->strength))));
+ LCS_asString(linitial_node(RowMarkClause,
+ parse->rowMarks)->strength))));
/*
* Calculate pathkeys that represent result ordering requirements
qp_extra.tlist = tlist;
qp_extra.activeWindows = activeWindows;
qp_extra.groupClause = (gset_data
- ? (gset_data->rollups ? ((RollupData *) linitial(gset_data->rollups))->groupClause : NIL)
+ ? (gset_data->rollups ? linitial_node(RollupData, gset_data->rollups)->groupClause : NIL)
: parse->groupClause);
/*
split_pathtarget_at_srfs(root, final_target, sort_input_target,
&final_targets,
&final_targets_contain_srfs);
- final_target = (PathTarget *) linitial(final_targets);
+ final_target = linitial_node(PathTarget, final_targets);
Assert(!linitial_int(final_targets_contain_srfs));
/* likewise for sort_input_target vs. grouping_target */
split_pathtarget_at_srfs(root, sort_input_target, grouping_target,
&sort_input_targets,
&sort_input_targets_contain_srfs);
- sort_input_target = (PathTarget *) linitial(sort_input_targets);
+ sort_input_target = linitial_node(PathTarget, sort_input_targets);
Assert(!linitial_int(sort_input_targets_contain_srfs));
/* likewise for grouping_target vs. scanjoin_target */
split_pathtarget_at_srfs(root, grouping_target, scanjoin_target,
&grouping_targets,
&grouping_targets_contain_srfs);
- grouping_target = (PathTarget *) linitial(grouping_targets);
+ grouping_target = linitial_node(PathTarget, grouping_targets);
Assert(!linitial_int(grouping_targets_contain_srfs));
/* scanjoin_target will not have any SRFs precomputed for it */
split_pathtarget_at_srfs(root, scanjoin_target, NULL,
&scanjoin_targets,
&scanjoin_targets_contain_srfs);
- scanjoin_target = (PathTarget *) linitial(scanjoin_targets);
+ scanjoin_target = linitial_node(PathTarget, scanjoin_targets);
Assert(!linitial_int(scanjoin_targets_contain_srfs));
}
else
foreach(lc, parse->groupClause)
{
- SortGroupClause *gc = lfirst(lc);
+ SortGroupClause *gc = lfirst_node(SortGroupClause, lc);
Index ref = gc->tleSortGroupRef;
if (ref > maxref)
foreach(lc, parse->groupingSets)
{
- List *gset = lfirst(lc);
+ List *gset = (List *) lfirst(lc);
if (bms_overlap_list(gd->unsortable_refs, gset))
{
/*
* Get the initial (and therefore largest) grouping set.
*/
- gs = linitial(current_sets);
+ gs = linitial_node(GroupingSetData, current_sets);
/*
* Order the groupClause appropriately. If the first grouping set is
foreach(lc, groupClause)
{
- SortGroupClause *gc = lfirst(lc);
+ SortGroupClause *gc = lfirst_node(SortGroupClause, lc);
tleref_to_colnum_map[gc->tleSortGroupRef] = ref++;
}
{
List *set = NIL;
ListCell *lc2;
- GroupingSetData *gs = lfirst(lc);
+ GroupingSetData *gs = lfirst_node(GroupingSetData, lc);
foreach(lc2, gs->set)
{
* CTIDs invalid. This is also checked at parse time, but that's
* insufficient because of rule substitution, query pullup, etc.
*/
- CheckSelectLocking(parse, ((RowMarkClause *)
- linitial(parse->rowMarks))->strength);
+ CheckSelectLocking(parse, linitial_node(RowMarkClause,
+ parse->rowMarks)->strength);
}
else
{
prowmarks = NIL;
foreach(l, parse->rowMarks)
{
- RowMarkClause *rc = (RowMarkClause *) lfirst(l);
+ RowMarkClause *rc = lfirst_node(RowMarkClause, l);
RangeTblEntry *rte = rt_fetch(rc->rti, parse->rtable);
PlanRowMark *newrc;
i = 0;
foreach(l, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
PlanRowMark *newrc;
i++;
(list_length(parse->rtable) + 1));
foreach(lc, parse->groupClause)
{
- SortGroupClause *sgc = (SortGroupClause *) lfirst(lc);
+ SortGroupClause *sgc = lfirst_node(SortGroupClause, lc);
TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
Var *var = (Var *) tle->expr;
relid = 0;
foreach(lc, parse->rtable)
{
- RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+ RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
Bitmapset *relattnos;
Bitmapset *pkattnos;
Oid constraintOid;
foreach(lc, parse->groupClause)
{
- SortGroupClause *sgc = (SortGroupClause *) lfirst(lc);
+ SortGroupClause *sgc = lfirst_node(SortGroupClause, lc);
TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
Var *var = (Var *) tle->expr;
*/
foreach(sl, parse->sortClause)
{
- SortGroupClause *sc = (SortGroupClause *) lfirst(sl);
+ SortGroupClause *sc = lfirst_node(SortGroupClause, sl);
foreach(gl, parse->groupClause)
{
- SortGroupClause *gc = (SortGroupClause *) lfirst(gl);
+ SortGroupClause *gc = lfirst_node(SortGroupClause, gl);
if (equal(gc, sc))
{
*/
foreach(gl, parse->groupClause)
{
- SortGroupClause *gc = (SortGroupClause *) lfirst(gl);
+ SortGroupClause *gc = lfirst_node(SortGroupClause, gl);
if (list_member_ptr(new_groupclause, gc))
continue; /* it matched an ORDER BY item */
for_each_cell(lc, lc1)
{
- List *candidate = lfirst(lc);
+ List *candidate = (List *) lfirst(lc);
Bitmapset *candidate_set = NULL;
ListCell *lc2;
int dup_of = 0;
foreach(lc, groupingsets)
{
- List *candidate = lfirst(lc);
+ List *candidate = (List *) lfirst(lc);
List *new_elems = list_difference_int(candidate, previous);
GroupingSetData *gs = makeNode(GroupingSetData);
/* We consider only the first (bottom) window in pathkeys logic */
if (activeWindows != NIL)
{
- WindowClause *wc = (WindowClause *) linitial(activeWindows);
+ WindowClause *wc = linitial_node(WindowClause, activeWindows);
root->window_pathkeys = make_pathkeys_for_window(root,
wc,
foreach(lc, gd->rollups)
{
- RollupData *rollup = lfirst(lc);
+ RollupData *rollup = lfirst_node(RollupData, lc);
ListCell *lc;
groupExprs = get_sortgrouplist_exprs(rollup->groupClause,
forboth(lc, rollup->gsets, lc2, rollup->gsets_data)
{
List *gset = (List *) lfirst(lc);
- GroupingSetData *gs = lfirst(lc2);
+ GroupingSetData *gs = lfirst_node(GroupingSetData, lc2);
double numGroups = estimate_num_groups(root,
groupExprs,
path_rows,
forboth(lc, gd->hash_sets_idx, lc2, gd->unsortable_sets)
{
List *gset = (List *) lfirst(lc);
- GroupingSetData *gs = lfirst(lc2);
+ GroupingSetData *gs = lfirst_node(GroupingSetData, lc2);
double numGroups = estimate_num_groups(root,
groupExprs,
path_rows,
if (pathkeys_contained_in(root->group_pathkeys, path->pathkeys))
{
- unhashed_rollup = lfirst(l_start);
+ unhashed_rollup = lfirst_node(RollupData, l_start);
exclude_groups = unhashed_rollup->numGroups;
l_start = lnext(l_start);
}
for_each_cell(lc, l_start)
{
- RollupData *rollup = lfirst(lc);
+ RollupData *rollup = lfirst_node(RollupData, lc);
/*
* If we find an unhashable rollup that's not been skipped by the
}
foreach(lc, sets_data)
{
- GroupingSetData *gs = lfirst(lc);
+ GroupingSetData *gs = lfirst_node(GroupingSetData, lc);
List *gset = gs->set;
RollupData *rollup;
i = 0;
for_each_cell(lc, lnext(list_head(gd->rollups)))
{
- RollupData *rollup = lfirst(lc);
+ RollupData *rollup = lfirst_node(RollupData, lc);
if (rollup->hashable)
{
i = 0;
for_each_cell(lc, lnext(list_head(gd->rollups)))
{
- RollupData *rollup = lfirst(lc);
+ RollupData *rollup = lfirst_node(RollupData, lc);
if (rollup->hashable)
{
foreach(lc, hash_sets)
{
- GroupingSetData *gs = lfirst(lc);
+ GroupingSetData *gs = lfirst_node(GroupingSetData, lc);
RollupData *rollup = makeNode(RollupData);
Assert(gs->set != NIL);
foreach(l, activeWindows)
{
- WindowClause *wc = (WindowClause *) lfirst(l);
+ WindowClause *wc = lfirst_node(WindowClause, l);
List *window_pathkeys;
window_pathkeys = make_pathkeys_for_window(root,
foreach(l, new_tlist)
{
- TargetEntry *new_tle = (TargetEntry *) lfirst(l);
+ TargetEntry *new_tle = lfirst_node(TargetEntry, l);
TargetEntry *orig_tle;
/* ignore resjunk columns in setop result */
continue;
Assert(orig_tlist_item != NULL);
- orig_tle = (TargetEntry *) lfirst(orig_tlist_item);
+ orig_tle = lfirst_node(TargetEntry, orig_tlist_item);
orig_tlist_item = lnext(orig_tlist_item);
if (orig_tle->resjunk) /* should not happen */
elog(ERROR, "resjunk output columns are not implemented");
actives = NIL;
foreach(lc, root->parse->windowClause)
{
- WindowClause *wc = (WindowClause *) lfirst(lc);
+ WindowClause *wc = lfirst_node(WindowClause, lc);
/* It's only active if wflists shows some related WindowFuncs */
Assert(wc->winref <= wflists->maxWinRef);
result = NIL;
while (actives != NIL)
{
- WindowClause *wc = (WindowClause *) linitial(actives);
+ WindowClause *wc = linitial_node(WindowClause, actives);
ListCell *prev;
ListCell *next;
prev = NULL;
for (lc = list_head(actives); lc; lc = next)
{
- WindowClause *wc2 = (WindowClause *) lfirst(lc);
+ WindowClause *wc2 = lfirst_node(WindowClause, lc);
next = lnext(lc);
/* framing options are NOT to be compared here! */
sgrefs = NULL;
foreach(lc, activeWindows)
{
- WindowClause *wc = (WindowClause *) lfirst(lc);
+ WindowClause *wc = lfirst_node(WindowClause, lc);
ListCell *lc2;
foreach(lc2, wc->partitionClause)
{
- SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc2);
+ SortGroupClause *sortcl = lfirst_node(SortGroupClause, lc2);
sgrefs = bms_add_member(sgrefs, sortcl->tleSortGroupRef);
}
foreach(lc2, wc->orderClause)
{
- SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc2);
+ SortGroupClause *sortcl = lfirst_node(SortGroupClause, lc2);
sgrefs = bms_add_member(sgrefs, sortcl->tleSortGroupRef);
}
/* Add in sortgroupref numbers of GROUP BY clauses, too */
foreach(lc, parse->groupClause)
{
- SortGroupClause *grpcl = (SortGroupClause *) lfirst(lc);
+ SortGroupClause *grpcl = lfirst_node(SortGroupClause, lc);
sgrefs = bms_add_member(sgrefs, grpcl->tleSortGroupRef);
}
Assert(subpath->param_info == NULL);
forboth(lc1, targets, lc2, targets_contain_srfs)
{
- PathTarget *thistarget = (PathTarget *) lfirst(lc1);
+ PathTarget *thistarget = lfirst_node(PathTarget, lc1);
bool contains_srfs = (bool) lfirst_int(lc2);
/* If this level doesn't contain SRFs, do regular projection */
Assert(subpath->param_info == NULL);
forboth(lc1, targets, lc2, targets_contain_srfs)
{
- PathTarget *thistarget = (PathTarget *) lfirst(lc1);
+ PathTarget *thistarget = lfirst_node(PathTarget, lc1);
bool contains_srfs = (bool) lfirst_int(lc2);
/* If this level doesn't contain SRFs, do regular projection */
indexInfo = NULL;
foreach(lc, rel->indexlist)
{
- indexInfo = (IndexOptInfo *) lfirst(lc);
+ indexInfo = lfirst_node(IndexOptInfo, lc);
if (indexInfo->indexoid == indexOid)
break;
}
foreach(l, root->pcinfo_list)
{
- PartitionedChildRelInfo *pc = lfirst(l);
+ PartitionedChildRelInfo *pc = lfirst_node(PartitionedChildRelInfo, l);
if (pc->parent_relid == rti)
{
projects / postgresql.git / commitdiff