granicus.if.org Git - postgresql/blob - src/include/nodes/primnodes.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * primnodes.h
   4  *        Definitions for "primitive" node types, those that are used in more
   5  *        than one of the parse/plan/execute stages of the query pipeline.
   6  *        Currently, these are mostly nodes for executable expressions
   7  *        and join trees.
   8  *
   9  *
  10  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  11  * Portions Copyright (c) 1994, Regents of the University of California
  12  *
  13  * $Id: primnodes.h,v 1.77 2003/01/10 21:08:15 tgl Exp $
  14  *
  15  *-------------------------------------------------------------------------
  16  */
  17 #ifndef PRIMNODES_H
  18 #define PRIMNODES_H
  19
  20 #include "access/attnum.h"
  21 #include "nodes/pg_list.h"
  22
  23
  24 /* ----------------------------------------------------------------
  25  *                                              node definitions
  26  * ----------------------------------------------------------------
  27  */
  28
  29 /*--------------------
  30  * Resdom (Result Domain)
  31  *
  32  * Notes:
  33  * ressortgroupref is the parse/plan-time representation of ORDER BY and
  34  * GROUP BY items.      Targetlist entries with ressortgroupref=0 are not
  35  * sort/group items.  If ressortgroupref>0, then this item is an ORDER BY or
  36  * GROUP BY value.      No two entries in a targetlist may have the same nonzero
  37  * ressortgroupref --- but there is no particular meaning to the nonzero
  38  * values, except as tags.      (For example, one must not assume that lower
  39  * ressortgroupref means a more significant sort key.)  The order of the
  40  * associated SortClause or GroupClause lists determine the semantics.
  41  *
  42  * reskey and reskeyop are the execution-time representation of sorting.
  43  * reskey must be zero in any non-sort-key item.  The reskey of sort key
  44  * targetlist items for a sort plan node is 1,2,...,n for the n sort keys.
  45  * The reskeyop of each such targetlist item is the sort operator's OID.
  46  * reskeyop will be zero in non-sort-key items.
  47  *
  48  * Both reskey and reskeyop are typically zero during parse/plan stages.
  49  * The executor does not pay any attention to ressortgroupref.
  50  *--------------------
  51  */
  52 typedef struct Resdom
  53 {
  54         NodeTag         type;
  55         AttrNumber      resno;                  /* attribute number */
  56         Oid                     restype;                /* type of the value */
  57         int32           restypmod;              /* type-specific modifier of the value */
  58         char       *resname;            /* name of the resdom (could be NULL) */
  59         Index           ressortgroupref;
  60         /* nonzero if referenced by a sort/group clause */
  61         Index           reskey;                 /* order of key in a sort (for those > 0) */
  62         Oid                     reskeyop;               /* sort operator's Oid */
  63         bool            resjunk;                /* set to true to eliminate the attribute
  64                                                                  * from final target list */
  65 } Resdom;
  66
  67
  68 /*
  69  * Alias -
  70  *        specifies an alias for a range variable; the alias might also
  71  *        specify renaming of columns within the table.
  72  */
  73 typedef struct Alias
  74 {
  75         NodeTag         type;
  76         char       *aliasname;          /* aliased rel name (never qualified) */
  77         List       *colnames;           /* optional list of column aliases */
  78         /* Note: colnames is a list of Value nodes (always strings) */
  79 } Alias;
  80
  81 typedef enum InhOption
  82 {
  83         INH_NO,                                         /* Do NOT scan child tables */
  84         INH_YES,                                        /* DO scan child tables */
  85         INH_DEFAULT                                     /* Use current SQL_inheritance option */
  86 } InhOption;
  87
  88 /*
  89  * RangeVar - range variable, used in FROM clauses
  90  *
  91  * Also used to represent table names in utility statements; there, the alias
  92  * field is not used, and inhOpt shows whether to apply the operation
  93  * recursively to child tables.  In some contexts it is also useful to carry
  94  * a TEMP table indication here.
  95  */
  96 typedef struct RangeVar
  97 {
  98         NodeTag         type;
  99         char       *catalogname;        /* the catalog (database) name, or NULL */
 100         char       *schemaname;         /* the schema name, or NULL */
 101         char       *relname;            /* the relation/sequence name */
 102         InhOption       inhOpt;                 /* expand rel by inheritance? recursively
 103                                                                  * act on children? */
 104         bool            istemp;                 /* is this a temp relation/sequence? */
 105         Alias      *alias;                      /* table alias & optional column aliases */
 106 } RangeVar;
 107
 108
 109 /* ----------------------------------------------------------------
 110  *                                      node types for executable expressions
 111  * ----------------------------------------------------------------
 112  */
 113
 114 /*
 115  * Expr - generic superclass for executable-expression nodes
 116  *
 117  * All node types that are used in executable expression trees should derive
 118  * from Expr (that is, have Expr as their first field).  Since Expr only
 119  * contains NodeTag, this is a formality, but it is an easy form of
 120  * documentation.  See also the ExprState node types in execnodes.h.
 121  */
 122 typedef struct Expr
 123 {
 124         NodeTag         type;
 125 } Expr;
 126
 127 /*
 128  * Var - expression node representing a variable (ie, a table column)
 129  *
 130  * Note: during parsing/planning, varnoold/varoattno are always just copies
 131  * of varno/varattno.  At the tail end of planning, Var nodes appearing in
 132  * upper-level plan nodes are reassigned to point to the outputs of their
 133  * subplans; for example, in a join node varno becomes INNER or OUTER and
 134  * varattno becomes the index of the proper element of that subplan's target
 135  * list.  But varnoold/varoattno continue to hold the original values.
 136  * The code doesn't really need varnoold/varoattno, but they are very useful
 137  * for debugging and interpreting completed plans, so we keep them around.
 138  */
 139 #define    INNER                65000
 140 #define    OUTER                65001
 141
 142 #define    PRS2_OLD_VARNO                       1
 143 #define    PRS2_NEW_VARNO                       2
 144
 145 typedef struct Var
 146 {
 147         Expr            xpr;
 148         Index           varno;                  /* index of this var's relation in the
 149                                                                  * range table (could also be INNER or
 150                                                                  * OUTER) */
 151         AttrNumber      varattno;               /* attribute number of this var, or zero
 152                                                                  * for all */
 153         Oid                     vartype;                /* pg_type tuple OID for the type of this
 154                                                                  * var */
 155         int32           vartypmod;              /* pg_attribute typmod value */
 156         Index           varlevelsup;
 157
 158         /*
 159          * for subquery variables referencing outer relations; 0 in a normal
 160          * var, >0 means N levels up
 161          */
 162         Index           varnoold;               /* original value of varno, for debugging */
 163         AttrNumber      varoattno;              /* original value of varattno */
 164 } Var;
 165
 166 /*
 167  * Const
 168  */
 169 typedef struct Const
 170 {
 171         Expr            xpr;
 172         Oid                     consttype;              /* PG_TYPE OID of the constant's datatype */
 173         int                     constlen;               /* typlen of the constant's datatype */
 174         Datum           constvalue;             /* the constant's value */
 175         bool            constisnull;    /* whether the constant is null (if true,
 176                                                                  * constvalue is undefined) */
 177         bool            constbyval;             /* whether this datatype is passed by value.
 178                                                                  * If true, then all the information is
 179                                                                  * stored in the Datum.
 180                                                                  * If false, then the Datum contains a
 181                                                                  * pointer to the information. */
 182 } Const;
 183
 184 /* ----------------
 185  * Param
 186  *              paramkind - specifies the kind of parameter. The possible values
 187  *              for this field are specified in "params.h", and they are:
 188  *
 189  *              PARAM_NAMED: The parameter has a name, i.e. something
 190  *                              like `$.salary' or `$.foobar'.
 191  *                              In this case field `paramname' must be a valid name.
 192  *
 193  *              PARAM_NUM:       The parameter has only a numeric identifier,
 194  *                              i.e. something like `$1', `$2' etc.
 195  *                              The number is contained in the `paramid' field.
 196  *
 197  *              PARAM_EXEC:      The parameter is an internal executor parameter.
 198  *                              It has a number contained in the `paramid' field.
 199  * ----------------
 200  */
 201 typedef struct Param
 202 {
 203         Expr            xpr;
 204         int                     paramkind;              /* kind of parameter. See above */
 205         AttrNumber      paramid;                /* numeric ID for parameter ("$1") */
 206         char       *paramname;          /* name for parameter ("$.foo") */
 207         Oid                     paramtype;              /* PG_TYPE OID of parameter's datatype */
 208 } Param;
 209
 210 /*
 211  * Aggref
 212  */
 213 typedef struct Aggref
 214 {
 215         Expr            xpr;
 216         Oid                     aggfnoid;               /* pg_proc Oid of the aggregate */
 217         Oid                     aggtype;                /* type Oid of result of the aggregate */
 218         Expr       *target;                     /* expression we are aggregating on */
 219         bool            aggstar;                /* TRUE if argument was really '*' */
 220         bool            aggdistinct;    /* TRUE if it's agg(DISTINCT ...) */
 221 } Aggref;
 222
 223 /* ----------------
 224  *      ArrayRef: describes an array subscripting operation
 225  *
 226  * An ArrayRef can describe fetching a single element from an array,
 227  * fetching a subarray (array slice), storing a single element into
 228  * an array, or storing a slice.  The "store" cases work with an
 229  * initial array value and a source value that is inserted into the
 230  * appropriate part of the array; the result of the operation is an
 231  * entire new modified array value.
 232  *
 233  * If reflowerindexpr = NIL, then we are fetching or storing a single array
 234  * element at the subscripts given by refupperindexpr.  Otherwise we are
 235  * fetching or storing an array slice, that is a rectangular subarray
 236  * with lower and upper bounds given by the index expressions.
 237  * reflowerindexpr must be the same length as refupperindexpr when it
 238  * is not NIL.
 239  *
 240  * Note: array types can be fixed-length (refattrlength > 0), but only
 241  * when the element type is itself fixed-length.  Otherwise they are
 242  * varlena structures and have refattrlength = -1.      In any case,
 243  * an array type is never pass-by-value.
 244  *
 245  * Note: refrestype is NOT the element type, but the array type,
 246  * when doing subarray fetch or either type of store.  It might be a good
 247  * idea to include a refelemtype field as well.
 248  * ----------------
 249  */
 250 typedef struct ArrayRef
 251 {
 252         Expr            xpr;
 253         Oid                     refrestype;             /* type of the result of the ArrayRef
 254                                                                  * operation */
 255         int                     refattrlength;  /* typlen of array type */
 256         int                     refelemlength;  /* typlen of the array element type */
 257         bool            refelembyval;   /* is the element type pass-by-value? */
 258         char            refelemalign;   /* typalign of the element type */
 259         List       *refupperindexpr;/* expressions that evaluate to upper
 260                                                                  * array indexes */
 261         List       *reflowerindexpr;/* expressions that evaluate to lower
 262                                                                  * array indexes */
 263         Expr       *refexpr;            /* the expression that evaluates to an
 264                                                                  * array value */
 265         Expr       *refassgnexpr;       /* expression for the source value, or
 266                                                                  * NULL if fetch */
 267 } ArrayRef;
 268
 269 /*
 270  * CoercionContext - distinguishes the allowed set of type casts
 271  *
 272  * NB: ordering of the alternatives is significant; later (larger) values
 273  * allow more casts than earlier ones.
 274  */
 275 typedef enum CoercionContext
 276 {
 277         COERCION_IMPLICIT,                      /* coercion in context of expression */
 278         COERCION_ASSIGNMENT,            /* coercion in context of assignment */
 279         COERCION_EXPLICIT                       /* explicit cast operation */
 280 } CoercionContext;
 281
 282 /*
 283  * CoercionForm - information showing how to display a function-call node
 284  */
 285 typedef enum CoercionForm
 286 {
 287         COERCE_EXPLICIT_CALL,           /* display as a function call */
 288         COERCE_EXPLICIT_CAST,           /* display as an explicit cast */
 289         COERCE_IMPLICIT_CAST,           /* implicit cast, so hide it */
 290         COERCE_DONTCARE                         /* special case for pathkeys */
 291 } CoercionForm;
 292
 293 /*
 294  * FuncExpr - expression node for a function call
 295  */
 296 typedef struct FuncExpr
 297 {
 298         Expr            xpr;
 299         Oid                     funcid;                 /* PG_PROC OID of the function */
 300         Oid                     funcresulttype; /* PG_TYPE OID of result value */
 301         bool            funcretset;             /* true if function returns set */
 302         CoercionForm funcformat;        /* how to display this function call */
 303         List       *args;                       /* arguments to the function */
 304 } FuncExpr;
 305
 306 /*
 307  * OpExpr - expression node for an operator invocation
 308  *
 309  * Semantically, this is essentially the same as a function call.
 310  *
 311  * Note that opfuncid is not necessarily filled in immediately on creation
 312  * of the node.  The planner makes sure it is valid before passing the node
 313  * tree to the executor, but during parsing/planning opfuncid is typically 0.
 314  */
 315 typedef struct OpExpr
 316 {
 317         Expr            xpr;
 318         Oid                     opno;                   /* PG_OPERATOR OID of the operator */
 319         Oid                     opfuncid;               /* PG_PROC OID of underlying function */
 320         Oid                     opresulttype;   /* PG_TYPE OID of result value */
 321         bool            opretset;               /* true if operator returns set */
 322         List       *args;                       /* arguments to the operator (1 or 2) */
 323 } OpExpr;
 324
 325 /*
 326  * DistinctExpr - expression node for "x IS DISTINCT FROM y"
 327  *
 328  * Except for the nodetag, this is represented identically to an OpExpr
 329  * referencing the "=" operator for x and y.
 330  * We use "=", not the more obvious "<>", because more datatypes have "="
 331  * than "<>".  This means the executor must invert the operator result.
 332  * Note that the operator function won't be called at all if either input
 333  * is NULL, since then the result can be determined directly.
 334  */
 335 typedef OpExpr DistinctExpr;
 336
 337 /*
 338  * BoolExpr - expression node for the basic Boolean operators AND, OR, NOT
 339  *
 340  * Notice the arguments are given as a List.  For NOT, of course the list
 341  * must always have exactly one element.  For AND and OR, the executor can
 342  * handle any number of arguments.  The parser treats AND and OR as binary
 343  * and so it only produces two-element lists, but the optimizer will flatten
 344  * trees of AND and OR nodes to produce longer lists when possible.
 345  */
 346 typedef enum BoolExprType
 347 {
 348         AND_EXPR, OR_EXPR, NOT_EXPR
 349 } BoolExprType;
 350
 351 typedef struct BoolExpr
 352 {
 353         Expr            xpr;
 354         BoolExprType boolop;
 355         List       *args;                       /* arguments to this expression */
 356 } BoolExpr;
 357
 358 /* ----------------
 359  * SubLink
 360  *
 361  * A SubLink represents a subselect appearing in an expression, and in some
 362  * cases also the combining operator(s) just above it.  The subLinkType
 363  * indicates the form of the expression represented:
 364  *      EXISTS_SUBLINK          EXISTS(SELECT ...)
 365  *      ALL_SUBLINK                     (lefthand) op ALL (SELECT ...)
 366  *      ANY_SUBLINK                     (lefthand) op ANY (SELECT ...)
 367  *      MULTIEXPR_SUBLINK       (lefthand) op (SELECT ...)
 368  *      EXPR_SUBLINK            (SELECT with single targetlist item ...)
 369  * For ALL, ANY, and MULTIEXPR, the lefthand is a list of expressions of the
 370  * same length as the subselect's targetlist.  MULTIEXPR will *always* have
 371  * a list with more than one entry; if the subselect has just one target
 372  * then the parser will create an EXPR_SUBLINK instead (and any operator
 373  * above the subselect will be represented separately).  Note that both
 374  * MULTIEXPR and EXPR require the subselect to deliver only one row.
 375  * ALL, ANY, and MULTIEXPR require the combining operators to deliver boolean
 376  * results.  These are reduced to one result per row using OR or AND semantics
 377  * depending on the "useOr" flag.  ALL and ANY combine the per-row results
 378  * using AND and OR semantics respectively.
 379  *
 380  * SubLink is classed as an Expr node, but it is not actually executable;
 381  * it must be replaced in the expression tree by a SubPlan node during
 382  * planning.
 383  *
 384  * NOTE: in the raw output of gram.y, lefthand contains a list of raw
 385  * expressions; useOr and operOids are not filled in yet.  Also, subselect
 386  * is a raw parsetree.  During parse analysis, the parser transforms the
 387  * lefthand expression list using normal expression transformation rules.
 388  * It fills operOids with the OIDs representing the specific operator(s)
 389  * to apply to each pair of lefthand and targetlist expressions.
 390  * And subselect is transformed to a Query.  This is the representation
 391  * seen in saved rules and in the rewriter.
 392  *
 393  * In EXISTS and EXPR SubLinks, lefthand, operName, and operOids are unused
 394  * and are always NIL.  useOr is not significant either for these sublink
 395  * types.
 396  * ----------------
 397  */
 398 typedef enum SubLinkType
 399 {
 400         EXISTS_SUBLINK, ALL_SUBLINK, ANY_SUBLINK, MULTIEXPR_SUBLINK, EXPR_SUBLINK
 401 } SubLinkType;
 402
 403
 404 typedef struct SubLink
 405 {
 406         Expr            xpr;
 407         SubLinkType subLinkType;        /* EXISTS, ALL, ANY, MULTIEXPR, EXPR */
 408         bool            useOr;                  /* TRUE to combine column results with
 409                                                                  * "OR" not "AND" */
 410         List       *lefthand;           /* list of outer-query expressions on the
 411                                                                  * left */
 412         List       *operName;           /* originally specified operator name */
 413         List       *operOids;           /* OIDs of actual combining operators */
 414         Node       *subselect;          /* subselect as Query* or parsetree */
 415 } SubLink;
 416
 417 /*
 418  * SubPlan - executable expression node for a subplan (sub-SELECT)
 419  *
 420  * The planner replaces SubLink nodes in expression trees with SubPlan
 421  * nodes after it has finished planning the subquery.  SubPlan contains
 422  * a sub-plantree and rtable instead of a sub-Query.
 423  *
 424  * In an ordinary subplan, "exprs" points to a list of executable expressions
 425  * (OpExpr trees) for the combining operators; their left-hand arguments are
 426  * the original lefthand expressions, and their right-hand arguments are
 427  * PARAM_EXEC Param nodes representing the outputs of the sub-select.
 428  * (NOTE: runtime coercion functions may be inserted as well.)  But if the
 429  * sub-select becomes an initplan rather than a subplan, these executable
 430  * expressions are part of the outer plan's expression tree (and the SubPlan
 431  * node itself is not).  In this case "exprs" is NIL to avoid duplication.
 432  *
 433  * The planner also derives lists of the values that need to be passed into
 434  * and out of the subplan.  Input values are represented as a list "args" of
 435  * expressions to be evaluated in the outer-query context (currently these
 436  * args are always just Vars, but in principle they could be any expression).
 437  * The values are assigned to the global PARAM_EXEC params indexed by parParam
 438  * (the parParam and args lists must have the same length).  setParam is a
 439  * list of the PARAM_EXEC params that are computed by the sub-select, if it
 440  * is an initplan.
 441  */
 442 typedef struct SubPlan
 443 {
 444         Expr            xpr;
 445         /* Fields copied from original SubLink: */
 446         SubLinkType subLinkType;        /* EXISTS, ALL, ANY, MULTIEXPR, EXPR */
 447         bool            useOr;                  /* TRUE to combine column results with
 448                                                                  * "OR" not "AND" */
 449         /* The combining operators, transformed to executable expressions: */
 450         List       *exprs;                      /* list of OpExpr expression trees */
 451         List       *paramIds;           /* IDs of Params embedded in the above */
 452         /* The subselect, transformed to a Plan: */
 453         struct Plan *plan;                      /* subselect plan itself */
 454         int                     plan_id;                /* dummy thing because of we haven't equal
 455                                                                  * funcs for plan nodes... actually, we
 456                                                                  * could put *plan itself somewhere else
 457                                                                  * (TopPlan node ?)... */
 458         List       *rtable;                     /* range table for subselect */
 459         /* Information about execution strategy: */
 460         bool            useHashTable;   /* TRUE to store subselect output in a hash
 461                                                                  * table (implies we are doing "IN") */
 462         bool            unknownEqFalse; /* TRUE if it's okay to return FALSE when
 463                                                                  * the spec result is UNKNOWN; this allows
 464                                                                  * much simpler handling of null values */
 465         /* Information for passing params into and out of the subselect: */
 466         /* setParam and parParam are lists of integers (param IDs) */
 467         List       *setParam;           /* initplan subqueries have to set these
 468                                                                  * Params for parent plan */
 469         List       *parParam;           /* indices of input Params from parent plan */
 470         List       *args;                       /* exprs to pass as parParam values */
 471 } SubPlan;
 472
 473 /* ----------------
 474  * FieldSelect
 475  *
 476  * FieldSelect represents the operation of extracting one field from a tuple
 477  * value.  At runtime, the input expression is expected to yield a Datum
 478  * that contains a pointer-to-TupleTableSlot.  The specified field number
 479  * is extracted and returned as a Datum.
 480  * ----------------
 481  */
 482
 483 typedef struct FieldSelect
 484 {
 485         Expr            xpr;
 486         Expr       *arg;                        /* input expression */
 487         AttrNumber      fieldnum;               /* attribute number of field to extract */
 488         Oid                     resulttype;             /* type of the field (result type of this
 489                                                                  * node) */
 490         int32           resulttypmod;   /* output typmod (usually -1) */
 491 } FieldSelect;
 492
 493 /* ----------------
 494  * RelabelType
 495  *
 496  * RelabelType represents a "dummy" type coercion between two binary-
 497  * compatible datatypes, such as reinterpreting the result of an OID
 498  * expression as an int4.  It is a no-op at runtime; we only need it
 499  * to provide a place to store the correct type to be attributed to
 500  * the expression result during type resolution.  (We can't get away
 501  * with just overwriting the type field of the input expression node,
 502  * so we need a separate node to show the coercion's result type.)
 503  * ----------------
 504  */
 505
 506 typedef struct RelabelType
 507 {
 508         Expr            xpr;
 509         Expr       *arg;                        /* input expression */
 510         Oid                     resulttype;             /* output type of coercion expression */
 511         int32           resulttypmod;   /* output typmod (usually -1) */
 512         CoercionForm relabelformat;     /* how to display this node */
 513 } RelabelType;
 514
 515 /*
 516  * CaseExpr - a CASE expression
 517  */
 518 typedef struct CaseExpr
 519 {
 520         Expr            xpr;
 521         Oid                     casetype;               /* type of expression result */
 522         Expr       *arg;                        /* implicit equality comparison argument */
 523         List       *args;                       /* the arguments (list of WHEN clauses) */
 524         Expr       *defresult;          /* the default result (ELSE clause) */
 525 } CaseExpr;
 526
 527 /*
 528  * CaseWhen - an argument to a CASE expression
 529  */
 530 typedef struct CaseWhen
 531 {
 532         Expr            xpr;
 533         Expr       *expr;                       /* condition expression */
 534         Expr       *result;                     /* substitution result */
 535 } CaseWhen;
 536
 537 /* ----------------
 538  * NullTest
 539  *
 540  * NullTest represents the operation of testing a value for NULLness.
 541  * Currently, we only support scalar input values, but eventually a
 542  * row-constructor input should be supported.
 543  * The appropriate test is performed and returned as a boolean Datum.
 544  * ----------------
 545  */
 546
 547 typedef enum NullTestType
 548 {
 549         IS_NULL, IS_NOT_NULL
 550 } NullTestType;
 551
 552 typedef struct NullTest
 553 {
 554         Expr            xpr;
 555         Expr       *arg;                        /* input expression */
 556         NullTestType nulltesttype;      /* IS NULL, IS NOT NULL */
 557 } NullTest;
 558
 559 /*
 560  * BooleanTest
 561  *
 562  * BooleanTest represents the operation of determining whether a boolean
 563  * is TRUE, FALSE, or UNKNOWN (ie, NULL).  All six meaningful combinations
 564  * are supported.  Note that a NULL input does *not* cause a NULL result.
 565  * The appropriate test is performed and returned as a boolean Datum.
 566  */
 567
 568 typedef enum BoolTestType
 569 {
 570         IS_TRUE, IS_NOT_TRUE, IS_FALSE, IS_NOT_FALSE, IS_UNKNOWN, IS_NOT_UNKNOWN
 571 } BoolTestType;
 572
 573 typedef struct BooleanTest
 574 {
 575         Expr            xpr;
 576         Expr       *arg;                        /* input expression */
 577         BoolTestType booltesttype;      /* test type */
 578 } BooleanTest;
 579
 580 /*
 581  * ConstraintTest
 582  *
 583  * ConstraintTest represents the operation of testing a value to see whether
 584  * it meets a constraint.  If so, the input value is returned as the result;
 585  * if not, an error is raised.
 586  */
 587
 588 typedef enum ConstraintTestType
 589 {
 590         CONSTR_TEST_NOTNULL,
 591         CONSTR_TEST_CHECK
 592 } ConstraintTestType;
 593
 594 typedef struct ConstraintTest
 595 {
 596         Expr            xpr;
 597         Expr       *arg;                        /* input expression */
 598         ConstraintTestType testtype;    /* test type */
 599         char       *name;                       /* name of constraint (for error msgs) */
 600         char       *domname;            /* name of domain (for error messages) */
 601         Expr       *check_expr;         /* for CHECK test, a boolean expression */
 602 } ConstraintTest;
 603
 604 /*
 605  * Placeholder node for the value to be processed by a domain's check
 606  * constraint.  This is effectively like a Param, but can be implemented more
 607  * simply since we need only one replacement value at a time.
 608  *
 609  * Note: the typeId/typeMod will be set from the domain's base type, not
 610  * the domain itself.  This is because we shouldn't consider the value to
 611  * be a member of the domain if we haven't yet checked its constraints.
 612  */
 613 typedef struct ConstraintTestValue
 614 {
 615         Expr            xpr;
 616         Oid                     typeId;                 /* type for substituted value */
 617         int32           typeMod;                /* typemod for substituted value */
 618 } ConstraintTestValue;
 619
 620
 621 /*
 622  * TargetEntry -
 623  *         a target entry (used in query target lists)
 624  *
 625  * Strictly speaking, a TargetEntry isn't an expression node (since it can't
 626  * be evaluated by ExecEvalExpr).  But we treat it as one anyway, since in
 627  * very many places it's convenient to process a whole query targetlist as a
 628  * single expression tree.
 629  *
 630  * The separation between TargetEntry and Resdom is historical.  One of these
 631  * days, Resdom should probably get folded into TargetEntry.
 632  */
 633 typedef struct TargetEntry
 634 {
 635         Expr            xpr;
 636         Resdom     *resdom;                     /* descriptor for targetlist item */
 637         Expr       *expr;                       /* expression to evaluate */
 638 } TargetEntry;
 639
 640
 641 /* ----------------------------------------------------------------
 642  *                                      node types for join trees
 643  *
 644  * The leaves of a join tree structure are RangeTblRef nodes.  Above
 645  * these, JoinExpr nodes can appear to denote a specific kind of join
 646  * or qualified join.  Also, FromExpr nodes can appear to denote an
 647  * ordinary cross-product join ("FROM foo, bar, baz WHERE ...").
 648  * FromExpr is like a JoinExpr of jointype JOIN_INNER, except that it
 649  * may have any number of child nodes, not just two.  Also, there is an
 650  * implementation-defined difference: the planner is allowed to join the
 651  * children of a FromExpr using whatever join order seems good to it.
 652  * At present, JoinExpr nodes are always joined in exactly the order
 653  * implied by the jointree structure (except the planner may choose to
 654  * swap inner and outer members of a join pair).
 655  *
 656  * NOTE: the top level of a Query's jointree is always a FromExpr.
 657  * Even if the jointree contains no rels, there will be a FromExpr.
 658  *
 659  * NOTE: the qualification expressions present in JoinExpr nodes are
 660  * *in addition to* the query's main WHERE clause, which appears as the
 661  * qual of the top-level FromExpr.      The reason for associating quals with
 662  * specific nodes in the jointree is that the position of a qual is critical
 663  * when outer joins are present.  (If we enforce a qual too soon or too late,
 664  * that may cause the outer join to produce the wrong set of NULL-extended
 665  * rows.)  If all joins are inner joins then all the qual positions are
 666  * semantically interchangeable.
 667  *
 668  * NOTE: in the raw output of gram.y, a join tree contains RangeVar,
 669  * RangeSubselect, and RangeFunction nodes, which are all replaced by
 670  * RangeTblRef nodes during the parse analysis phase.  Also, the top-level
 671  * FromExpr is added during parse analysis; the grammar regards FROM and
 672  * WHERE as separate.
 673  * ----------------------------------------------------------------
 674  */
 675
 676 /*
 677  * RangeTblRef - reference to an entry in the query's rangetable
 678  *
 679  * We could use direct pointers to the RT entries and skip having these
 680  * nodes, but multiple pointers to the same node in a querytree cause
 681  * lots of headaches, so it seems better to store an index into the RT.
 682  */
 683 typedef struct RangeTblRef
 684 {
 685         NodeTag         type;
 686         int                     rtindex;
 687 } RangeTblRef;
 688
 689 /*----------
 690  * JoinExpr - for SQL JOIN expressions
 691  *
 692  * isNatural, using, and quals are interdependent.      The user can write only
 693  * one of NATURAL, USING(), or ON() (this is enforced by the grammar).
 694  * If he writes NATURAL then parse analysis generates the equivalent USING()
 695  * list, and from that fills in "quals" with the right equality comparisons.
 696  * If he writes USING() then "quals" is filled with equality comparisons.
 697  * If he writes ON() then only "quals" is set.  Note that NATURAL/USING
 698  * are not equivalent to ON() since they also affect the output column list.
 699  *
 700  * alias is an Alias node representing the AS alias-clause attached to the
 701  * join expression, or NULL if no clause.  NB: presence or absence of the
 702  * alias has a critical impact on semantics, because a join with an alias
 703  * restricts visibility of the tables/columns inside it.
 704  *
 705  * During parse analysis, an RTE is created for the Join, and its index
 706  * is filled into rtindex.      This RTE is present mainly so that Vars can
 707  * be created that refer to the outputs of the join.
 708  *----------
 709  */
 710 typedef struct JoinExpr
 711 {
 712         NodeTag         type;
 713         JoinType        jointype;               /* type of join */
 714         bool            isNatural;              /* Natural join? Will need to shape table */
 715         Node       *larg;                       /* left subtree */
 716         Node       *rarg;                       /* right subtree */
 717         List       *using;                      /* USING clause, if any (list of String) */
 718         Node       *quals;                      /* qualifiers on join, if any */
 719         Alias      *alias;                      /* user-written alias clause, if any */
 720         int                     rtindex;                /* RT index assigned for join */
 721 } JoinExpr;
 722
 723 /*----------
 724  * FromExpr - represents a FROM ... WHERE ... construct
 725  *
 726  * This is both more flexible than a JoinExpr (it can have any number of
 727  * children, including zero) and less so --- we don't need to deal with
 728  * aliases and so on.  The output column set is implicitly just the union
 729  * of the outputs of the children.
 730  *----------
 731  */
 732 typedef struct FromExpr
 733 {
 734         NodeTag         type;
 735         List       *fromlist;           /* List of join subtrees */
 736         Node       *quals;                      /* qualifiers on join, if any */
 737 } FromExpr;
 738
 739 #endif   /* PRIMNODES_H */