parsenodes.h 45.7 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * parsenodes.h
4
 *	  definitions for parse tree nodes
5 6
 *
 *
Bruce Momjian's avatar
Bruce Momjian committed
7
 * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
8
 * Portions Copyright (c) 1994, Regents of the University of California
9
 *
10
 * $Id: parsenodes.h,v 1.191 2002/07/18 16:47:26 tgl Exp $
11 12 13
 *
 *-------------------------------------------------------------------------
 */
14 15
#ifndef PARSENODES_H
#define PARSENODES_H
16

17
#include "nodes/primnodes.h"
18

19

20
/*****************************************************************************
21
 *	Query Tree
22 23 24 25
 *****************************************************************************/

/*
 * Query -
26 27 28 29
 *	  all statments are turned into a Query tree (via transformStmt)
 *	  for further processing by the optimizer
 *	  utility statements (i.e. non-optimizable statements)
 *	  have the *utilityStmt field set.
30 31 32 33
 *
 * we need the isPortal flag because portal names can be null too; can
 * get rid of it if we support CURSOR as a commandType.
 */
34 35
typedef struct Query
{
36
	NodeTag		type;
37

38
	CmdType		commandType;	/* select|insert|update|delete|utility */
39

40
	Node	   *utilityStmt;	/* non-null if this is a non-optimizable
41 42
								 * statement */

43
	int			resultRelation; /* target relation (index into rtable) */
44
	RangeVar   *into;			/* target relation or portal (cursor) 
45
								 * for portal just name is meaningful */
46 47
	bool		isPortal;		/* is this a retrieve into portal? */
	bool		isBinary;		/* binary portal? */
48

49
	bool		hasAggs;		/* has aggregates in tlist or havingQual */
50
	bool		hasSubLinks;	/* has subquery SubLink */
51

52 53
	bool		originalQuery;	/* marks original query through rewriting */

54
	List	   *rtable;			/* list of range table entries */
55 56
	FromExpr   *jointree;		/* table join tree (FROM and WHERE
								 * clauses) */
57

58 59
	List	   *rowMarks;		/* integer list of RT indexes of relations
								 * that are selected FOR UPDATE */
60

61
	List	   *targetList;		/* target list (of TargetEntry) */
62

63 64 65
	List	   *groupClause;	/* a list of GroupClause's */

	Node	   *havingQual;		/* qualifications applied to groups */
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
66

67 68 69
	List	   *distinctClause; /* a list of SortClause's */

	List	   *sortClause;		/* a list of SortClause's */
70

Bruce Momjian's avatar
Bruce Momjian committed
71 72
	Node	   *limitOffset;	/* # of result tuples to skip */
	Node	   *limitCount;		/* # of result tuples to return */
Bruce Momjian's avatar
Bruce Momjian committed
73

74 75 76
	Node	   *setOperations;	/* set-operation tree if this is top level
								 * of a UNION/INTERSECT/EXCEPT query */

77 78 79 80 81 82 83 84
	/*
	 * If the resultRelation turns out to be the parent of an inheritance
	 * tree, the planner will add all the child tables to the rtable and
	 * store a list of the rtindexes of all the result relations here.
	 * This is done at plan time, not parse time, since we don't want to
	 * commit to the exact set of child tables at parse time.  This field
	 * ought to go in some sort of TopPlan plan node, not in the Query.
	 */
85
	List	   *resultRelations;	/* integer list of RT indexes, or NIL */
86

87
	/* internal to planner */
88
	List	   *base_rel_list;	/* list of base-relation RelOptInfos */
89
	List	   *other_rel_list; /* list of other 1-relation RelOptInfos */
90
	List	   *join_rel_list;	/* list of join-relation RelOptInfos */
91 92
	List	   *equi_key_list;	/* list of lists of equijoined
								 * PathKeyItems */
93
	List	   *query_pathkeys; /* pathkeys for query_planner()'s result */
94
} Query;
95 96


97 98
/****************************************************************************
 *	Supporting data structures for Parse Trees
99
 *
100 101 102 103
 *	Most of these node types appear in raw parsetrees output by the grammar,
 *	and get transformed to something else by the analyzer.	A few of them
 *	are used as-is in transformed querytrees.
 ****************************************************************************/
104

105 106
/*
 * TypeName - specifies a type in definitions
107 108 109 110 111 112 113 114
 *
 * For TypeName structures generated internally, it is often easier to
 * specify the type by OID than by name.  If "names" is NIL then the
 * actual type OID is given by typeid, otherwise typeid is unused.
 *
 * If pct_type is TRUE, then names is actually a field name and we look up
 * the type of that field.  Otherwise (the normal case), names is a type
 * name possibly qualified with schema and database name.
115
 */
116
typedef struct TypeName
117
{
118
	NodeTag		type;
119 120
	List	   *names;			/* qualified name (list of Value strings) */
	Oid			typeid;			/* type identified by OID */
121 122
	bool		timezone;		/* timezone specified? */
	bool		setof;			/* is a set? */
123
	bool		pct_type;		/* %TYPE specified? */
124 125 126
	int32		typmod;			/* type modifier */
	List	   *arrayBounds;	/* array bounds */
} TypeName;
127

128
/*
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
 * ColumnRef - specifies a reference to a column, or possibly a whole tuple
 *
 *		The "fields" list must be nonempty; its last component may be "*"
 *		instead of a field name.  Subscripts are optional.
 */
typedef struct ColumnRef
{
	NodeTag		type;
	List	   *fields;			/* field names (list of Value strings) */
	List	   *indirection;	/* subscripts (list of A_Indices) */
} ColumnRef;

/*
 * ParamRef - specifies a parameter reference
 *
 *		The parameter could be qualified with field names and/or subscripts
145
 */
146
typedef struct ParamRef
147 148
{
	NodeTag		type;
149
	int			number;			/* the number of the parameter */
150 151 152
	List	   *fields;			/* field names (list of Value strings) */
	List	   *indirection;	/* subscripts (list of A_Indices) */
} ParamRef;
153

154 155 156 157
/*
 * A_Expr - binary expressions
 */
typedef struct A_Expr
158
{
159
	NodeTag		type;
160
	int			oper;			/* type of operation (OP,OR,AND,NOT) */
161
	List	   *name;			/* possibly-qualified name of operator */
162 163 164
	Node	   *lexpr;			/* left argument */
	Node	   *rexpr;			/* right argument */
} A_Expr;
165

166 167 168 169
/*
 * A_Const - a constant expression
 */
typedef struct A_Const
170 171
{
	NodeTag		type;
172 173 174
	Value		val;			/* the value (with the tag) */
	TypeName   *typename;		/* typecast */
} A_Const;
175

176 177 178 179 180 181 182 183 184 185 186 187
/*
 * BetweenExpr - an SQL99 BETWEEN expression
 */

typedef struct BetweenExpr
{
	NodeTag		type;
	Node	   *expr;			/* Expression to check */
	Node	   *lexpr;			/* First bound */
	Node	   *rexpr;			/* Second bound */
	bool		not;			/* Do we want inverse? */
	bool		symmetric;		/* True if SYMMETRIC, false if ASYMMETRIC */
188
	Oid			typeId;			/* Information about common type */
189 190 191 192 193 194
	int16		typeLen;
	bool		typeByVal;
	Expr	   *gthan;
	Expr	   *lthan;
} BetweenExpr;

195 196 197
/*
 * TypeCast - a CAST expression
 *
198
 * NOTE: for mostly historical reasons, A_Const parsenodes contain
199
 * room for a TypeName; we only generate a separate TypeCast node if the
200 201 202
 * argument to be casted is not a constant.  In theory either representation
 * would work, but it is convenient to have the target type immediately
 * available while resolving a constant's datatype.
203
 */
204
typedef struct TypeCast
205
{
206
	NodeTag		type;
207 208 209
	Node	   *arg;			/* the expression being casted */
	TypeName   *typename;		/* the target type */
} TypeCast;
210

211 212
/*
 * CaseExpr - a CASE expression
213
 */
214
typedef struct CaseExpr
215
{
216
	NodeTag		type;
217 218 219 220 221
	Oid			casetype;
	Node	   *arg;			/* implicit equality comparison argument */
	List	   *args;			/* the arguments (list of WHEN clauses) */
	Node	   *defresult;		/* the default result (ELSE clause) */
} CaseExpr;
222

223 224
/*
 * CaseWhen - an argument to a CASE expression
225
 */
226
typedef struct CaseWhen
227
{
228
	NodeTag		type;
229 230 231
	Node	   *expr;			/* comparison expression */
	Node	   *result;			/* substitution result */
} CaseWhen;
232

233 234
/* ----------------
 * NullTest
235
 *
236 237 238 239 240
 * NullTest represents the operation of testing a value for NULLness.
 * Currently, we only support scalar input values, but eventually a
 * row-constructor input should be supported.
 * The appropriate test is performed and returned as a boolean Datum.
 * ----------------
241 242
 */

243
typedef enum NullTestType
244
{
245 246
	IS_NULL, IS_NOT_NULL
} NullTestType;
247

248
typedef struct NullTest
249
{
250
	NodeTag		type;
251 252 253
	Node	   *arg;			/* input expression */
	NullTestType nulltesttype;	/* IS NULL, IS NOT NULL */
} NullTest;
Jan Wieck's avatar
Jan Wieck committed
254

255 256 257 258 259 260 261 262
/* ----------------
 * BooleanTest
 *
 * BooleanTest represents the operation of determining whether a boolean
 * is TRUE, FALSE, or UNKNOWN (ie, NULL).  All six meaningful combinations
 * are supported.  Note that a NULL input does *not* cause a NULL result.
 * The appropriate test is performed and returned as a boolean Datum.
 * ----------------
Jan Wieck's avatar
Jan Wieck committed
263 264
 */

265
typedef enum BoolTestType
Jan Wieck's avatar
Jan Wieck committed
266
{
267 268
	IS_TRUE, IS_NOT_TRUE, IS_FALSE, IS_NOT_FALSE, IS_UNKNOWN, IS_NOT_UNKNOWN
} BoolTestType;
269

270
typedef struct BooleanTest
271
{
272
	NodeTag		type;
273 274 275
	Node	   *arg;			/* input expression */
	BoolTestType booltesttype;	/* test type */
} BooleanTest;
276

277 278 279 280 281 282 283 284 285 286 287 288 289 290
/*
 * ColumnDef - column definition (used in various creates)
 *
 * If the column has a default value, we may have the value expression
 * in either "raw" form (an untransformed parse tree) or "cooked" form
 * (the nodeToString representation of an executable expression tree),
 * depending on how this ColumnDef node was created (by parsing, or by
 * inheritance from an existing relation).	We should never have both
 * in the same node!
 *
 * The constraints list may contain a CONSTR_DEFAULT item in a raw
 * parsetree produced by gram.y, but transformCreateStmt will remove
 * the item and set raw_default instead.  CONSTR_DEFAULT items
 * should not appear in any subsequent processing.
291 292 293 294
 *
 * The "support" field, if not null, denotes a supporting relation that
 * should be linked by an internal dependency to the column.  Currently
 * this is only used to link a SERIAL column's sequence to the column.
295 296
 */
typedef struct ColumnDef
297
{
298
	NodeTag		type;
299 300 301 302 303 304 305
	char	   *colname;		/* name of column */
	TypeName   *typename;		/* type of column */
	bool		is_not_null;	/* NOT NULL constraint specified? */
	Node	   *raw_default;	/* default value (untransformed parse
								 * tree) */
	char	   *cooked_default; /* nodeToString representation */
	List	   *constraints;	/* other constraints on column */
306
	RangeVar   *support;		/* supporting relation, if any */
307
} ColumnDef;
308

309 310
/*
 * Ident -
311 312
 *	  an unqualified identifier.  This is currently used only in the context
 *	  of column name lists.
313
 */
314
typedef struct Ident
315 316
{
	NodeTag		type;
317 318
	char	   *name;			/* its name */
} Ident;
319

320 321 322 323 324 325 326 327 328
/*
 * FuncCall - a function or aggregate invocation
 *
 * agg_star indicates we saw a 'foo(*)' construct, while agg_distinct
 * indicates we saw 'foo(DISTINCT ...)'.  In either case, the construct
 * *must* be an aggregate call.  Otherwise, it might be either an
 * aggregate or some other kind of function.
 */
typedef struct FuncCall
329 330
{
	NodeTag		type;
331
	List	   *funcname;		/* qualified name of function */
332 333 334 335
	List	   *args;			/* the arguments (list of exprs) */
	bool		agg_star;		/* argument was really '*' */
	bool		agg_distinct;	/* arguments were labeled DISTINCT */
} FuncCall;
336

337 338
/*
 * A_Indices - array reference or bounds ([lidx:uidx] or [uidx])
339
 */
340
typedef struct A_Indices
341
{
342
	NodeTag		type;
343 344 345
	Node	   *lidx;			/* could be NULL */
	Node	   *uidx;
} A_Indices;
346

347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
/*
 * ExprFieldSelect - select a field and/or array element from an expression
 *
 *		This is used in the raw parsetree to represent selection from an
 *		arbitrary expression (not a column or param reference).  Either
 *		fields or indirection may be NIL if not used.
 */
typedef struct ExprFieldSelect
{
	NodeTag		type;
	Node	   *arg;			/* the thing being selected from */
	List	   *fields;			/* field names (list of Value strings) */
	List	   *indirection;	/* subscripts (list of A_Indices) */
} ExprFieldSelect;

362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
/*
 * ResTarget -
 *	  result target (used in target list of pre-transformed Parse trees)
 *
 * In a SELECT or INSERT target list, 'name' is either NULL or
 * the column name assigned to the value.  (If there is an 'AS ColumnLabel'
 * clause, the grammar sets 'name' from it; otherwise 'name' is initially NULL
 * and is filled in during the parse analysis phase.)
 * The 'indirection' field is not used at all.
 *
 * In an UPDATE target list, 'name' is the name of the destination column,
 * and 'indirection' stores any subscripts attached to the destination.
 * That is, our representation is UPDATE table SET name [indirection] = val.
 */
typedef struct ResTarget
377 378
{
	NodeTag		type;
379 380 381 382 383 384
	char	   *name;			/* column name or NULL */
	List	   *indirection;	/* subscripts for destination column, or
								 * NIL */
	Node	   *val;			/* the value expression to compute or
								 * assign */
} ResTarget;
385

Bruce Momjian's avatar
Bruce Momjian committed
386 387 388 389 390 391 392 393
/*
 * Empty node used as a marker for Default Columns
 */
typedef struct InsertDefault
{
	NodeTag		type;
} InsertDefault;

394 395 396 397
/*
 * SortGroupBy - for ORDER BY clause
 */
typedef struct SortGroupBy
398 399
{
	NodeTag		type;
400
	List	   *useOp;			/* operator to use */
401 402
	Node	   *node;			/* Expression  */
} SortGroupBy;
403

404 405
/*
 * RangeSubselect - subquery appearing in a FROM clause
406
 */
407
typedef struct RangeSubselect
408
{
409
	NodeTag		type;
410
	Node	   *subquery;		/* the untransformed sub-select clause */
411
	Alias	   *alias;			/* table alias & optional column aliases */
412
} RangeSubselect;
413

414 415 416 417 418 419 420 421 422 423
/*
 * RangeFunction - function call appearing in a FROM clause
 */
typedef struct RangeFunction
{
	NodeTag		type;
	Node	   *funccallnode;	/* untransformed function call tree */
	Alias	   *alias;			/* table alias & optional column aliases */
} RangeFunction;

424 425 426
/*
 * IndexElem - index parameters (used in CREATE INDEX)
 *
427 428 429 430
 * For a plain index, each 'name' is an attribute name in the heap relation;
 * 'funcname' and 'args' are NIL.  For a functional index, only one IndexElem
 * is allowed.  It has name = NULL, funcname = name of function and args =
 * list of attribute names that are the function's arguments.
431 432
 */
typedef struct IndexElem
433
{
434
	NodeTag		type;
435 436
	char	   *name;			/* name of attribute to index, or NULL */
	List	   *funcname;		/* qualified name of function */
437
	List	   *args;			/* list of names of function arguments */
438
	List	   *opclass;		/* name of desired opclass; NIL = default */
439
} IndexElem;
440

441 442 443 444 445
/*
 * DefElem -
 *	  a definition (used in definition lists in the form of defname = arg)
 */
typedef struct DefElem
446
{
447
	NodeTag		type;
448 449 450
	char	   *defname;
	Node	   *arg;			/* a (Value *) or a (TypeName *) */
} DefElem;
451

Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
452

453 454 455
/****************************************************************************
 *	Nodes for a Query tree
 ****************************************************************************/
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
456

457 458 459 460 461 462
/*
 * TargetEntry -
 *	   a target  entry (used in the transformed target list)
 *
 * one of resdom or fjoin is not NULL. a target list is
 *		((<resdom | fjoin> expr) (<resdom | fjoin> expr) ...)
463
 */
464
typedef struct TargetEntry
465
{
466
	NodeTag		type;
467 468 469 470
	Resdom	   *resdom;			/* fjoin overload this to be a list?? */
	Fjoin	   *fjoin;
	Node	   *expr;
} TargetEntry;
471

472 473 474 475
/*--------------------
 * RangeTblEntry -
 *	  A range table is a List of RangeTblEntry nodes.
 *
476 477 478 479 480 481
 *	  A range table entry may represent a plain relation, a sub-select in
 *	  FROM, or the result of a JOIN clause.  (Only explicit JOIN syntax
 *	  produces an RTE, not the implicit join resulting from multiple FROM
 *	  items.  This is because we only need the RTE to deal with SQL features
 *	  like outer joins and join-output-column aliasing.)  Other special
 *	  RTE types also exist, as indicated by RTEKind.
482
 *
483
 *	  alias is an Alias node representing the AS alias-clause attached to the
484 485 486 487 488
 *	  FROM expression, or NULL if no clause.
 *
 *	  eref is the table reference name and column reference names (either
 *	  real or aliases).  Note that system columns (OID etc) are not included
 *	  in the column list.
489
 *	  eref->aliasname is required to be present, and should generally be used
490 491 492 493
 *	  to identify the RTE for error messages etc.
 *
 *	  inh is TRUE for relation references that should be expanded to include
 *	  inheritance children, if the rel has any.  This *must* be FALSE for
494
 *	  RTEs other than RTE_RELATION entries.
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
 *
 *	  inFromCl marks those range variables that are listed in the FROM clause.
 *	  In SQL, the query can only refer to range variables listed in the
 *	  FROM clause, but POSTQUEL allows you to refer to tables not listed,
 *	  in which case a range table entry will be generated.	We still support
 *	  this POSTQUEL feature, although there is some doubt whether it's
 *	  convenient or merely confusing.  The flag is needed since an
 *	  implicitly-added RTE shouldn't change the namespace for unqualified
 *	  column names processed later, and it also shouldn't affect the
 *	  expansion of '*'.
 *
 *	  checkForRead, checkForWrite, and checkAsUser control run-time access
 *	  permissions checks.  A rel will be checked for read or write access
 *	  (or both, or neither) per checkForRead and checkForWrite.  If
 *	  checkAsUser is not InvalidOid, then do the permissions checks using
 *	  the access rights of that user, not the current effective user ID.
 *	  (This allows rules to act as setuid gateways.)
 *--------------------
513
 */
514 515 516 517 518
typedef enum RTEKind
{
	RTE_RELATION,				/* ordinary relation reference */
	RTE_SUBQUERY,				/* subquery in FROM */
	RTE_JOIN,					/* join */
519 520
	RTE_SPECIAL,				/* special rule relation (NEW or OLD) */
	RTE_FUNCTION				/* function in FROM */
521 522
} RTEKind;

523
typedef struct RangeTblEntry
524
{
525
	NodeTag		type;
526

527 528
	RTEKind		rtekind;		/* see above */

529
	/*
530 531 532 533 534 535
	 * XXX the fields applicable to only some rte kinds should be merged
	 * into a union.  I didn't do this yet because the diffs would impact
	 * a lot of code that is being actively worked on.  FIXME later.
	 */

	/*
536
	 * Fields valid for a plain relation RTE (else zero):
537 538
	 */
	Oid			relid;			/* OID of the relation */
539

540 541 542 543
	/*
	 * Fields valid for a subquery RTE (else NULL):
	 */
	Query	   *subquery;		/* the sub-query */
544

545 546 547 548 549
	/*
	 * Fields valid for a function RTE (else NULL):
	 */
	Node	   *funcexpr;		/* expression tree for func call */

550
	/*
551
	 * Fields valid for a join RTE (else NULL/zero):
552
	 *
553 554 555 556 557
	 * joinaliasvars is a list of Vars or COALESCE expressions corresponding
	 * to the columns of the join result.  An alias Var referencing column
	 * K of the join result can be replaced by the K'th element of
	 * joinaliasvars --- but to simplify the task of reverse-listing aliases
	 * correctly, we do not do that until planning time.
558 559
	 */
	JoinType	jointype;		/* type of join */
560
	List	   *joinaliasvars;	/* list of alias-var expansions */
561

562 563 564
	/*
	 * Fields valid in all RTEs:
	 */
565 566
	Alias	   *alias;			/* user-written alias clause, if any */
	Alias	   *eref;			/* expanded reference names */
567 568 569 570 571 572
	bool		inh;			/* inheritance requested? */
	bool		inFromCl;		/* present in FROM clause */
	bool		checkForRead;	/* check rel for read access */
	bool		checkForWrite;	/* check rel for write access */
	Oid			checkAsUser;	/* if not zero, check access as this user */
} RangeTblEntry;
573

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
/*
 * SortClause -
 *	   representation of ORDER BY clauses
 *
 * tleSortGroupRef must match ressortgroupref of exactly one Resdom of the
 * associated targetlist; that is the expression to be sorted (or grouped) by.
 * sortop is the OID of the ordering operator.
 *
 * SortClauses are also used to identify Resdoms that we will do a "Unique"
 * filter step on (for SELECT DISTINCT and SELECT DISTINCT ON).  The
 * distinctClause list is simply a copy of the relevant members of the
 * sortClause list.  Note that distinctClause can be a subset of sortClause,
 * but cannot have members not present in sortClause; and the members that
 * do appear must be in the same order as in sortClause.
 */
typedef struct SortClause
590
{
591
	NodeTag		type;
592 593 594
	Index		tleSortGroupRef;	/* reference into targetlist */
	Oid			sortop;			/* the sort operator to use */
} SortClause;
595

596 597 598 599 600 601 602
/*
 * GroupClause -
 *	   representation of GROUP BY clauses
 *
 * GroupClause is exactly like SortClause except for the nodetag value
 * (it's probably not even really necessary to have two different
 * nodetags...).  We have routines that operate interchangeably on both.
603
 */
604 605 606 607 608 609
typedef SortClause GroupClause;


/*****************************************************************************
 *		Optimizable Statements
 *****************************************************************************/
610 611

/* ----------------------
612
 *		Insert Statement
613 614
 * ----------------------
 */
615
typedef struct InsertStmt
616
{
617
	NodeTag		type;
618
	RangeVar   *relation;		/* relation to insert into */
619 620 621 622 623 624 625 626 627 628
	List	   *cols;			/* optional: names of the target columns */

	/*
	 * An INSERT statement has *either* VALUES or SELECT, never both. If
	 * VALUES, a targetList is supplied (empty for DEFAULT VALUES). If
	 * SELECT, a complete SelectStmt (or set-operation tree) is supplied.
	 */
	List	   *targetList;		/* the target list (of ResTarget) */
	Node	   *selectStmt;		/* the source SELECT */
} InsertStmt;
629

630
/* ----------------------
631
 *		Delete Statement
632 633
 * ----------------------
 */
634
typedef struct DeleteStmt
635
{
636
	NodeTag		type;
637
	RangeVar   *relation;		/* relation to delete from */
638 639
	Node	   *whereClause;	/* qualifications */
} DeleteStmt;
640 641

/* ----------------------
642
 *		Update Statement
643 644
 * ----------------------
 */
645
typedef struct UpdateStmt
646
{
647
	NodeTag		type;
648
	RangeVar   *relation;		/* relation to update */
649 650
	List	   *targetList;		/* the target list (of ResTarget) */
	Node	   *whereClause;	/* qualifications */
651
	List	   *fromClause;		/* optional from clause for more tables */
652
} UpdateStmt;
653 654

/* ----------------------
655 656 657 658 659 660 661 662 663 664
 *		Select Statement
 *
 * A "simple" SELECT is represented in the output of gram.y by a single
 * SelectStmt node.  A SELECT construct containing set operators (UNION,
 * INTERSECT, EXCEPT) is represented by a tree of SelectStmt nodes, in
 * which the leaf nodes are component SELECTs and the internal nodes
 * represent UNION, INTERSECT, or EXCEPT operators.  Using the same node
 * type for both leaf and internal nodes allows gram.y to stick ORDER BY,
 * LIMIT, etc, clause values into a SELECT statement without worrying
 * whether it is a simple or compound SELECT.
665 666
 * ----------------------
 */
667 668 669 670 671 672 673 674 675
typedef enum SetOperation
{
	SETOP_NONE = 0,
	SETOP_UNION,
	SETOP_INTERSECT,
	SETOP_EXCEPT
} SetOperation;

typedef struct SelectStmt
676
{
677
	NodeTag		type;
678 679 680 681 682 683 684

	/*
	 * These fields are used only in "leaf" SelectStmts.
	 */
	List	   *distinctClause; /* NULL, list of DISTINCT ON exprs, or
								 * lcons(NIL,NIL) for all (SELECT
								 * DISTINCT) */
685
	RangeVar   *into;			/* target table (for select into table) */
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
	List	   *intoColNames;	/* column names for into table */
	List	   *targetList;		/* the target list (of ResTarget) */
	List	   *fromClause;		/* the FROM clause */
	Node	   *whereClause;	/* WHERE qualification */
	List	   *groupClause;	/* GROUP BY clauses */
	Node	   *havingClause;	/* HAVING conditional-expression */

	/*
	 * These fields are used in both "leaf" SelectStmts and upper-level
	 * SelectStmts.  portalname/binary may only be set at the top level.
	 */
	List	   *sortClause;		/* sort clause (a list of SortGroupBy's) */
	char	   *portalname;		/* the portal (cursor) to create */
	bool		binary;			/* a binary (internal) portal? */
	Node	   *limitOffset;	/* # of result tuples to skip */
	Node	   *limitCount;		/* # of result tuples to return */
	List	   *forUpdate;		/* FOR UPDATE clause */

	/*
	 * These fields are used only in upper-level SelectStmts.
	 */
	SetOperation op;			/* type of set op */
	bool		all;			/* ALL specified? */
	struct SelectStmt *larg;	/* left child */
	struct SelectStmt *rarg;	/* right child */
	/* Eventually add fields for CORRESPONDING spec here */
} SelectStmt;
713 714

/* ----------------------
715 716 717 718 719 720 721
 *		Set Operation node for post-analysis query trees
 *
 * After parse analysis, a SELECT with set operations is represented by a
 * top-level Query node containing the leaf SELECTs as subqueries in its
 * range table.  Its setOperations field shows the tree of set operations,
 * with leaf SelectStmt nodes replaced by RangeTblRef nodes, and internal
 * nodes replaced by SetOperationStmt nodes.
722 723
 * ----------------------
 */
724
typedef struct SetOperationStmt
725
{
726
	NodeTag		type;
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
	SetOperation op;			/* type of set op */
	bool		all;			/* ALL specified? */
	Node	   *larg;			/* left child */
	Node	   *rarg;			/* right child */
	/* Eventually add fields for CORRESPONDING spec here */

	/* Fields derived during parse analysis: */
	List	   *colTypes;		/* integer list of OIDs of output column
								 * types */
} SetOperationStmt;


/*****************************************************************************
 *		Other Statements (no optimizations required)
 *
 *		Some of them require a little bit of transformation (which is also
 *		done by transformStmt). The whole structure is then passed on to
 *		ProcessUtility (by-passing the optimization step) as the utilityStmt
 *		field in Query.
 *****************************************************************************/
747

748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
/* ----------------------
 *		Create Schema Statement
 *
 * NOTE: the schemaElts list contains raw parsetrees for component statements
 * of the schema, such as CREATE TABLE, GRANT, etc.  These are analyzed and
 * executed after the schema itself is created.
 * ----------------------
 */
typedef struct CreateSchemaStmt
{
	NodeTag		type;
	char	   *schemaname;		/* the name of the schema to create */
	char	   *authid;			/* the owner of the created schema */
	List	   *schemaElts;		/* schema components (list of parsenodes) */
} CreateSchemaStmt;

764 765 766 767 768 769
typedef enum DropBehavior
{
	DROP_RESTRICT,				/* drop fails if any dependent objects */
	DROP_CASCADE				/* remove dependent objects too */
} DropBehavior;

770
/* ----------------------
771 772 773 774
 *	Alter Table
 *
 * The fields are used in different ways by the different variants of
 * this command.
775 776
 * ----------------------
 */
777
typedef struct AlterTableStmt
778
{
779
	NodeTag		type;
780 781 782
	char		subtype;		/*------------
								 *	A = add column
								 *	T = alter column default
783 784
								 *	N = alter column drop not null
								 *	O = alter column set not null
785 786 787 788
								 *	S = alter column statistics
								 *  M = alter column storage
								 *	D = drop column
								 *	C = add constraint
789 790
								 *	c = pre-processed add constraint
								 *		(local in parser/analyze.c)
791 792 793 794 795
								 *	X = drop constraint
								 *	E = create toast table
								 *	U = change owner
								 *------------
								 */
796
	RangeVar   *relation;		/* table to work on */
797 798 799
	char	   *name;			/* column or constraint name to act on, or
								 * new owner */
	Node	   *def;			/* definition of new column or constraint */
800
	DropBehavior behavior;		/* RESTRICT or CASCADE for DROP cases */
801
} AlterTableStmt;
802

803
/* ----------------------
804
 *		Grant|Revoke Statement
805 806
 * ----------------------
 */
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
typedef enum GrantObjectType
{
	ACL_OBJECT_RELATION,		/* table, view, sequence */
	ACL_OBJECT_DATABASE,		/* database */
	ACL_OBJECT_FUNCTION,		/* function */
	ACL_OBJECT_LANGUAGE,		/* procedural language */
	ACL_OBJECT_NAMESPACE		/* namespace */
} GrantObjectType;

/*
 * Grantable rights are encoded so that we can OR them together in a bitmask.
 * The present representation of AclItem limits us to 30 distinct rights.
 * Caution: changing these codes breaks stored ACLs, hence forces initdb.
 */
#define ACL_INSERT		(1<<0)	/* for relations */
#define ACL_SELECT		(1<<1)
#define ACL_UPDATE		(1<<2)
#define ACL_DELETE		(1<<3)
#define ACL_RULE		(1<<4)
#define ACL_REFERENCES	(1<<5)
#define ACL_TRIGGER		(1<<6)
#define ACL_EXECUTE		(1<<7)	/* for functions */
#define ACL_USAGE		(1<<8)	/* for languages and namespaces */
#define ACL_CREATE		(1<<9)	/* for namespaces and databases */
#define ACL_CREATE_TEMP	(1<<10)	/* for databases */
#define N_ACL_RIGHTS	11		/* 1 plus the last 1<<x */
#define ACL_ALL_RIGHTS	(-1)	/* all-privileges marker in GRANT list */
#define ACL_NO_RIGHTS	0
835 836

typedef struct GrantStmt
837
{
838
	NodeTag		type;
839 840 841 842
	bool		is_grant;		/* true = GRANT, false = REVOKE */
	GrantObjectType objtype;	/* kind of object being operated on */
	List	   *objects;		/* list of RangeVar nodes, FuncWithArgs nodes,
								 * or plain names (as Value strings) */
843 844 845
	List	   *privileges;		/* integer list of privilege codes */
	List	   *grantees;		/* list of PrivGrantee nodes */
} GrantStmt;
846

847
typedef struct PrivGrantee
848
{
849
	NodeTag		type;
850 851 852
	char	   *username;		/* if both are NULL then PUBLIC */
	char	   *groupname;
} PrivGrantee;
853

854
typedef struct FuncWithArgs
855
{
856
	NodeTag		type;
857
	List	   *funcname;		/* qualified name of function */
858 859
	List	   *funcargs;		/* list of Typename nodes */
} FuncWithArgs;
860

861 862
/* This is only used internally in gram.y. */
typedef struct PrivTarget
863
{
864
	NodeTag		type;
865
	GrantObjectType objtype;
866 867 868
	List	   *objs;
} PrivTarget;

869
/* ----------------------
870
 *		Close Portal Statement
871 872
 * ----------------------
 */
873
typedef struct ClosePortalStmt
874
{
875
	NodeTag		type;
876 877
	char	   *portalname;		/* name of the portal (cursor) */
} ClosePortalStmt;
878 879

/* ----------------------
880
 *		Copy Statement
881 882
 * ----------------------
 */
883
typedef struct CopyStmt
884
{
885
	NodeTag		type;
886
	RangeVar   *relation;		/* the relation to copy */
887
	List *attlist;
888
	bool		is_from;		/* TO or FROM */
889
	char	   *filename;		/* if NULL, use stdin/stdout */
890
	List	   *options;		/* List of DefElem nodes */
891
} CopyStmt;
892 893

/* ----------------------
894 895 896 897 898 899 900
 *		Create Table Statement
 *
 * NOTE: in the raw gram.y output, ColumnDef, Constraint, and FkConstraint
 * nodes are intermixed in tableElts, and constraints is NIL.  After parse
 * analysis, tableElts contains just ColumnDefs, and constraints contains
 * just Constraint nodes (in fact, only CONSTR_CHECK nodes, in the present
 * implementation).
901 902
 * ----------------------
 */
903
typedef struct CreateStmt
904 905
{
	NodeTag		type;
906
	RangeVar   *relation;		/* relation to create */
907
	List	   *tableElts;		/* column definitions (list of ColumnDef) */
908
	List	   *inhRelations;	/* relations to inherit from */
909 910 911
	List	   *constraints;	/* constraints (list of Constraint nodes) */
	bool		hasoids;		/* should it have OIDs? */
} CreateStmt;
912

913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/* ----------
 * Definitions for plain (non-FOREIGN KEY) constraints in CreateStmt
 *
 * XXX probably these ought to be unified with FkConstraints at some point?
 *
 * For constraints that use expressions (CONSTR_DEFAULT, CONSTR_CHECK)
 * we may have the expression in either "raw" form (an untransformed
 * parse tree) or "cooked" form (the nodeToString representation of
 * an executable expression tree), depending on how this Constraint
 * node was created (by parsing, or by inheritance from an existing
 * relation).  We should never have both in the same node!
 *
 * Constraint attributes (DEFERRABLE etc) are initially represented as
 * separate Constraint nodes for simplicity of parsing.  analyze.c makes
 * a pass through the constraints list to attach the info to the appropriate
 * FkConstraint node (and, perhaps, someday to other kinds of constraints).
 * ----------
930
 */
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947

typedef enum ConstrType			/* types of constraints */
{
	CONSTR_NULL,				/* not SQL92, but a lot of people expect
								 * it */
	CONSTR_NOTNULL,
	CONSTR_DEFAULT,
	CONSTR_CHECK,
	CONSTR_PRIMARY,
	CONSTR_UNIQUE,
	CONSTR_ATTR_DEFERRABLE,		/* attributes for previous constraint node */
	CONSTR_ATTR_NOT_DEFERRABLE,
	CONSTR_ATTR_DEFERRED,
	CONSTR_ATTR_IMMEDIATE
} ConstrType;

typedef struct Constraint
948
{
949
	NodeTag		type;
950 951 952 953 954 955
	ConstrType	contype;
	char	   *name;			/* name, or NULL if unnamed */
	Node	   *raw_expr;		/* expr, as untransformed parse tree */
	char	   *cooked_expr;	/* expr, as nodeToString representation */
	List	   *keys;			/* Ident nodes naming referenced column(s) */
} Constraint;
956

957 958
/* ----------
 * Definitions for FOREIGN KEY constraints in CreateStmt
959 960 961 962 963 964 965 966 967 968
 *
 * Note: FKCONSTR_ACTION_xxx values are stored into pg_constraint.confupdtype
 * and pg_constraint.confdeltype columns; FKCONSTR_MATCH_xxx values are
 * stored into pg_constraint.confmatchtype.  Changing the code values may
 * require an initdb!
 *
 * If skip_validation is true then we skip checking that the existing rows
 * in the table satisfy the constraint, and just install the catalog entries
 * for the constraint.  This is currently used only during CREATE TABLE
 * (when we know the table must be empty).
969
 * ----------
970
 */
971 972 973 974 975
#define FKCONSTR_ACTION_NOACTION	'a'
#define FKCONSTR_ACTION_RESTRICT	'r'
#define FKCONSTR_ACTION_CASCADE		'c'
#define FKCONSTR_ACTION_SETNULL		'n'
#define FKCONSTR_ACTION_SETDEFAULT	'd'
976

977 978 979
#define FKCONSTR_MATCH_FULL			'f'
#define FKCONSTR_MATCH_PARTIAL		'p'
#define FKCONSTR_MATCH_UNSPECIFIED	'u'
980 981

typedef struct FkConstraint
982
{
983
	NodeTag		type;
984
	char	   *constr_name;	/* Constraint name, or NULL if unnamed */
985
	RangeVar   *pktable;		/* Primary key table */
986 987
	List	   *fk_attrs;		/* Attributes of foreign key */
	List	   *pk_attrs;		/* Corresponding attrs in PK table */
988 989 990
	char		fk_matchtype;	/* FULL, PARTIAL, UNSPECIFIED */
	char		fk_upd_action;	/* ON UPDATE action */
	char		fk_del_action;	/* ON DELETE action */
991 992
	bool		deferrable;		/* DEFERRABLE */
	bool		initdeferred;	/* INITIALLY DEFERRED */
993
	bool		skip_validation; /* skip validation of existing rows? */
994
} FkConstraint;
995 996

/* ----------------------
997
 *		Create/Drop TRIGGER Statements
998 999
 * ----------------------
 */
1000 1001

typedef struct CreateTrigStmt
1002
{
1003
	NodeTag		type;
1004 1005 1006 1007
	char	   *trigname;		/* TRIGGER's name */
	RangeVar   *relation;		/* relation trigger is on */
	List	   *funcname;		/* qual. name of function to call */
	List	   *args;			/* list of (T_String) Values or NIL */
1008 1009 1010 1011 1012 1013 1014
	bool		before;			/* BEFORE/AFTER */
	bool		row;			/* ROW/STATEMENT */
	char		actions[4];		/* Insert, Update, Delete */
	char	   *lang;			/* currently not used, always NULL */
	char	   *text;			/* AS 'text' */
	List	   *attr;			/* UPDATE OF a, b,... (NI) or NULL */
	char	   *when;			/* WHEN 'a > 10 ...' (NI) or NULL */
1015

1016 1017 1018 1019 1020
	/* The following are used for referential */
	/* integrity constraint triggers */
	bool		isconstraint;	/* This is an RI trigger */
	bool		deferrable;		/* [NOT] DEFERRABLE */
	bool		initdeferred;	/* INITIALLY {DEFERRED|IMMEDIATE} */
1021
	RangeVar   *constrrel;		/* opposite relation */
1022 1023
} CreateTrigStmt;

1024
/* ----------------------
1025
 *		Create/Drop PROCEDURAL LANGUAGE Statement
1026 1027
 * ----------------------
 */
1028
typedef struct CreatePLangStmt
1029 1030
{
	NodeTag		type;
1031
	char	   *plname;			/* PL name */
1032
	List	   *plhandler;		/* PL call handler function (qual. name) */
1033
	List	   *plvalidator;	/* optional validator function (qual. name) */
1034 1035 1036
	char	   *plcompiler;		/* lancompiler text */
	bool		pltrusted;		/* PL is trusted */
} CreatePLangStmt;
1037

1038
typedef struct DropPLangStmt
1039
{
1040
	NodeTag		type;
1041
	char	   *plname;			/* PL name */
1042
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1043
} DropPLangStmt;
1044 1045

/* ----------------------
1046
 *	Create/Alter/Drop User Statements
1047 1048
 * ----------------------
 */
1049
typedef struct CreateUserStmt
1050
{
1051
	NodeTag		type;
1052 1053 1054
	char	   *user;			/* PostgreSQL user login name */
	List	   *options;		/* List of DefElem nodes */
} CreateUserStmt;
1055

1056
typedef struct AlterUserStmt
1057
{
1058
	NodeTag		type;
1059 1060 1061
	char	   *user;			/* PostgreSQL user login name */
	List	   *options;		/* List of DefElem nodes */
} AlterUserStmt;
1062

1063
typedef struct AlterUserSetStmt
1064
{
1065
	NodeTag		type;
1066 1067 1068 1069
	char	   *user;
	char	   *variable;
	List	   *value;
} AlterUserSetStmt;
1070

1071
typedef struct DropUserStmt
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1072 1073
{
	NodeTag		type;
1074 1075
	List	   *users;			/* List of users to remove */
} DropUserStmt;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1076

1077
/* ----------------------
1078
 *		Create/Alter/Drop Group Statements
1079 1080
 * ----------------------
 */
1081
typedef struct CreateGroupStmt
1082
{
1083
	NodeTag		type;
1084 1085 1086
	char	   *name;			/* name of the new group */
	List	   *options;		/* List of DefElem nodes */
} CreateGroupStmt;
1087

1088 1089 1090 1091 1092 1093 1094
typedef struct AlterGroupStmt
{
	NodeTag		type;
	char	   *name;			/* name of group to alter */
	int			action;			/* +1 = add, -1 = drop user */
	List	   *listUsers;		/* list of users to add/drop */
} AlterGroupStmt;
1095

1096
typedef struct DropGroupStmt
1097
{
1098 1099
	NodeTag		type;
	char	   *name;
1100
} DropGroupStmt;
1101 1102

/* ----------------------
1103
 *		Create SEQUENCE Statement
1104 1105 1106
 * ----------------------
 */

1107
typedef struct CreateSeqStmt
1108
{
1109
	NodeTag		type;
1110
	RangeVar   *sequence;		/* the sequence to create */
1111 1112
	List	   *options;
} CreateSeqStmt;
1113

1114
/* ----------------------
1115
 *		Create {Operator|Type|Aggregate} Statement
1116 1117
 * ----------------------
 */
1118
typedef struct DefineStmt
1119 1120
{
	NodeTag		type;
Tom Lane's avatar
Tom Lane committed
1121
	int			defType;		/* OPERATOR|TYPE_P|AGGREGATE */
1122
	List	   *defnames;		/* qualified name (list of Value strings) */
1123 1124
	List	   *definition;		/* a list of DefElem */
} DefineStmt;
1125

Tom Lane's avatar
Tom Lane committed
1126 1127 1128 1129 1130 1131 1132
/* ----------------------
 *		Create Domain Statement
 * ----------------------
 */
typedef struct CreateDomainStmt
{
	NodeTag		type;
1133 1134 1135
	List	   *domainname;		/* qualified name (list of Value strings) */
	TypeName   *typename;		/* the base type */
	List	   *constraints;	/* constraints (list of Constraint nodes) */
Tom Lane's avatar
Tom Lane committed
1136 1137
} CreateDomainStmt;

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1138
/* ----------------------
1139
 *		Drop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1140 1141 1142
 * ----------------------
 */

1143 1144 1145 1146
#define DROP_TABLE	  1
#define DROP_SEQUENCE 2
#define DROP_VIEW	  3
#define DROP_INDEX	  4
1147 1148
#define DROP_TYPE     5
#define DROP_DOMAIN	  6
1149
#define DROP_CONVERSION	  7
1150
#define DROP_SCHEMA	  8
1151

1152 1153 1154
typedef struct DropStmt
{
	NodeTag		type;
1155
	List	   *objects;		/* list of sublists of names (as Values) */
1156 1157
	int			removeType;		/* see #defines above */
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1158
} DropStmt;
1159

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
/* ----------------------
 *		Drop Rule|Trigger Statement
 *
 * In general this may be used for dropping any property of a relation;
 * for example, someday soon we may have DROP ATTRIBUTE.
 * ----------------------
 */

#define DROP_RULE	  100
#define DROP_TRIGGER  101

typedef struct DropPropertyStmt
{
	NodeTag		type;
	RangeVar   *relation;		/* owning relation */
	char	   *property;		/* name of rule, trigger, etc */
1176 1177
	int			removeType;		/* see #defines above */
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1178 1179
} DropPropertyStmt;

1180
/* ----------------------
1181
 *				Truncate Table Statement
1182 1183
 * ----------------------
 */
1184
typedef struct TruncateStmt
1185
{
1186
	NodeTag		type;
1187
	RangeVar   *relation;		/* relation to be truncated */
1188
} TruncateStmt;
1189 1190

/* ----------------------
1191
 *				Comment On Statement
1192 1193
 * ----------------------
 */
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
#define COMMENT_ON_AGGREGATE	100
#define COMMENT_ON_COLUMN		101
#define COMMENT_ON_CONSTRAINT	102
#define COMMENT_ON_DATABASE		103
#define COMMENT_ON_FUNCTION		104
#define COMMENT_ON_INDEX		105
#define COMMENT_ON_OPERATOR		106
#define COMMENT_ON_RULE			107
#define COMMENT_ON_SCHEMA		108
#define COMMENT_ON_SEQUENCE		109
#define COMMENT_ON_TABLE		110
#define COMMENT_ON_TRIGGER		111
#define COMMENT_ON_TYPE			112
#define COMMENT_ON_VIEW			113

1209
typedef struct CommentStmt
1210
{
1211
	NodeTag		type;
1212
	int			objtype;		/* Object's type, see codes above */
1213 1214 1215
	List	   *objname;		/* Qualified name of the object */
	List	   *objargs;		/* Arguments if needed (eg, for functions) */
	char	   *comment;		/* Comment to insert, or NULL to remove */
1216
} CommentStmt;
1217 1218

/* ----------------------
1219
 *		Begin Recipe Statement
1220 1221
 * ----------------------
 */
1222
typedef struct RecipeStmt
1223
{
1224
	NodeTag		type;
1225 1226
	char	   *recipeName;		/* name of the recipe */
} RecipeStmt;
1227 1228

/* ----------------------
1229
 *		Fetch Statement
1230 1231
 * ----------------------
 */
1232
typedef struct FetchStmt
1233
{
1234
	NodeTag		type;
1235 1236 1237 1238 1239
	int			direction;		/* FORWARD or BACKWARD */
	int			howMany;		/* amount to fetch ("ALL" --> 0) */
	char	   *portalname;		/* name of portal (cursor) */
	bool		ismove;			/* TRUE if MOVE */
} FetchStmt;
1240

1241
/* ----------------------
1242
 *		Create Index Statement
1243 1244
 * ----------------------
 */
1245
typedef struct IndexStmt
1246 1247
{
	NodeTag		type;
1248
	char	   *idxname;		/* name of the index */
1249
	RangeVar   *relation;		/* relation to build index on */
1250 1251 1252 1253 1254 1255 1256
	char	   *accessMethod;	/* name of access method (eg. btree) */
	List	   *indexParams;	/* a list of IndexElem */
	Node	   *whereClause;	/* qualification (partial-index predicate) */
	List	   *rangetable;		/* range table for qual, filled in by
								 * transformStmt() */
	bool		unique;			/* is index unique? */
	bool		primary;		/* is index on primary key? */
1257
	bool		isconstraint;	/* is it from a CONSTRAINT clause? */
1258
} IndexStmt;
1259

1260 1261 1262
/* ----------------------
 *		Create Function Statement
 * ----------------------
1263
 */
1264
typedef struct CreateFunctionStmt
1265
{
1266
	NodeTag		type;
1267
	bool		replace;		/* T => replace if already exists */
1268
	List	   *funcname;		/* qualified name of function to create */
1269
	List	   *argTypes;		/* list of argument types (TypeName nodes) */
1270
	TypeName   *returnType;		/* the return type */
1271
	List	   *options;		/* a list of DefElem */
1272
	List	   *withClause;		/* a list of DefElem */
1273
} CreateFunctionStmt;
1274

1275 1276 1277
/* ----------------------
 *		Drop Aggregate Statement
 * ----------------------
1278
 */
1279
typedef struct RemoveAggrStmt
1280
{
1281
	NodeTag		type;
1282
	List	   *aggname;		/* aggregate to drop */
1283
	TypeName   *aggtype;		/* TypeName for input datatype, or NULL */
1284
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1285
} RemoveAggrStmt;
1286

1287 1288 1289
/* ----------------------
 *		Drop Function Statement
 * ----------------------
1290
 */
1291
typedef struct RemoveFuncStmt
1292
{
1293
	NodeTag		type;
1294
	List	   *funcname;		/* function to drop */
1295
	List	   *args;			/* types of the arguments */
1296
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1297
} RemoveFuncStmt;
1298

1299 1300 1301
/* ----------------------
 *		Drop Operator Statement
 * ----------------------
1302
 */
1303
typedef struct RemoveOperStmt
1304
{
1305
	NodeTag		type;
1306
	List	   *opname;			/* operator to drop */
1307
	List	   *args;			/* types of the arguments */
1308
	DropBehavior behavior;		/* RESTRICT or CASCADE behavior */
1309
} RemoveOperStmt;
1310

1311
/* ----------------------
1312
 *		Alter Object Rename Statement
1313
 * ----------------------
1314 1315
 * Currently supports renaming tables, table columns, and triggers.
 * If renaming a table, oldname is ignored.
1316
 */
1317 1318 1319 1320 1321
#define RENAME_TABLE	110
#define RENAME_COLUMN	111
#define RENAME_TRIGGER	112
#define RENAME_RULE		113

1322
typedef struct RenameStmt
1323
{
1324
	NodeTag		type;
1325 1326
	RangeVar   *relation;		/* owning relation */
	char	   *oldname;		/* name of rule, trigger, etc */
1327
	char	   *newname;		/* the new name */
1328
	int			renameType;		/* RENAME_TABLE, RENAME_COLUMN, etc */
1329
} RenameStmt;
1330

1331 1332 1333
/* ----------------------
 *		Create Rule Statement
 * ----------------------
1334
 */
1335
typedef struct RuleStmt
1336 1337
{
	NodeTag		type;
1338
	RangeVar   *relation;		/* relation the rule is for */
1339 1340
	char	   *rulename;		/* name of the rule */
	Node	   *whereClause;	/* qualifications */
1341
	CmdType		event;			/* SELECT, INSERT, etc */
1342 1343 1344
	bool		instead;		/* is a 'do instead'? */
	List	   *actions;		/* the action statements */
} RuleStmt;
1345

1346 1347 1348
/* ----------------------
 *		Notify Statement
 * ----------------------
1349
 */
1350
typedef struct NotifyStmt
1351 1352
{
	NodeTag		type;
1353
	RangeVar   *relation;		/* qualified name to notify */
1354
} NotifyStmt;
1355

1356 1357 1358
/* ----------------------
 *		Listen Statement
 * ----------------------
1359
 */
1360
typedef struct ListenStmt
1361 1362
{
	NodeTag		type;
1363
	RangeVar   *relation;		/* qualified name to listen on */
1364
} ListenStmt;
1365

1366 1367 1368
/* ----------------------
 *		Unlisten Statement
 * ----------------------
1369
 */
1370
typedef struct UnlistenStmt
1371
{
1372
	NodeTag		type;
1373
	RangeVar   *relation;		/* qualified name to unlisten on, or '*' */
1374
} UnlistenStmt;
1375

1376 1377 1378 1379 1380
/* ----------------------
 *		{Begin|Abort|End} Transaction Statement
 * ----------------------
 */
typedef struct TransactionStmt
1381
{
1382
	NodeTag		type;
1383 1384
	int			command;		/* BEGIN|END|ABORT */
} TransactionStmt;
1385

1386 1387 1388
/* ----------------------
 *		Create View Statement
 * ----------------------
1389
 */
1390
typedef struct ViewStmt
1391
{
1392
	NodeTag		type;
1393
	RangeVar   *view;			/* the view to be created */
1394 1395 1396
	List	   *aliases;		/* target column names */
	Query	   *query;			/* the SQL statement */
} ViewStmt;
1397

1398 1399 1400 1401 1402
/* ----------------------
 *		Load Statement
 * ----------------------
 */
typedef struct LoadStmt
1403
{
1404
	NodeTag		type;
1405 1406
	char	   *filename;		/* file to load */
} LoadStmt;
1407

1408 1409 1410
/* ----------------------
 *		Createdb Statement
 * ----------------------
1411
 */
1412
typedef struct CreatedbStmt
1413
{
1414
	NodeTag		type;
1415
	char	   *dbname;			/* name of database to create */
1416
	List	   *options;		/* List of DefElem nodes */
1417
} CreatedbStmt;
1418

1419 1420 1421
/* ----------------------
 *	Alter Database
 * ----------------------
1422
 */
1423
typedef struct AlterDatabaseSetStmt
1424
{
1425
	NodeTag		type;
1426 1427 1428 1429
	char	   *dbname;
	char	   *variable;
	List	   *value;
} AlterDatabaseSetStmt;
1430

1431 1432 1433
/* ----------------------
 *		Dropdb Statement
 * ----------------------
1434
 */
1435
typedef struct DropdbStmt
1436
{
1437
	NodeTag		type;
1438 1439
	char	   *dbname;			/* database to drop */
} DropdbStmt;
1440

1441 1442 1443
/* ----------------------
 *		Cluster Statement (support pbrown's cluster index implementation)
 * ----------------------
1444
 */
1445
typedef struct ClusterStmt
1446
{
1447
	NodeTag		type;
1448
	RangeVar   *relation;		/* relation being indexed */
1449 1450
	char	   *indexname;		/* original index defined */
} ClusterStmt;
1451

1452 1453
/* ----------------------
 *		Vacuum and Analyze Statements
1454
 *
1455 1456 1457
 * Even though these are nominally two statements, it's convenient to use
 * just one node type for both.
 * ----------------------
1458
 */
1459
typedef struct VacuumStmt
1460
{
1461
	NodeTag		type;
1462 1463 1464 1465 1466
	bool		vacuum;			/* do VACUUM step */
	bool		full;			/* do FULL (non-concurrent) vacuum */
	bool		analyze;		/* do ANALYZE step */
	bool		freeze;			/* early-freeze option */
	bool		verbose;		/* print progress info */
1467
	RangeVar   *relation;		/* single table to process, or NULL */
1468 1469
	List	   *va_cols;		/* list of column names, or NIL for all */
} VacuumStmt;
1470

1471 1472 1473
/* ----------------------
 *		Explain Statement
 * ----------------------
1474
 */
1475
typedef struct ExplainStmt
1476 1477
{
	NodeTag		type;
1478 1479 1480 1481
	Query	   *query;			/* the query */
	bool		verbose;		/* print plan info */
	bool		analyze;		/* get statistics by executing plan */
} ExplainStmt;
1482

1483 1484 1485
/* ----------------------
 * Checkpoint Statement
 * ----------------------
1486
 */
1487
typedef struct CheckPointStmt
1488
{
1489
	NodeTag		type;
1490
} CheckPointStmt;
1491

1492 1493 1494
/* ----------------------
 * Set Statement
 * ----------------------
1495
 */
1496 1497

typedef struct VariableSetStmt
1498 1499
{
	NodeTag		type;
1500 1501
	char	   *name;
	List	   *args;
1502
	bool		is_local;		/* SET LOCAL */
1503
} VariableSetStmt;
1504

1505 1506 1507
/* ----------------------
 * Show Statement
 * ----------------------
1508
 */
1509 1510

typedef struct VariableShowStmt
1511
{
1512
	NodeTag		type;
1513 1514
	char	   *name;
} VariableShowStmt;
1515

1516 1517 1518
/* ----------------------
 * Reset Statement
 * ----------------------
1519
 */
1520 1521

typedef struct VariableResetStmt
1522
{
1523
	NodeTag		type;
1524 1525
	char	   *name;
} VariableResetStmt;
1526

1527 1528 1529
/* ----------------------
 *		LOCK Statement
 * ----------------------
1530
 */
1531
typedef struct LockStmt
1532
{
1533
	NodeTag		type;
1534
	List	   *relations;		/* relations to lock */
1535 1536
	int			mode;			/* lock mode */
} LockStmt;
1537

1538 1539 1540
/* ----------------------
 *		SET CONSTRAINTS Statement
 * ----------------------
1541
 */
1542
typedef struct ConstraintsSetStmt
1543
{
1544
	NodeTag		type;
1545 1546 1547
	List	   *constraints;	/* List of names as Value strings */
	bool		deferred;
} ConstraintsSetStmt;
1548

1549 1550 1551
/* ----------------------
 *		REINDEX Statement
 * ----------------------
1552
 */
1553
typedef struct ReindexStmt
1554
{
1555
	NodeTag		type;
1556
	int			reindexType;	/* INDEX|TABLE|DATABASE */
1557 1558
	RangeVar   *relation;		/* Table or index to reindex */
	const char *name;			/* name of database to reindex */
1559 1560 1561
	bool		force;
	bool		all;
} ReindexStmt;
1562

1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
/* ----------------------
 *		CREATE CONVERSION Statement
 * ----------------------
 */
typedef struct CreateConversionStmt
{
	NodeTag		type;
	List		*conversion_name;		/* Name of the conversion */
	char		*for_encoding_name;		/* source encoding name */
	char		*to_encoding_name;		/* destiname encoding name */
	List		*func_name;				/* qualified conversion function name */
	bool		def;				/* is this a default conversion? */
} CreateConversionStmt;

1577
#endif   /* PARSENODES_H */