PostgreSQL Source Code  git master
tidpath.c File Reference
Include dependency graph for tidpath.c:

Go to the source code of this file.

Functions

static bool IsCTIDVar (Var *var, RelOptInfo *rel)
 
static bool IsBinaryTidClause (RestrictInfo *rinfo, RelOptInfo *rel)
 
static bool IsTidEqualClause (RestrictInfo *rinfo, RelOptInfo *rel)
 
static bool IsTidRangeClause (RestrictInfo *rinfo, RelOptInfo *rel)
 
static bool IsTidEqualAnyClause (PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
 
static bool IsCurrentOfClause (RestrictInfo *rinfo, RelOptInfo *rel)
 
static ListTidQualFromRestrictInfo (PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
 
static ListTidQualFromRestrictInfoList (PlannerInfo *root, List *rlist, RelOptInfo *rel)
 
static ListTidRangeQualFromRestrictInfoList (List *rlist, RelOptInfo *rel)
 
static void BuildParameterizedTidPaths (PlannerInfo *root, RelOptInfo *rel, List *clauses)
 
static bool ec_member_matches_ctid (PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
 
void create_tidscan_paths (PlannerInfo *root, RelOptInfo *rel)
 

Function Documentation

◆ BuildParameterizedTidPaths()

static void BuildParameterizedTidPaths ( PlannerInfo root,
RelOptInfo rel,
List clauses 
)
static

Definition at line 387 of file tidpath.c.

References add_path(), bms_del_member(), bms_union(), create_tidscan_path(), IsTidEqualClause(), join_clause_is_movable_to(), RelOptInfo::lateral_relids, lfirst_node, list_make1, RestrictInfo::pseudoconstant, RelOptInfo::relid, RestrictInfo::required_relids, and restriction_is_securely_promotable().

Referenced by create_tidscan_paths().

388 {
389  ListCell *l;
390 
391  foreach(l, clauses)
392  {
394  List *tidquals;
395  Relids required_outer;
396 
397  /*
398  * Validate whether each clause is actually usable; we must check this
399  * even when examining clauses generated from an EquivalenceClass,
400  * since they might not satisfy the restriction on not having Vars of
401  * our rel on the other side, or somebody might've built an operator
402  * class that accepts type "tid" but has other operators in it.
403  *
404  * We currently consider only TidEqual join clauses. In principle we
405  * might find a suitable ScalarArrayOpExpr in the rel's joininfo list,
406  * but it seems unlikely to be worth expending the cycles to check.
407  * And we definitely won't find a CurrentOfExpr here. Hence, we don't
408  * use TidQualFromRestrictInfo; but this must match that function
409  * otherwise.
410  */
411  if (rinfo->pseudoconstant ||
412  !restriction_is_securely_promotable(rinfo, rel) ||
413  !IsTidEqualClause(rinfo, rel))
414  continue;
415 
416  /*
417  * Check if clause can be moved to this rel; this is probably
418  * redundant when considering EC-derived clauses, but we must check it
419  * for "loose" join clauses.
420  */
421  if (!join_clause_is_movable_to(rinfo, rel))
422  continue;
423 
424  /* OK, make list of clauses for this path */
425  tidquals = list_make1(rinfo);
426 
427  /* Compute required outer rels for this path */
428  required_outer = bms_union(rinfo->required_relids, rel->lateral_relids);
429  required_outer = bms_del_member(required_outer, rel->relid);
430 
431  add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals,
432  required_outer));
433  }
434 }
void add_path(RelOptInfo *parent_rel, Path *new_path)
Definition: pathnode.c:422
Relids required_relids
Definition: pathnodes.h:2077
bool pseudoconstant
Definition: pathnodes.h:2064
#define list_make1(x1)
Definition: pg_list.h:206
Relids lateral_relids
Definition: pathnodes.h:706
#define lfirst_node(type, lc)
Definition: pg_list.h:172
Index relid
Definition: pathnodes.h:709
static bool IsTidEqualClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:130
bool restriction_is_securely_promotable(RestrictInfo *restrictinfo, RelOptInfo *rel)
Definition: restrictinfo.c:397
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:225
bool join_clause_is_movable_to(RestrictInfo *rinfo, RelOptInfo *baserel)
Definition: restrictinfo.c:525
TidPath * create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer)
Definition: pathnode.c:1183
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition: bitmapset.c:773
Definition: pg_list.h:50

◆ create_tidscan_paths()

void create_tidscan_paths ( PlannerInfo root,
RelOptInfo rel 
)

Definition at line 459 of file tidpath.c.

References add_path(), RelOptInfo::baserestrictinfo, BuildParameterizedTidPaths(), create_tidrangescan_path(), create_tidscan_path(), ec_member_matches_ctid(), generate_implied_equalities_for_column(), RelOptInfo::has_eclass_joins, RelOptInfo::joininfo, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, NIL, TidQualFromRestrictInfoList(), and TidRangeQualFromRestrictInfoList().

Referenced by set_plain_rel_pathlist().

460 {
461  List *tidquals;
462  List *tidrangequals;
463 
464  /*
465  * If any suitable quals exist in the rel's baserestrict list, generate a
466  * plain (unparameterized) TidPath with them.
467  */
468  tidquals = TidQualFromRestrictInfoList(root, rel->baserestrictinfo, rel);
469 
470  if (tidquals != NIL)
471  {
472  /*
473  * This path uses no join clauses, but it could still have required
474  * parameterization due to LATERAL refs in its tlist.
475  */
476  Relids required_outer = rel->lateral_relids;
477 
478  add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals,
479  required_outer));
480  }
481 
482  /*
483  * If there are range quals in the baserestrict list, generate a
484  * TidRangePath.
485  */
487  rel);
488 
489  if (tidrangequals != NIL)
490  {
491  /*
492  * This path uses no join clauses, but it could still have required
493  * parameterization due to LATERAL refs in its tlist.
494  */
495  Relids required_outer = rel->lateral_relids;
496 
497  add_path(rel, (Path *) create_tidrangescan_path(root, rel,
498  tidrangequals,
499  required_outer));
500  }
501 
502  /*
503  * Try to generate parameterized TidPaths using equality clauses extracted
504  * from EquivalenceClasses. (This is important since simple "t1.ctid =
505  * t2.ctid" clauses will turn into ECs.)
506  */
507  if (rel->has_eclass_joins)
508  {
509  List *clauses;
510 
511  /* Generate clauses, skipping any that join to lateral_referencers */
513  rel,
515  NULL,
516  rel->lateral_referencers);
517 
518  /* Generate a path for each usable join clause */
519  BuildParameterizedTidPaths(root, rel, clauses);
520  }
521 
522  /*
523  * Also consider parameterized TidPaths using "loose" join quals. Quals
524  * of the form "t1.ctid = t2.ctid" would turn into these if they are outer
525  * join quals, for example.
526  */
527  BuildParameterizedTidPaths(root, rel, rel->joininfo);
528 }
bool has_eclass_joins
Definition: pathnodes.h:751
#define NIL
Definition: pg_list.h:65
void add_path(RelOptInfo *parent_rel, Path *new_path)
Definition: pathnode.c:422
TidRangePath * create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, List *tidrangequals, Relids required_outer)
Definition: pathnode.c:1212
List * baserestrictinfo
Definition: pathnodes.h:745
static List * TidRangeQualFromRestrictInfoList(List *rlist, RelOptInfo *rel)
Definition: tidpath.c:359
static bool ec_member_matches_ctid(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
Definition: tidpath.c:442
Relids lateral_relids
Definition: pathnodes.h:706
static void BuildParameterizedTidPaths(PlannerInfo *root, RelOptInfo *rel, List *clauses)
Definition: tidpath.c:387
List * joininfo
Definition: pathnodes.h:749
Relids lateral_referencers
Definition: pathnodes.h:717
static List * TidQualFromRestrictInfoList(PlannerInfo *root, List *rlist, RelOptInfo *rel)
Definition: tidpath.c:276
TidPath * create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer)
Definition: pathnode.c:1183
Definition: pg_list.h:50
List * generate_implied_equalities_for_column(PlannerInfo *root, RelOptInfo *rel, ec_matches_callback_type callback, void *callback_arg, Relids prohibited_rels)
Definition: equivclass.c:2850

◆ ec_member_matches_ctid()

static bool ec_member_matches_ctid ( PlannerInfo root,
RelOptInfo rel,
EquivalenceClass ec,
EquivalenceMember em,
void *  arg 
)
static

Definition at line 442 of file tidpath.c.

References EquivalenceMember::em_expr, IsA, and IsCTIDVar().

Referenced by create_tidscan_paths().

445 {
446  if (em->em_expr && IsA(em->em_expr, Var) &&
447  IsCTIDVar((Var *) em->em_expr, rel))
448  return true;
449  return false;
450 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:587
Definition: primnodes.h:186
static bool IsCTIDVar(Var *var, RelOptInfo *rel)
Definition: tidpath.c:56

◆ IsBinaryTidClause()

static bool IsBinaryTidClause ( RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 76 of file tidpath.c.

References OpExpr::args, bms_is_member(), RestrictInfo::clause, contain_volatile_functions(), is_opclause(), IsA, IsCTIDVar(), RestrictInfo::left_relids, linitial, list_length(), lsecond, RelOptInfo::relid, and RestrictInfo::right_relids.

Referenced by IsTidEqualClause(), and IsTidRangeClause().

77 {
78  OpExpr *node;
79  Node *arg1,
80  *arg2,
81  *other;
82  Relids other_relids;
83 
84  /* Must be an OpExpr */
85  if (!is_opclause(rinfo->clause))
86  return false;
87  node = (OpExpr *) rinfo->clause;
88 
89  /* OpExpr must have two arguments */
90  if (list_length(node->args) != 2)
91  return false;
92  arg1 = linitial(node->args);
93  arg2 = lsecond(node->args);
94 
95  /* Look for CTID as either argument */
96  other = NULL;
97  other_relids = NULL;
98  if (arg1 && IsA(arg1, Var) &&
99  IsCTIDVar((Var *) arg1, rel))
100  {
101  other = arg2;
102  other_relids = rinfo->right_relids;
103  }
104  if (!other && arg2 && IsA(arg2, Var) &&
105  IsCTIDVar((Var *) arg2, rel))
106  {
107  other = arg1;
108  other_relids = rinfo->left_relids;
109  }
110  if (!other)
111  return false;
112 
113  /* The other argument must be a pseudoconstant */
114  if (bms_is_member(rel->relid, other_relids) ||
116  return false;
117 
118  return true; /* success */
119 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:587
Definition: nodes.h:536
Relids left_relids
Definition: pathnodes.h:2086
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:452
Definition: primnodes.h:186
#define lsecond(l)
Definition: pg_list.h:179
#define linitial(l)
Definition: pg_list.h:174
Index relid
Definition: pathnodes.h:709
Expr * clause
Definition: pathnodes.h:2056
static bool IsCTIDVar(Var *var, RelOptInfo *rel)
Definition: tidpath.c:56
Relids right_relids
Definition: pathnodes.h:2087
static int list_length(const List *l)
Definition: pg_list.h:149
static bool is_opclause(const void *clause)
Definition: nodeFuncs.h:66
List * args
Definition: primnodes.h:548
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427

◆ IsCTIDVar()

static bool IsCTIDVar ( Var var,
RelOptInfo rel 
)
inlinestatic

Definition at line 56 of file tidpath.c.

References RelOptInfo::relid, SelfItemPointerAttributeNumber, Var::varattno, Var::varlevelsup, Var::varno, and Var::vartype.

Referenced by ec_member_matches_ctid(), IsBinaryTidClause(), and IsTidEqualAnyClause().

57 {
58  /* The vartype check is strictly paranoia */
60  var->vartype == TIDOID &&
61  var->varno == rel->relid &&
62  var->varlevelsup == 0)
63  return true;
64  return false;
65 }
int varno
Definition: primnodes.h:189
Index varlevelsup
Definition: primnodes.h:196
AttrNumber varattno
Definition: primnodes.h:191
Oid vartype
Definition: primnodes.h:193
Index relid
Definition: pathnodes.h:709
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21

◆ IsCurrentOfClause()

static bool IsCurrentOfClause ( RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 211 of file tidpath.c.

References RestrictInfo::clause, CurrentOfExpr::cvarno, IsA, and RelOptInfo::relid.

Referenced by TidQualFromRestrictInfo().

212 {
213  CurrentOfExpr *node;
214 
215  /* Must be a CurrentOfExpr */
216  if (!(rinfo->clause && IsA(rinfo->clause, CurrentOfExpr)))
217  return false;
218  node = (CurrentOfExpr *) rinfo->clause;
219 
220  /* If it references this rel, we're good */
221  if (node->cvarno == rel->relid)
222  return true;
223 
224  return false;
225 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:587
Index relid
Definition: pathnodes.h:709
Expr * clause
Definition: pathnodes.h:2056

◆ IsTidEqualAnyClause()

static bool IsTidEqualAnyClause ( PlannerInfo root,
RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 172 of file tidpath.c.

References ScalarArrayOpExpr::args, Assert, bms_is_member(), RestrictInfo::clause, contain_volatile_functions(), IsA, IsCTIDVar(), linitial, list_length(), lsecond, ScalarArrayOpExpr::opno, pull_varnos(), RelOptInfo::relid, and ScalarArrayOpExpr::useOr.

Referenced by TidQualFromRestrictInfo().

173 {
174  ScalarArrayOpExpr *node;
175  Node *arg1,
176  *arg2;
177 
178  /* Must be a ScalarArrayOpExpr */
179  if (!(rinfo->clause && IsA(rinfo->clause, ScalarArrayOpExpr)))
180  return false;
181  node = (ScalarArrayOpExpr *) rinfo->clause;
182 
183  /* Operator must be tideq */
184  if (node->opno != TIDEqualOperator)
185  return false;
186  if (!node->useOr)
187  return false;
188  Assert(list_length(node->args) == 2);
189  arg1 = linitial(node->args);
190  arg2 = lsecond(node->args);
191 
192  /* CTID must be first argument */
193  if (arg1 && IsA(arg1, Var) &&
194  IsCTIDVar((Var *) arg1, rel))
195  {
196  /* The other argument must be a pseudoconstant */
197  if (bms_is_member(rel->relid, pull_varnos(root, arg2)) ||
199  return false;
200 
201  return true; /* success */
202  }
203 
204  return false;
205 }
Relids pull_varnos(PlannerInfo *root, Node *node)
Definition: var.c:97
#define IsA(nodeptr, _type_)
Definition: nodes.h:587
Definition: nodes.h:536
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:452
Definition: primnodes.h:186
#define lsecond(l)
Definition: pg_list.h:179
#define linitial(l)
Definition: pg_list.h:174
Index relid
Definition: pathnodes.h:709
Expr * clause
Definition: pathnodes.h:2056
static bool IsCTIDVar(Var *var, RelOptInfo *rel)
Definition: tidpath.c:56
#define Assert(condition)
Definition: c.h:804
static int list_length(const List *l)
Definition: pg_list.h:149
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427

◆ IsTidEqualClause()

static bool IsTidEqualClause ( RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 130 of file tidpath.c.

References RestrictInfo::clause, and IsBinaryTidClause().

Referenced by BuildParameterizedTidPaths(), and TidQualFromRestrictInfo().

131 {
132  if (!IsBinaryTidClause(rinfo, rel))
133  return false;
134 
135  if (((OpExpr *) rinfo->clause)->opno == TIDEqualOperator)
136  return true;
137 
138  return false;
139 }
static bool IsBinaryTidClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:76
Expr * clause
Definition: pathnodes.h:2056

◆ IsTidRangeClause()

static bool IsTidRangeClause ( RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 150 of file tidpath.c.

References RestrictInfo::clause, and IsBinaryTidClause().

Referenced by TidRangeQualFromRestrictInfoList().

151 {
152  Oid opno;
153 
154  if (!IsBinaryTidClause(rinfo, rel))
155  return false;
156  opno = ((OpExpr *) rinfo->clause)->opno;
157 
158  if (opno == TIDLessOperator || opno == TIDLessEqOperator ||
159  opno == TIDGreaterOperator || opno == TIDGreaterEqOperator)
160  return true;
161 
162  return false;
163 }
unsigned int Oid
Definition: postgres_ext.h:31
static bool IsBinaryTidClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:76
Expr * clause
Definition: pathnodes.h:2056

◆ TidQualFromRestrictInfo()

static List* TidQualFromRestrictInfo ( PlannerInfo root,
RestrictInfo rinfo,
RelOptInfo rel 
)
static

Definition at line 239 of file tidpath.c.

References IsCurrentOfClause(), IsTidEqualAnyClause(), IsTidEqualClause(), list_make1, NIL, RestrictInfo::pseudoconstant, and restriction_is_securely_promotable().

Referenced by TidQualFromRestrictInfoList().

240 {
241  /*
242  * We may ignore pseudoconstant clauses (they can't contain Vars, so could
243  * not match anyway).
244  */
245  if (rinfo->pseudoconstant)
246  return NIL;
247 
248  /*
249  * If clause must wait till after some lower-security-level restriction
250  * clause, reject it.
251  */
252  if (!restriction_is_securely_promotable(rinfo, rel))
253  return NIL;
254 
255  /*
256  * Check all base cases. If we get a match, return the clause.
257  */
258  if (IsTidEqualClause(rinfo, rel) ||
259  IsTidEqualAnyClause(root, rinfo, rel) ||
260  IsCurrentOfClause(rinfo, rel))
261  return list_make1(rinfo);
262 
263  return NIL;
264 }
#define NIL
Definition: pg_list.h:65
bool pseudoconstant
Definition: pathnodes.h:2064
static bool IsCurrentOfClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:211
#define list_make1(x1)
Definition: pg_list.h:206
static bool IsTidEqualAnyClause(PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:172
static bool IsTidEqualClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:130
bool restriction_is_securely_promotable(RestrictInfo *restrictinfo, RelOptInfo *rel)
Definition: restrictinfo.c:397

◆ TidQualFromRestrictInfoList()

static List* TidQualFromRestrictInfoList ( PlannerInfo root,
List rlist,
RelOptInfo rel 
)
static

Definition at line 276 of file tidpath.c.

References Assert, castNode, is_andclause(), lfirst, lfirst_node, list_concat(), NIL, RestrictInfo::orclause, restriction_is_or_clause(), and TidQualFromRestrictInfo().

Referenced by create_tidscan_paths().

277 {
278  List *rlst = NIL;
279  ListCell *l;
280 
281  foreach(l, rlist)
282  {
284 
285  if (restriction_is_or_clause(rinfo))
286  {
287  ListCell *j;
288 
289  /*
290  * We must be able to extract a CTID condition from every
291  * sub-clause of an OR, or we can't use it.
292  */
293  foreach(j, ((BoolExpr *) rinfo->orclause)->args)
294  {
295  Node *orarg = (Node *) lfirst(j);
296  List *sublist;
297 
298  /* OR arguments should be ANDs or sub-RestrictInfos */
299  if (is_andclause(orarg))
300  {
301  List *andargs = ((BoolExpr *) orarg)->args;
302 
303  /* Recurse in case there are sub-ORs */
304  sublist = TidQualFromRestrictInfoList(root, andargs, rel);
305  }
306  else
307  {
308  RestrictInfo *rinfo = castNode(RestrictInfo, orarg);
309 
311  sublist = TidQualFromRestrictInfo(root, rinfo, rel);
312  }
313 
314  /*
315  * If nothing found in this arm, we can't do anything with
316  * this OR clause.
317  */
318  if (sublist == NIL)
319  {
320  rlst = NIL; /* forget anything we had */
321  break; /* out of loop over OR args */
322  }
323 
324  /*
325  * OK, continue constructing implicitly-OR'ed result list.
326  */
327  rlst = list_concat(rlst, sublist);
328  }
329  }
330  else
331  {
332  /* Not an OR clause, so handle base cases */
333  rlst = TidQualFromRestrictInfo(root, rinfo, rel);
334  }
335 
336  /*
337  * Stop as soon as we find any usable CTID condition. In theory we
338  * could get CTID equality conditions from different AND'ed clauses,
339  * in which case we could try to pick the most efficient one. In
340  * practice, such usage seems very unlikely, so we don't bother; we
341  * just exit as soon as we find the first candidate.
342  */
343  if (rlst)
344  break;
345  }
346 
347  return rlst;
348 }
#define NIL
Definition: pg_list.h:65
#define castNode(_type_, nodeptr)
Definition: nodes.h:605
Expr * orclause
Definition: pathnodes.h:2090
static bool is_andclause(const void *clause)
Definition: nodeFuncs.h:97
Definition: nodes.h:536
List * list_concat(List *list1, const List *list2)
Definition: list.c:530
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
Definition: restrictinfo.c:382
#define lfirst_node(type, lc)
Definition: pg_list.h:172
static List * TidQualFromRestrictInfo(PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:239
static List * TidQualFromRestrictInfoList(PlannerInfo *root, List *rlist, RelOptInfo *rel)
Definition: tidpath.c:276
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
Definition: pg_list.h:50

◆ TidRangeQualFromRestrictInfoList()

static List* TidRangeQualFromRestrictInfoList ( List rlist,
RelOptInfo rel 
)
static

Definition at line 359 of file tidpath.c.

References AMFLAG_HAS_TID_RANGE, RelOptInfo::amflags, IsTidRangeClause(), lappend(), lfirst_node, and NIL.

Referenced by create_tidscan_paths().

360 {
361  List *rlst = NIL;
362  ListCell *l;
363 
364  if ((rel->amflags & AMFLAG_HAS_TID_RANGE) == 0)
365  return NIL;
366 
367  foreach(l, rlist)
368  {
370 
371  if (IsTidRangeClause(rinfo, rel))
372  rlst = lappend(rlst, rinfo);
373  }
374 
375  return rlst;
376 }
#define NIL
Definition: pg_list.h:65
static bool IsTidRangeClause(RestrictInfo *rinfo, RelOptInfo *rel)
Definition: tidpath.c:150
uint32 amflags
Definition: pathnodes.h:728
#define lfirst_node(type, lc)
Definition: pg_list.h:172
List * lappend(List *list, void *datum)
Definition: list.c:336
#define AMFLAG_HAS_TID_RANGE
Definition: pathnodes.h:637
Definition: pg_list.h:50