open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reformat some node comments

Browse Source 
Reformat some comments in node field definitions to avoid long lines.

This makes room for per-field annotations in a future patch to
generate node support functions automatically.

Discussion: https://www.postgresql.org/message-id/c5906b07-220a-a3d4-8ff3-8ee593009424@enterprisedb.com
pull/92/head
Peter Eisentraut 3 years ago
parent 94ebf8117c
commit 835d476fd2
4 changed files with 952 additions and 400 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 3
      src/include/nodes/parsenodes.h
  2. 686
      src/include/nodes/pathnodes.h
  3. 423
      src/include/nodes/plannodes.h
  4. 240
      src/include/nodes/primnodes.h

3
src/include/nodes/parsenodes.h
Unescape View File

@ -123,7 +123,8 @@ typedef struct Query
QuerySource querySource; /* where did I come from? */
uint64 queryId; /* query identifier (can be set by plugins) */
/* query identifier (can be set by plugins) */
uint64 queryId;
bool canSetTag; /* do I set the command result tag? */

686
src/include/nodes/pathnodes.h
Unescape View File

@ -226,8 +226,8 @@ struct PlannerInfo
* even when using the hash table for lookups; this simplifies life for
* GEQO.
*/
List *join_rel_list; /* list of join-relation RelOptInfos */
struct HTAB *join_rel_hash; /* optional hashtable for join relations */
List *join_rel_list;
struct HTAB *join_rel_hash;
/*
* When doing a dynamic-programming-style join search, join_rel_level[k]
@ -329,11 +329,16 @@ struct PlannerInfo
*/
List *update_colnos;
/* Fields filled during create_plan() for use in setrefs.c */
AttrNumber *grouping_map; /* for GroupingFunc fixup */
List *minmax_aggs; /* List of MinMaxAggInfos */
/*
* Fields filled during create_plan() for use in setrefs.c
*/
/* for GroupingFunc fixup */
AttrNumber *grouping_map;
/* List of MinMaxAggInfos */
List *minmax_aggs;
MemoryContext planner_cxt; /* context holding PlannerInfo */
/* context holding PlannerInfo */
MemoryContext planner_cxt;
Cardinality total_table_pages; /* # of pages in all non-dummy tables of
* query */
@ -369,9 +374,12 @@ struct PlannerInfo
Relids curOuterRels; /* outer rels above current node */
List *curOuterParams; /* not-yet-assigned NestLoopParams */
/* These fields are workspace for setrefs.c */
bool *isAltSubplan; /* array corresponding to glob->subplans */
bool *isUsedSubplan; /* array corresponding to glob->subplans */
/*
* These fields are workspace for setrefs.c. Each is an array
* corresponding to glob->subplans.
*/
bool *isAltSubplan;
bool *isUsedSubplan;
/* optional private data for join_search_hook, e.g., GEQO */
void *join_search_private;
@ -678,21 +686,37 @@ typedef struct RelOptInfo
RelOptKind reloptkind;
/* all relations included in this RelOptInfo */
Relids relids; /* set of base relids (rangetable indexes) */
/*
* all relations included in this RelOptInfo; set of base relids
* (rangetable indexes)
*/
Relids relids;
/* size estimates generated by planner */
Cardinality rows; /* estimated number of result tuples */
/*
* size estimates generated by planner
*/
/* estimated number of result tuples */
Cardinality rows;
/* per-relation planner control flags */
bool consider_startup; /* keep cheap-startup-cost paths? */
bool consider_param_startup; /* ditto, for parameterized paths? */
bool consider_parallel; /* consider parallel paths? */
/*
* per-relation planner control flags
*/
/* keep cheap-startup-cost paths? */
bool consider_startup;
/* ditto, for parameterized paths? */
bool consider_param_startup;
/* consider parallel paths? */
bool consider_parallel;
/* default result targetlist for Paths scanning this relation */
struct PathTarget *reltarget; /* list of Vars/Exprs, cost, width */
/*
* default result targetlist for Paths scanning this relation; list of
* Vars/Exprs, cost, width
*/
struct PathTarget *reltarget;
/* materialization information */
/*
* materialization information
*/
List *pathlist; /* Path structures */
List *ppilist; /* ParamPathInfos used in pathlist */
List *partial_pathlist; /* partial Paths */
@ -701,79 +725,132 @@ typedef struct RelOptInfo
struct Path *cheapest_unique_path;
List *cheapest_parameterized_paths;
/* parameterization information needed for both base rels and join rels */
/* (see also lateral_vars and lateral_referencers) */
Relids direct_lateral_relids; /* rels directly laterally referenced */
Relids lateral_relids; /* minimum parameterization of rel */
/*
* parameterization information needed for both base rels and join rels
* (see also lateral_vars and lateral_referencers)
*/
/* rels directly laterally referenced */
Relids direct_lateral_relids;
/* minimum parameterization of rel */
Relids lateral_relids;
/* information about a base rel (not set for join rels!) */
/*
* information about a base rel (not set for join rels!)
*/
Index relid;
Oid reltablespace; /* containing tablespace */
RTEKind rtekind; /* RELATION, SUBQUERY, FUNCTION, etc */
AttrNumber min_attr; /* smallest attrno of rel (often <0) */
AttrNumber max_attr; /* largest attrno of rel */
Relids *attr_needed; /* array indexed [min_attr .. max_attr] */
int32 *attr_widths; /* array indexed [min_attr .. max_attr] */
List *lateral_vars; /* LATERAL Vars and PHVs referenced by rel */
Relids lateral_referencers; /* rels that reference me laterally */
List *indexlist; /* list of IndexOptInfo */
List *statlist; /* list of StatisticExtInfo */
BlockNumber pages; /* size estimates derived from pg_class */
/* containing tablespace */
Oid reltablespace;
/* RELATION, SUBQUERY, FUNCTION, etc */
RTEKind rtekind;
/* smallest attrno of rel (often <0) */
AttrNumber min_attr;
/* largest attrno of rel */
AttrNumber max_attr;
/* array indexed [min_attr .. max_attr] */
Relids *attr_needed;
/* array indexed [min_attr .. max_attr] */
int32 *attr_widths;
/* LATERAL Vars and PHVs referenced by rel */
List *lateral_vars;
/* rels that reference me laterally */
Relids lateral_referencers;
/* list of IndexOptInfo */
List *indexlist;
/* list of StatisticExtInfo */
List *statlist;
/* size estimates derived from pg_class */
BlockNumber pages;
Cardinality tuples;
double allvisfrac;
Bitmapset *eclass_indexes; /* Indexes in PlannerInfo's eq_classes list of
* ECs that mention this rel */
/*
* Indexes in PlannerInfo's eq_classes list of ECs that mention this rel
*/
Bitmapset *eclass_indexes;
PlannerInfo *subroot; /* if subquery */
List *subplan_params; /* if subquery */
int rel_parallel_workers; /* wanted number of parallel workers */
uint32 amflags; /* Bitmask of optional features supported by
* the table AM */
/* Information about foreign tables and foreign joins */
Oid serverid; /* identifies server for the table or join */
Oid userid; /* identifies user to check access as */
bool useridiscurrent; /* join is only valid for current user */
/* wanted number of parallel workers */
int rel_parallel_workers;
/* Bitmask of optional features supported by the table AM */
uint32 amflags;
/*
* Information about foreign tables and foreign joins
*/
/* identifies server for the table or join */
Oid serverid;
/* identifies user to check access as */
Oid userid;
/* join is only valid for current user */
bool useridiscurrent;
/* use "struct FdwRoutine" to avoid including fdwapi.h here */
struct FdwRoutine *fdwroutine;
void *fdw_private;
/* cache space for remembering if we have proven this relation unique */
List *unique_for_rels; /* known unique for these other relid
* set(s) */
List *non_unique_for_rels; /* known not unique for these set(s) */
/* used by various scans and joins: */
List *baserestrictinfo; /* RestrictInfo structures (if base rel) */
QualCost baserestrictcost; /* cost of evaluating the above */
Index baserestrict_min_security; /* min security_level found in
* baserestrictinfo */
List *joininfo; /* RestrictInfo structures for join clauses
* involving this rel */
bool has_eclass_joins; /* T means joininfo is incomplete */
/* used by partitionwise joins: */
bool consider_partitionwise_join; /* consider partitionwise join
* paths? (if partitioned rel) */
Relids top_parent_relids; /* Relids of topmost parents (if "other"
* rel) */
/* used for partitioned relations: */
PartitionScheme part_scheme; /* Partitioning scheme */
int nparts; /* Number of partitions; -1 if not yet set; in
* case of a join relation 0 means it's
* considered unpartitioned */
struct PartitionBoundInfoData *boundinfo; /* Partition bounds */
bool partbounds_merged; /* True if partition bounds were created
* by partition_bounds_merge() */
List *partition_qual; /* Partition constraint, if not the root */
struct RelOptInfo **part_rels; /* Array of RelOptInfos of partitions,
* stored in the same order as bounds */
Bitmapset *live_parts; /* Bitmap with members acting as indexes into
* the part_rels[] array to indicate which
* partitions survived partition pruning. */
Relids all_partrels; /* Relids set of all partition relids */
List **partexprs; /* Non-nullable partition key expressions */
List **nullable_partexprs; /* Nullable partition key expressions */
/*
* cache space for remembering if we have proven this relation unique
*/
/* known unique for these other relid set(s) */
List *unique_for_rels;
/* known not unique for these set(s) */
List *non_unique_for_rels;
/*
* used by various scans and joins:
*/
/* RestrictInfo structures (if base rel) */
List *baserestrictinfo;
/* cost of evaluating the above */
QualCost baserestrictcost;
/* min security_level found in baserestrictinfo */
Index baserestrict_min_security;
/* RestrictInfo structures for join clauses involving this rel */
List *joininfo;
/* T means joininfo is incomplete */
bool has_eclass_joins;
/*
* used by partitionwise joins:
*/
/* consider partitionwise join paths? (if partitioned rel) */
bool consider_partitionwise_join;
/* Relids of topmost parents (if "other" rel) */
Relids top_parent_relids;
/*
* used for partitioned relations:
*/
/* Partitioning scheme */
PartitionScheme part_scheme;
/*
* Number of partitions; -1 if not yet set; in case of a join relation 0
* means it's considered unpartitioned
*/
int nparts;
/* Partition bounds */
struct PartitionBoundInfoData *boundinfo;
/* True if partition bounds were created by partition_bounds_merge() */
bool partbounds_merged;
/* Partition constraint, if not the root */
List *partition_qual;
/*
* Array of RelOptInfos of partitions, stored in the same order as bounds
*/
struct RelOptInfo **part_rels;
/*
* Bitmap with members acting as indexes into the part_rels[] array to
* indicate which partitions survived partition pruning.
*/
Bitmapset *live_parts;
/* Relids set of all partition relids */
Relids all_partrels;
/* Non-nullable partition key expressions */
List **partexprs;
/* Nullable partition key expressions */
List **nullable_partexprs;
} RelOptInfo;
/*
@ -836,56 +913,93 @@ struct IndexOptInfo
{
NodeTag type;
Oid indexoid; /* OID of the index relation */
Oid reltablespace; /* tablespace of index (not table) */
RelOptInfo *rel; /* back-link to index's table */
/* index-size statistics (from pg_class and elsewhere) */
BlockNumber pages; /* number of disk pages in index */
Cardinality tuples; /* number of index tuples in index */
int tree_height; /* index tree height, or -1 if unknown */
/* index descriptor information */
int ncolumns; /* number of columns in index */
int nkeycolumns; /* number of key columns in index */
int *indexkeys; /* column numbers of index's attributes both
* key and included columns, or 0 */
Oid *indexcollations; /* OIDs of collations of index columns */
Oid *opfamily; /* OIDs of operator families for columns */
Oid *opcintype; /* OIDs of opclass declared input data types */
Oid *sortopfamily; /* OIDs of btree opfamilies, if orderable */
bool *reverse_sort; /* is sort order descending? */
bool *nulls_first; /* do NULLs come first in the sort order? */
bytea **opclassoptions; /* opclass-specific options for columns */
bool *canreturn; /* which index cols can be returned in an
* index-only scan? */
Oid relam; /* OID of the access method (in pg_am) */
List *indexprs; /* expressions for non-simple index columns */
List *indpred; /* predicate if a partial index, else NIL */
List *indextlist; /* targetlist representing index columns */
List *indrestrictinfo; /* parent relation's baserestrictinfo
* list, less any conditions implied by
* the index's predicate (unless it's a
* target rel, see comments in
* check_index_predicates()) */
bool predOK; /* true if index predicate matches query */
bool unique; /* true if a unique index */
bool immediate; /* is uniqueness enforced immediately? */
bool hypothetical; /* true if index doesn't really exist */
/* Remaining fields are copied from the index AM's API struct: */
bool amcanorderbyop; /* does AM support order by operator result? */
bool amoptionalkey; /* can query omit key for the first column? */
bool amsearcharray; /* can AM handle ScalarArrayOpExpr quals? */
bool amsearchnulls; /* can AM search for NULL/NOT NULL entries? */
bool amhasgettuple; /* does AM have amgettuple interface? */
bool amhasgetbitmap; /* does AM have amgetbitmap interface? */
bool amcanparallel; /* does AM support parallel scan? */
bool amcanmarkpos; /* does AM support mark/restore? */
/* OID of the index relation */
Oid indexoid;
/* tablespace of index (not table) */
Oid reltablespace;
/* back-link to index's table */
RelOptInfo *rel;
/*
* index-size statistics (from pg_class and elsewhere)
*/
/* number of disk pages in index */
BlockNumber pages;
/* number of index tuples in index */
Cardinality tuples;
/* index tree height, or -1 if unknown */
int tree_height;
/*
* index descriptor information
*/
/* number of columns in index */
int ncolumns;
/* number of key columns in index */
int nkeycolumns;
/*
* column numbers of index's attributes both key and included columns, or
* 0
*/
int *indexkeys;
/* OIDs of collations of index columns */
Oid *indexcollations;
/* OIDs of operator families for columns */
Oid *opfamily;
/* OIDs of opclass declared input data types */
Oid *opcintype;
/* OIDs of btree opfamilies, if orderable */
Oid *sortopfamily;
/* is sort order descending? */
bool *reverse_sort;
/* do NULLs come first in the sort order? */
bool *nulls_first;
/* opclass-specific options for columns */
bytea **opclassoptions;
/* which index cols can be returned in an index-only scan? */
bool *canreturn;
/* OID of the access method (in pg_am) */
Oid relam;
/* expressions for non-simple index columns */
List *indexprs;
/* predicate if a partial index, else NIL */
List *indpred;
/* targetlist representing index columns */
List *indextlist;
/*
* parent relation's baserestrictinfo list, less any conditions implied by
* the index's predicate (unless it's a target rel, see comments in
* check_index_predicates())
*/
List *indrestrictinfo;
/* true if index predicate matches query */
bool predOK;
/* true if a unique index */
bool unique;
/* is uniqueness enforced immediately? */
bool immediate;
/* true if index doesn't really exist */
bool hypothetical;
/*
* Remaining fields are copied from the index AM's API struct
* (IndexAmRoutine)
*/
bool amcanorderbyop;
bool amoptionalkey;
bool amsearcharray;
bool amsearchnulls;
/* does AM have amgettuple interface? */
bool amhasgettuple;
/* does AM have amgetbitmap interface? */
bool amhasgetbitmap;
bool amcanparallel;
/* does AM have ammarkpos interface? */
bool amcanmarkpos;
/* Rather than include amapi.h here, we declare amcostestimate like this */
void (*amcostestimate) (); /* AM's cost estimator */
};
@ -902,19 +1016,35 @@ typedef struct ForeignKeyOptInfo
{
NodeTag type;
/* Basic data about the foreign key (fetched from catalogs): */
Index con_relid; /* RT index of the referencing table */
Index ref_relid; /* RT index of the referenced table */
int nkeys; /* number of columns in the foreign key */
AttrNumber conkey[INDEX_MAX_KEYS]; /* cols in referencing table */
AttrNumber confkey[INDEX_MAX_KEYS]; /* cols in referenced table */
Oid conpfeqop[INDEX_MAX_KEYS]; /* PK = FK operator OIDs */
/* Derived info about whether FK's equality conditions match the query: */
int nmatched_ec; /* # of FK cols matched by ECs */
int nconst_ec; /* # of these ECs that are ec_has_const */
int nmatched_rcols; /* # of FK cols matched by non-EC rinfos */
int nmatched_ri; /* total # of non-EC rinfos matched to FK */
/*
* Basic data about the foreign key (fetched from catalogs):
*/
/* RT index of the referencing table */
Index con_relid;
/* RT index of the referenced table */
Index ref_relid;
/* number of columns in the foreign key */
int nkeys;
/* cols in referencing table */
AttrNumber conkey[INDEX_MAX_KEYS];
/* cols in referenced table */
AttrNumber confkey[INDEX_MAX_KEYS];
/* PK = FK operator OIDs */
Oid conpfeqop[INDEX_MAX_KEYS];
/*
* Derived info about whether FK's equality conditions match the query:
*/
/* # of FK cols matched by ECs */
int nmatched_ec;
/* # of these ECs that are ec_has_const */
int nconst_ec;
/* # of FK cols matched by non-EC rinfos */
int nmatched_rcols;
/* total # of non-EC rinfos matched to FK */
int nmatched_ri;
/* Pointer to eclass matching each column's condition, if there is one */
struct EquivalenceClass *eclass[INDEX_MAX_KEYS];
/* Pointer to eclass member for the referencing Var, if there is one */
@ -934,12 +1064,23 @@ typedef struct StatisticExtInfo
{
NodeTag type;
Oid statOid; /* OID of the statistics row */
bool inherit; /* includes child relations */
RelOptInfo *rel; /* back-link to statistic's table */
char kind; /* statistics kind of this entry */
Bitmapset *keys; /* attnums of the columns covered */
List *exprs; /* expressions */
/* OID of the statistics row */
Oid statOid;
/* includes child relations */
bool inherit;
/* back-link to statistic's table */
RelOptInfo *rel;
/* statistics kind of this entry */
char kind;
/* attnums of the columns covered */
Bitmapset *keys;
/* expressions */
List *exprs;
} StatisticExtInfo;
/*
@ -1119,12 +1260,21 @@ typedef enum VolatileFunctionStatus
typedef struct PathTarget
{
NodeTag type;
List *exprs; /* list of expressions to be computed */
Index *sortgrouprefs; /* corresponding sort/group refnos, or 0 */
QualCost cost; /* cost of evaluating the expressions */
int width; /* estimated avg width of result tuples */
VolatileFunctionStatus has_volatile_expr; /* indicates if exprs contain
* any volatile functions. */
/* list of expressions to be computed */
List *exprs;
/* corresponding sort/group refnos, or 0 */
Index *sortgrouprefs;
/* cost of evaluating the expressions */
QualCost cost;
/* estimated avg width of result tuples */
int width;
/* indicates if exprs contain any volatile functions */
VolatileFunctionStatus has_volatile_expr;
} PathTarget;
/* Convenience macro to get a sort/group refno from a PathTarget */
@ -1189,24 +1339,32 @@ typedef struct Path
{
NodeTag type;
NodeTag pathtype; /* tag identifying scan/join method */
/* tag identifying scan/join method */
NodeTag pathtype;
RelOptInfo *parent; /* the relation this path can build */
PathTarget *pathtarget; /* list of Vars/Exprs, cost, width */
/* the relation this path can build */
RelOptInfo *parent;
ParamPathInfo *param_info; /* parameterization info, or NULL if none */
/* list of Vars/Exprs, cost, width */
PathTarget *pathtarget;
bool parallel_aware; /* engage parallel-aware logic? */
bool parallel_safe; /* OK to use as part of parallel plan? */
int parallel_workers; /* desired # of workers; 0 = not parallel */
/* parameterization info, or NULL if none */
ParamPathInfo *param_info;
/* engage parallel-aware logic? */
bool parallel_aware;
/* OK to use as part of parallel plan? */
bool parallel_safe;
/* desired # of workers; 0 = not parallel */
int parallel_workers;
/* estimated size/costs for path (see costsize.c for more info) */
Cardinality rows; /* estimated number of result tuples */
Cost startup_cost; /* cost expended before fetching any tuples */
Cost total_cost; /* total cost (assuming all tuples fetched) */
List *pathkeys; /* sort ordering of path's output */
/* pathkeys is a List of PathKey nodes; see above */
/* sort ordering of path's output; a List of PathKey nodes; see above */
List *pathkeys;
} Path;
/* Macro for extracting a path's parameterization relids; beware double eval */
@ -2072,22 +2230,29 @@ typedef struct RestrictInfo
{
NodeTag type;
Expr *clause; /* the represented clause of WHERE or JOIN */
/* the represented clause of WHERE or JOIN */
Expr *clause;
bool is_pushed_down; /* true if clause was pushed down in level */
/* true if clause was pushed down in level */
bool is_pushed_down;
bool outerjoin_delayed; /* true if delayed by lower outer join */
/* true if delayed by lower outer join */
bool outerjoin_delayed;
bool can_join; /* see comment above */
/* see comment above */
bool can_join;
bool pseudoconstant; /* see comment above */
/* see comment above */
bool pseudoconstant;
bool leakproof; /* true if known to contain no leaked Vars */
/* true if known to contain no leaked Vars */
bool leakproof;
VolatileFunctionStatus has_volatile; /* to indicate if clause contains
* any volatile functions. */
/* to indicate if clause contains any volatile functions. */
VolatileFunctionStatus has_volatile;
Index security_level; /* see comment above */
/* see comment above */
Index security_level;
/* The set of relids (varnos) actually referenced in the clause: */
Relids clause_relids;
@ -2101,45 +2266,84 @@ typedef struct RestrictInfo
/* The relids used in the clause that are nullable by lower outer joins: */
Relids nullable_relids;
/* These fields are set for any binary opclause: */
Relids left_relids; /* relids in left side of clause */
Relids right_relids; /* relids in right side of clause */
/*
* Relids in the left/right side of the clause. These fields are set for
* any binary opclause.
*/
Relids left_relids;
Relids right_relids;
/* This field is NULL unless clause is an OR clause: */
Expr *orclause; /* modified clause with RestrictInfos */
/*
* Modified clause with RestrictInfos. This field is NULL unless clause
* is an OR clause.
*/
Expr *orclause;
/* This field is NULL unless clause is potentially redundant: */
EquivalenceClass *parent_ec; /* generating EquivalenceClass */
/*
* Generating EquivalenceClass. This field is NULL unless clause is
* potentially redundant.
*/
EquivalenceClass *parent_ec;
/* cache space for cost and selectivity */
QualCost eval_cost; /* eval cost of clause; -1 if not yet set */
Selectivity norm_selec; /* selectivity for "normal" (JOIN_INNER)
* semantics; -1 if not yet set; >1 means a
* redundant clause */
Selectivity outer_selec; /* selectivity for outer join semantics; -1 if
* not yet set */
/*
* cache space for cost and selectivity
*/
/* valid if clause is mergejoinable, else NIL */
List *mergeopfamilies; /* opfamilies containing clause operator */
/* eval cost of clause; -1 if not yet set */
QualCost eval_cost;
/* cache space for mergeclause processing; NULL if not yet set */
EquivalenceClass *left_ec; /* EquivalenceClass containing lefthand */
EquivalenceClass *right_ec; /* EquivalenceClass containing righthand */
EquivalenceMember *left_em; /* EquivalenceMember for lefthand */
EquivalenceMember *right_em; /* EquivalenceMember for righthand */
List *scansel_cache; /* list of MergeScanSelCache structs */
/*
* selectivity for "normal" (JOIN_INNER) semantics; -1 if not yet set; >1
* means a redundant clause
*/
Selectivity norm_selec;
/* selectivity for outer join semantics; -1 if not yet set */
Selectivity outer_selec;
/*
* opfamilies containing clause operator; valid if clause is
* mergejoinable, else NIL
*/
List *mergeopfamilies;
/* transient workspace for use while considering a specific join path */
bool outer_is_left; /* T = outer var on left, F = on right */
/*
* cache space for mergeclause processing; NULL if not yet set
*/
/* valid if clause is hashjoinable, else InvalidOid: */
Oid hashjoinoperator; /* copy of clause operator */
/* EquivalenceClass containing lefthand */
EquivalenceClass *left_ec;
/* EquivalenceClass containing righthand */
EquivalenceClass *right_ec;
/* EquivalenceMember for lefthand */
EquivalenceMember *left_em;
/* EquivalenceMember for righthand */
EquivalenceMember *right_em;
/* list of MergeScanSelCache structs */
List *scansel_cache;
/* cache space for hashclause processing; -1 if not yet set */
Selectivity left_bucketsize; /* avg bucketsize of left side */
Selectivity right_bucketsize; /* avg bucketsize of right side */
Selectivity left_mcvfreq; /* left side's most common val's freq */
Selectivity right_mcvfreq; /* right side's most common val's freq */
/*
* transient workspace for use while considering a specific join path; T =
* outer var on left, F = on right
*/
bool outer_is_left;
/*
* copy of clause operator; valid if clause is hashjoinable, else
* InvalidOid
*/
Oid hashjoinoperator;
/*
* cache space for hashclause processing; -1 if not yet set
*/
/* avg bucketsize of left side */
Selectivity left_bucketsize;
/* avg bucketsize of right side */
Selectivity right_bucketsize;
/* left side's most common val's freq */
Selectivity left_mcvfreq;
/* right side's most common val's freq */
Selectivity right_mcvfreq;
/* hash equality operators used for memoize nodes, else InvalidOid */
Oid left_hasheqoperator;
@ -2198,10 +2402,18 @@ typedef struct MergeScanSelCache
typedef struct PlaceHolderVar
{
Expr xpr;
Expr *phexpr; /* the represented expression */
Relids phrels; /* base relids syntactically within expr src */
Index phid; /* ID for PHV (unique within planner run) */
Index phlevelsup; /* > 0 if PHV belongs to outer query */
/* the represented expression */
Expr *phexpr;
/* base relids syntactically within expr src */
Relids phrels;
/* ID for PHV (unique within planner run) */
Index phid;
/* > 0 if PHV belongs to outer query */
Index phlevelsup;
} PlaceHolderVar;
/*
@ -2360,7 +2572,7 @@ typedef struct AppendRelInfo
* child column is dropped or doesn't exist in the parent.
*/
int num_child_cols; /* length of array */
AttrNumber *parent_colnos; /* array of parent attnos, or zeroes */
AttrNumber *parent_colnos;
/*
* We store the parent table's OID here for inheritance, or InvalidOid for
@ -2428,12 +2640,23 @@ typedef struct PlaceHolderInfo
{
NodeTag type;
Index phid; /* ID for PH (unique within planner run) */
PlaceHolderVar *ph_var; /* copy of PlaceHolderVar tree */
Relids ph_eval_at; /* lowest level we can evaluate value at */
Relids ph_lateral; /* relids of contained lateral refs, if any */
Relids ph_needed; /* highest level the value is needed at */
int32 ph_width; /* estimated attribute width */
/* ID for PH (unique within planner run) */
Index phid;
/* copy of PlaceHolderVar tree */
PlaceHolderVar *ph_var;
/* lowest level we can evaluate value at */
Relids ph_eval_at;
/* relids of contained lateral refs, if any */
Relids ph_lateral;
/* highest level the value is needed at */
Relids ph_needed;
/* estimated attribute width */
int32 ph_width;
} PlaceHolderInfo;
/*
@ -2445,13 +2668,26 @@ typedef struct MinMaxAggInfo
{
NodeTag type;
Oid aggfnoid; /* pg_proc Oid of the aggregate */
Oid aggsortop; /* Oid of its sort operator */
Expr *target; /* expression we are aggregating on */
PlannerInfo *subroot; /* modified "root" for planning the subquery */
Path *path; /* access path for subquery */
Cost pathcost; /* estimated cost to fetch first row */
Param *param; /* param for subplan's output */
/* pg_proc Oid of the aggregate */
Oid aggfnoid;
/* Oid of its sort operator */
Oid aggsortop;
/* expression we are aggregating on */
Expr *target;
/* modified "root" for planning the subquery */
PlannerInfo *subroot;
/* access path for subquery */
Path *path;
/* estimated cost to fetch first row */
Cost pathcost;
/* param for subplan's output */
Param *param;
} MinMaxAggInfo;
/*

423
src/include/nodes/plannodes.h
Unescape View File

@ -274,14 +274,29 @@ typedef struct Append
typedef struct MergeAppend
{
Plan plan;
Bitmapset *apprelids; /* RTIs of appendrel(s) formed by this node */
/* RTIs of appendrel(s) formed by this node */
Bitmapset *apprelids;
List *mergeplans;
/* these fields are just like the sort-key info in struct Sort: */
int numCols; /* number of sort-key columns */
AttrNumber *sortColIdx; /* their indexes in the target list */
Oid *sortOperators; /* OIDs of operators to sort them by */
Oid *collations; /* OIDs of collations */
bool *nullsFirst; /* NULLS FIRST/LAST directions */
/* number of sort-key columns */
int numCols;
/* their indexes in the target list */
AttrNumber *sortColIdx;
/* OIDs of operators to sort them by */
Oid *sortOperators;
/* OIDs of collations */
Oid *collations;
/* NULLS FIRST/LAST directions */
bool *nullsFirst;
/* Info for run-time subplan pruning; NULL if we're not doing that */
struct PartitionPruneInfo *part_prune_info;
} MergeAppend;
@ -297,14 +312,24 @@ typedef struct MergeAppend
typedef struct RecursiveUnion
{
Plan plan;
int wtParam; /* ID of Param representing work table */
/* ID of Param representing work table */
int wtParam;
/* Remaining fields are zero/null in UNION ALL case */
int numCols; /* number of columns to check for
* duplicate-ness */
AttrNumber *dupColIdx; /* their indexes in the target list */
Oid *dupOperators; /* equality operators to compare with */
/* number of columns to check for duplicate-ness */
int numCols;
/* their indexes in the target list */
AttrNumber *dupColIdx;
/* equality operators to compare with */
Oid *dupOperators;
Oid *dupCollations;
long numGroups; /* estimated number of groups in input */
/* estimated number of groups in input */
long numGroups;
} RecursiveUnion;
/* ----------------
@ -777,13 +802,26 @@ typedef struct NestLoopParam
typedef struct MergeJoin
{
Join join;
bool skip_mark_restore; /* Can we skip mark/restore calls? */
List *mergeclauses; /* mergeclauses as expression trees */
/* Can we skip mark/restore calls? */
bool skip_mark_restore;
/* mergeclauses as expression trees */
List *mergeclauses;
/* these are arrays, but have the same length as the mergeclauses list: */
Oid *mergeFamilies; /* per-clause OIDs of btree opfamilies */
Oid *mergeCollations; /* per-clause OIDs of collations */
int *mergeStrategies; /* per-clause ordering (ASC or DESC) */
bool *mergeNullsFirst; /* per-clause nulls ordering */
/* per-clause OIDs of btree opfamilies */
Oid *mergeFamilies;
/* per-clause OIDs of collations */
Oid *mergeCollations;
/* per-clause ordering (ASC or DESC) */
int *mergeStrategies;
/* per-clause nulls ordering */
bool *mergeNullsFirst;
} MergeJoin;
/* ----------------
@ -821,21 +859,38 @@ typedef struct Memoize
{
Plan plan;
int numKeys; /* size of the two arrays below */
Oid *hashOperators; /* hash operators for each key */
Oid *collations; /* collations for each key */
List *param_exprs; /* cache keys in the form of exprs containing
* parameters */
bool singlerow; /* true if the cache entry should be marked as
* complete after we store the first tuple in
* it. */
bool binary_mode; /* true when cache key should be compared bit
* by bit, false when using hash equality ops */
uint32 est_entries; /* The maximum number of entries that the
* planner expects will fit in the cache, or 0
* if unknown */
Bitmapset *keyparamids; /* paramids from param_exprs */
/* size of the two arrays below */
int numKeys;
/* hash operators for each key */
Oid *hashOperators;
/* collations for each key */
Oid *collations;
/* cache keys in the form of exprs containing parameters */
List *param_exprs;
/*
* true if the cache entry should be marked as complete after we store the
* first tuple in it.
*/
bool singlerow;
/*
* true when cache key should be compared bit by bit, false when using
* hash equality ops
*/
bool binary_mode;
/*
* The maximum number of entries that the planner expects will fit in the
* cache, or 0 if unknown
*/
uint32 est_entries;
/* paramids from param_exprs */
Bitmapset *keyparamids;
} Memoize;
/* ----------------
@ -845,11 +900,21 @@ typedef struct Memoize
typedef struct Sort
{
Plan plan;
int numCols; /* number of sort-key columns */
AttrNumber *sortColIdx; /* their indexes in the target list */
Oid *sortOperators; /* OIDs of operators to sort them by */
Oid *collations; /* OIDs of collations */
bool *nullsFirst; /* NULLS FIRST/LAST directions */
/* number of sort-key columns */
int numCols;
/* their indexes in the target list */
AttrNumber *sortColIdx;
/* OIDs of operators to sort them by */
Oid *sortOperators;
/* OIDs of collations */
Oid *collations;
/* NULLS FIRST/LAST directions */
bool *nullsFirst;
} Sort;
/* ----------------
@ -871,9 +936,15 @@ typedef struct IncrementalSort
typedef struct Group
{
Plan plan;
int numCols; /* number of grouping columns */
AttrNumber *grpColIdx; /* their indexes in the target list */
Oid *grpOperators; /* equality operators to compare with */
/* number of grouping columns */
int numCols;
/* their indexes in the target list */
AttrNumber *grpColIdx;
/* equality operators to compare with */
Oid *grpOperators;
Oid *grpCollations;
} Group;
@ -894,18 +965,39 @@ typedef struct Group
typedef struct Agg
{
Plan plan;
AggStrategy aggstrategy; /* basic strategy, see nodes.h */
AggSplit aggsplit; /* agg-splitting mode, see nodes.h */
int numCols; /* number of grouping columns */
AttrNumber *grpColIdx; /* their indexes in the target list */
Oid *grpOperators; /* equality operators to compare with */
/* basic strategy, see nodes.h */
AggStrategy aggstrategy;
/* agg-splitting mode, see nodes.h */
AggSplit aggsplit;
/* number of grouping columns */
int numCols;
/* their indexes in the target list */
AttrNumber *grpColIdx;
/* equality operators to compare with */
Oid *grpOperators;
Oid *grpCollations;
long numGroups; /* estimated number of groups in input */
uint64 transitionSpace; /* for pass-by-ref transition data */
Bitmapset *aggParams; /* IDs of Params used in Aggref inputs */
/* estimated number of groups in input */
long numGroups;
/* for pass-by-ref transition data */
uint64 transitionSpace;
/* IDs of Params used in Aggref inputs */
Bitmapset *aggParams;
/* Note: planner provides numGroups & aggParams only in HASHED/MIXED case */
List *groupingSets; /* grouping sets to use */
List *chain; /* chained Agg/Sort nodes */
/* grouping sets to use */
List *groupingSets;
/* chained Agg/Sort nodes */
List *chain;
} Agg;
/* ----------------
@ -915,28 +1007,71 @@ typedef struct Agg
typedef struct WindowAgg
{
Plan plan;
Index winref; /* ID referenced by window functions */
int partNumCols; /* number of columns in partition clause */
AttrNumber *partColIdx; /* their indexes in the target list */
Oid *partOperators; /* equality operators for partition columns */
Oid *partCollations; /* collations for partition columns */
int ordNumCols; /* number of columns in ordering clause */
AttrNumber *ordColIdx; /* their indexes in the target list */
Oid *ordOperators; /* equality operators for ordering columns */
Oid *ordCollations; /* collations for ordering columns */
int frameOptions; /* frame_clause options, see WindowDef */
Node *startOffset; /* expression for starting bound, if any */
Node *endOffset; /* expression for ending bound, if any */
List *runCondition; /* qual to help short-circuit execution */
List *runConditionOrig; /* runCondition for display in EXPLAIN */
/* ID referenced by window functions */
Index winref;
/* number of columns in partition clause */
int partNumCols;
/* their indexes in the target list */
AttrNumber *partColIdx;
/* equality operators for partition columns */
Oid *partOperators;
/* collations for partition columns */
Oid *partCollations;
/* number of columns in ordering clause */
int ordNumCols;
/* their indexes in the target list */
AttrNumber *ordColIdx;
/* equality operators for ordering columns */
Oid *ordOperators;
/* collations for ordering columns */
Oid *ordCollations;
/* frame_clause options, see WindowDef */
int frameOptions;
/* expression for starting bound, if any */
Node *startOffset;
/* expression for ending bound, if any */
Node *endOffset;
/* qual to help short-circuit execution */
List *runCondition;
/* runCondition for display in EXPLAIN */
List *runConditionOrig;
/* these fields are used with RANGE offset PRECEDING/FOLLOWING: */
Oid startInRangeFunc; /* in_range function for startOffset */
Oid endInRangeFunc; /* in_range function for endOffset */
Oid inRangeColl; /* collation for in_range tests */
bool inRangeAsc; /* use ASC sort order for in_range tests? */
bool inRangeNullsFirst; /* nulls sort first for in_range tests? */
bool topWindow; /* false for all apart from the WindowAgg
* that's closest to the root of the plan */
/* in_range function for startOffset */
Oid startInRangeFunc;
/* in_range function for endOffset */
Oid endInRangeFunc;
/* collation for in_range tests */
Oid inRangeColl;
/* use ASC sort order for in_range tests? */
bool inRangeAsc;
/* nulls sort first for in_range tests? */
bool inRangeNullsFirst;
/*
* false for all apart from the WindowAgg that's closest to the root of
* the plan
*/
bool topWindow;
} WindowAgg;
/* ----------------
@ -946,10 +1081,18 @@ typedef struct WindowAgg
typedef struct Unique
{
Plan plan;
int numCols; /* number of columns to check for uniqueness */
AttrNumber *uniqColIdx; /* their indexes in the target list */
Oid *uniqOperators; /* equality operators to compare with */
Oid *uniqCollations; /* collations for equality comparisons */
/* number of columns to check for uniqueness */
int numCols;
/* their indexes in the target list */
AttrNumber *uniqColIdx;
/* equality operators to compare with */
Oid *uniqOperators;
/* collations for equality comparisons */
Oid *uniqCollations;
} Unique;
/* ------------
@ -981,16 +1124,35 @@ typedef struct Gather
typedef struct GatherMerge
{
Plan plan;
int num_workers; /* planned number of worker processes */
int rescan_param; /* ID of Param that signals a rescan, or -1 */
/* planned number of worker processes */
int num_workers;
/* ID of Param that signals a rescan, or -1 */
int rescan_param;
/* remaining fields are just like the sort-key info in struct Sort */
int numCols; /* number of sort-key columns */
AttrNumber *sortColIdx; /* their indexes in the target list */
Oid *sortOperators; /* OIDs of operators to sort them by */
Oid *collations; /* OIDs of collations */
bool *nullsFirst; /* NULLS FIRST/LAST directions */
Bitmapset *initParam; /* param id's of initplans which are referred
* at gather merge or one of it's child node */
/* number of sort-key columns */
int numCols;
/* their indexes in the target list */
AttrNumber *sortColIdx;
/* OIDs of operators to sort them by */
Oid *sortOperators;
/* OIDs of collations */
Oid *collations;
/* NULLS FIRST/LAST directions */
bool *nullsFirst;
/*
* param id's of initplans which are referred at gather merge or one of
* it's child node
*/
Bitmapset *initParam;
} GatherMerge;
/* ----------------
@ -1024,16 +1186,31 @@ typedef struct Hash
typedef struct SetOp
{
Plan plan;
SetOpCmd cmd; /* what to do, see nodes.h */
SetOpStrategy strategy; /* how to do it, see nodes.h */
int numCols; /* number of columns to check for
* duplicate-ness */
AttrNumber *dupColIdx; /* their indexes in the target list */
Oid *dupOperators; /* equality operators to compare with */
/* what to do, see nodes.h */
SetOpCmd cmd;
/* how to do it, see nodes.h */
SetOpStrategy strategy;
/* number of columns to check for duplicate-ness */
int numCols;
/* their indexes in the target list */
AttrNumber *dupColIdx;
/* equality operators to compare with */
Oid *dupOperators;
Oid *dupCollations;
AttrNumber flagColIdx; /* where is the flag column, if any */
int firstFlag; /* flag value for first input relation */
long numGroups; /* estimated number of groups in input */
/* where is the flag column, if any */
AttrNumber flagColIdx;
/* flag value for first input relation */
int firstFlag;
/* estimated number of groups in input */
long numGroups;
} SetOp;
/* ----------------
@ -1062,13 +1239,27 @@ typedef struct LockRows
typedef struct Limit
{
Plan plan;
Node *limitOffset; /* OFFSET parameter, or NULL if none */
Node *limitCount; /* COUNT parameter, or NULL if none */
LimitOption limitOption; /* limit type */
int uniqNumCols; /* number of columns to check for similarity */
AttrNumber *uniqColIdx; /* their indexes in the target list */
Oid *uniqOperators; /* equality operators to compare with */
Oid *uniqCollations; /* collations for equality comparisons */
/* OFFSET parameter, or NULL if none */
Node *limitOffset;
/* COUNT parameter, or NULL if none */
Node *limitCount;
/* limit type */
LimitOption limitOption;
/* number of columns to check for similarity */
int uniqNumCols;
/* their indexes in the target list */
AttrNumber *uniqColIdx;
/* equality operators to compare with */
Oid *uniqOperators;
/* collations for equality comparisons */
Oid *uniqCollations;
} Limit;
@ -1223,13 +1414,24 @@ typedef struct PartitionPruneInfo
typedef struct PartitionedRelPruneInfo
{
NodeTag type;
Index rtindex; /* RT index of partition rel for this level */
Bitmapset *present_parts; /* Indexes of all partitions which subplans or
* subparts are present for */
int nparts; /* Length of the following arrays: */
int *subplan_map; /* subplan index by partition index, or -1 */
int *subpart_map; /* subpart index by partition index, or -1 */
Oid *relid_map; /* relation OID by partition index, or 0 */
/* RT index of partition rel for this level */
Index rtindex;
/* Indexes of all partitions which subplans or subparts are present for */
Bitmapset *present_parts;
/* Length of the following arrays: */
int nparts;
/* subplan index by partition index, or -1 */
int *subplan_map;
/* subpart index by partition index, or -1 */
int *subpart_map;
/* relation OID by partition index, or 0 */
Oid *relid_map;
/*
* initial_pruning_steps shows how to prune during executor startup (i.e.,
@ -1239,8 +1441,9 @@ typedef struct PartitionedRelPruneInfo
*/
List *initial_pruning_steps; /* List of PartitionPruneStep */
List *exec_pruning_steps; /* List of PartitionPruneStep */
Bitmapset *execparamids; /* All PARAM_EXEC Param IDs in
* exec_pruning_steps */
/* All PARAM_EXEC Param IDs in exec_pruning_steps */
Bitmapset *execparamids;
} PartitionedRelPruneInfo;
/*

240
src/include/nodes/primnodes.h
Unescape View File

@ -63,14 +63,27 @@ typedef enum OnCommitAction
typedef struct RangeVar
{
NodeTag type;
char *catalogname; /* the catalog (database) name, or NULL */
char *schemaname; /* the schema name, or NULL */
char *relname; /* the relation/sequence name */
bool inh; /* expand rel by inheritance? recursively act
* on children? */
char relpersistence; /* see RELPERSISTENCE_* in pg_class.h */
Alias *alias; /* table alias & optional column aliases */
int location; /* token location, or -1 if unknown */
/* the catalog (database) name, or NULL */
char *catalogname;
/* the schema name, or NULL */
char *schemaname;
/* the relation/sequence name */
char *relname;
/* expand rel by inheritance? recursively act on children? */
bool inh;
/* see RELPERSISTENCE_* in pg_class.h */
char relpersistence;
/* table alias & optional column aliases */
Alias *alias;
/* token location, or -1 if unknown */
int location;
} RangeVar;
typedef enum TableFuncType
@ -195,19 +208,38 @@ typedef struct Expr
typedef struct Var
{
Expr xpr;
int varno; /* index of this var's relation in the range
* table, or INNER_VAR/OUTER_VAR/etc */
AttrNumber varattno; /* attribute number of this var, or zero for
* all attrs ("whole-row Var") */
Oid vartype; /* pg_type OID for the type of this var */
int32 vartypmod; /* pg_attribute typmod value */
Oid varcollid; /* OID of collation, or InvalidOid if none */
Index varlevelsup; /* for subquery variables referencing outer
* relations; 0 in a normal var, >0 means N
* levels up */
Index varnosyn; /* syntactic relation index (0 if unknown) */
AttrNumber varattnosyn; /* syntactic attribute number */
int location; /* token location, or -1 if unknown */
/*
* index of this var's relation in the range table, or
* INNER_VAR/OUTER_VAR/etc
*/
int varno;
/*
* attribute number of this var, or zero for all attrs ("whole-row Var")
*/
AttrNumber varattno;
/* pg_type OID for the type of this var */
Oid vartype;
/* pg_attribute typmod value */
int32 vartypmod;
/* OID of collation, or InvalidOid if none */
Oid varcollid;
/*
* for subquery variables referencing outer relations; 0 in a normal var,
* >0 means N levels up
*/
Index varlevelsup;
/* syntactic relation index (0 if unknown) */
Index varnosyn;
/* syntactic attribute number */
AttrNumber varattnosyn;
/* token location, or -1 if unknown */
int location;
} Var;
/*
@ -329,26 +361,66 @@ typedef struct Param
typedef struct Aggref
{
Expr xpr;
Oid aggfnoid; /* pg_proc Oid of the aggregate */
Oid aggtype; /* type Oid of result of the aggregate */
Oid aggcollid; /* OID of collation of result */
Oid inputcollid; /* OID of collation that function should use */
Oid aggtranstype; /* type Oid of aggregate's transition value */
List *aggargtypes; /* type Oids of direct and aggregated args */
List *aggdirectargs; /* direct arguments, if an ordered-set agg */
List *args; /* aggregated arguments and sort expressions */
List *aggorder; /* ORDER BY (list of SortGroupClause) */
List *aggdistinct; /* DISTINCT (list of SortGroupClause) */
Expr *aggfilter; /* FILTER expression, if any */
bool aggstar; /* true if argument list was really '*' */
bool aggvariadic; /* true if variadic arguments have been
* combined into an array last argument */
char aggkind; /* aggregate kind (see pg_aggregate.h) */
Index agglevelsup; /* > 0 if agg belongs to outer query */
AggSplit aggsplit; /* expected agg-splitting mode of parent Agg */
int aggno; /* unique ID within the Agg node */
int aggtransno; /* unique ID of transition state in the Agg */
int location; /* token location, or -1 if unknown */
/* pg_proc Oid of the aggregate */
Oid aggfnoid;
/* type Oid of result of the aggregate */
Oid aggtype;
/* OID of collation of result */
Oid aggcollid;
/* OID of collation that function should use */
Oid inputcollid;
/* type Oid of aggregate's transition value */
Oid aggtranstype;
/* type Oids of direct and aggregated args */
List *aggargtypes;
/* direct arguments, if an ordered-set agg */
List *aggdirectargs;
/* aggregated arguments and sort expressions */
List *args;
/* ORDER BY (list of SortGroupClause) */
List *aggorder;
/* DISTINCT (list of SortGroupClause) */
List *aggdistinct;
/* FILTER expression, if any */
Expr *aggfilter;
/* true if argument list was really '*' */
bool aggstar;
/*
* true if variadic arguments have been combined into an array last
* argument
*/
bool aggvariadic;
/* aggregate kind (see pg_aggregate.h) */
char aggkind;
/* > 0 if agg belongs to outer query */
Index agglevelsup;
/* expected agg-splitting mode of parent Agg */
AggSplit aggsplit;
/* unique ID within the Agg node */
int aggno;
/* unique ID of transition state in the Agg */
int aggtransno;
/* token location, or -1 if unknown */
int location;
} Aggref;
/*
@ -378,12 +450,21 @@ typedef struct Aggref
typedef struct GroupingFunc
{
Expr xpr;
List *args; /* arguments, not evaluated but kept for
* benefit of EXPLAIN etc. */
List *refs; /* ressortgrouprefs of arguments */
List *cols; /* actual column positions set by planner */
Index agglevelsup; /* same as Aggref.agglevelsup */
int location; /* token location */
/* arguments, not evaluated but kept for benefit of EXPLAIN etc. */
List *args;
/* ressortgrouprefs of arguments */
List *refs;
/* actual column positions set by planner */
List *cols;
/* same as Aggref.agglevelsup */
Index agglevelsup;
/* token location */
int location;
} GroupingFunc;
/*
@ -548,14 +629,30 @@ typedef struct NamedArgExpr
typedef struct OpExpr
{
Expr xpr;
Oid opno; /* PG_OPERATOR OID of the operator */
Oid opfuncid; /* PG_PROC OID of underlying function */
Oid opresulttype; /* PG_TYPE OID of result value */
bool opretset; /* true if operator returns set */
Oid opcollid; /* OID of collation of result */
Oid inputcollid; /* OID of collation that operator should use */
List *args; /* arguments to the operator (1 or 2) */
int location; /* token location, or -1 if unknown */
/* PG_OPERATOR OID of the operator */
Oid opno;
/* PG_PROC OID of underlying function */
Oid opfuncid;
/* PG_TYPE OID of result value */
Oid opresulttype;
/* true if operator returns set */
bool opretset;
/* OID of collation of result */
Oid opcollid;
/* OID of collation that operator should use */
Oid inputcollid;
/* arguments to the operator (1 or 2) */
List *args;
/* token location, or -1 if unknown */
int location;
} OpExpr;
/*
@ -605,15 +702,30 @@ typedef OpExpr NullIfExpr;
typedef struct ScalarArrayOpExpr
{
Expr xpr;
Oid opno; /* PG_OPERATOR OID of the operator */
Oid opfuncid; /* PG_PROC OID of comparison function */
Oid hashfuncid; /* PG_PROC OID of hash func or InvalidOid */
Oid negfuncid; /* PG_PROC OID of negator of opfuncid function
* or InvalidOid. See above */
bool useOr; /* true for ANY, false for ALL */
Oid inputcollid; /* OID of collation that operator should use */
List *args; /* the scalar and array operands */
int location; /* token location, or -1 if unknown */
/* PG_OPERATOR OID of the operator */
Oid opno;
/* PG_PROC OID of comparison function */
Oid opfuncid;
/* PG_PROC OID of hash func or InvalidOid */
Oid hashfuncid;
/* PG_PROC OID of negator of opfuncid function or InvalidOid. See above */
Oid negfuncid;
/* true for ANY, false for ALL */
bool useOr;
/* OID of collation that operator should use */
Oid inputcollid;
/* the scalar and array operands */
List *args;
/* token location, or -1 if unknown */
int location;
} ScalarArrayOpExpr;
/*

Write Preview
Loading…
Cancel
Save