gram.y 140 KB
Newer Older
1 2
%{ /* -*-text-*- */

3
/*#define YYDEBUG 1*/
4
/*-------------------------------------------------------------------------
5
 *
6
 * gram.y
7
 *	  POSTGRES SQL YACC rules/actions
8
 *
9 10 11 12
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
13
 *	  $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.85 1999/07/03 00:32:44 momjian Exp $
14 15
 *
 * HISTORY
16 17 18
 *	  AUTHOR			DATE			MAJOR EVENT
 *	  Andrew Yu			Sept, 1994		POSTQUEL to SQL conversion
 *	  Andrew Yu			Oct, 1994		lispy code conversion
19 20
 *
 * NOTES
21 22
 *	  CAPITALS are used to represent terminal symbols.
 *	  non-capitals are used to represent non-terminals.
23 24
 *	  SQL92-specific syntax is separated from plain SQL/Postgres syntax
 *	  to help isolate the non-extensible portions of the parser.
25
 *
26 27
 *	  if you use list, make sure the datum is a node so that the printing
 *	  routines work
28 29
 *
 * WARNING
30 31
 *	  sometimes we assign constants to makeStrings. Make sure we don't free
 *	  those.
32 33 34 35 36
 *
 *-------------------------------------------------------------------------
 */
#include <string.h>
#include <ctype.h>
Bruce Momjian's avatar
Bruce Momjian committed
37

38
#include "postgres.h"
39
#include "access/htup.h"
40
#include "nodes/parsenodes.h"
41
#include "nodes/print.h"
Bruce Momjian's avatar
Bruce Momjian committed
42
#include "parser/gramparse.h"
43
#include "parser/parse_type.h"
44
#include "utils/acl.h"
45
#include "utils/palloc.h"
46 47 48
#include "catalog/catname.h"
#include "utils/elog.h"
#include "access/xact.h"
49
#include "storage/lmgr.h"
50
#include "utils/numeric.h"
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
51
#include "parser/analyze.h"
52
#include "catalog/pg_type.h"
53

Marc G. Fournier's avatar
Marc G. Fournier committed
54
#ifdef MULTIBYTE
55 56 57
#include "mb/pg_wchar.h"
#endif

58
static char saved_relname[NAMEDATALEN];  /* need this for complex attributes */
59
static bool QueryIsRule = FALSE;
60
static List *saved_In_Expr = NIL;
61 62
static Oid	*param_type_info;
static int	pfunc_num_args;
63 64
extern List *parsetree;

65

66
/*
67
 * If you need access to certain yacc-generated variables and find that
68 69 70 71 72
 * they're static by default, uncomment the next line.  (this is not a
 * problem, yet.)
 */
/*#define __YYSCLASS*/

73
static char *xlateSqlFunc(char *);
74
static char *xlateSqlType(char *);
75
static Node *makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr);
Bruce Momjian's avatar
Bruce Momjian committed
76
static Node *makeRowExpr(char *opr, List *largs, List *rargs);
77
static void mapTargetColumns(List *source, List *target);
78 79
static List *makeConstantList( A_Const *node);
static char *FlattenStringList(List *list);
80
static char *fmtId(char *rawid);
81
static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr);
82
static void param_type_init(Oid *typev, int nargs);
83
static Node *doNegate(Node *n);
84 85

Oid	param_type(int t); /* used in parse_expr.c */
86 87 88 89 90 91 92 93

/* old versions of flex define this as a macro */
#if defined(yywrap)
#undef yywrap
#endif /* yywrap */
%}


94 95 96 97 98 99 100
%union
{
	double				dval;
	int					ival;
	char				chr;
	char				*str;
	bool				boolean;
101
	bool*				pboolean;	/* for pg_shadow privileges */
102 103 104 105 106 107 108 109 110 111
	List				*list;
	Node				*node;
	Value				*value;

	Attr				*attr;

	TypeName			*typnam;
	DefElem				*defelt;
	ParamString			*param;
	SortGroupBy			*sortgroupby;
112
	JoinExpr			*joinexpr;
113 114 115 116 117 118 119 120 121 122
	IndexElem			*ielem;
	RangeVar			*range;
	RelExpr				*relexp;
	A_Indices			*aind;
	ResTarget			*target;
	ParamNo				*paramno;

	VersionStmt			*vstmt;
	DefineStmt			*dstmt;
	RuleStmt			*rstmt;
Bruce Momjian's avatar
Bruce Momjian committed
123
	InsertStmt			*astmt;
124 125
}

126
%type <node>	stmt,
127
		AddAttrStmt, ClosePortalStmt,
128
		CopyStmt, CreateStmt, CreateAsStmt, CreateSeqStmt, DefineStmt, DestroyStmt,
129
		ExtendStmt, FetchStmt,	GrantStmt, CreateTrigStmt, DropTrigStmt,
130
		CreatePLangStmt, DropPLangStmt,
131
		IndexStmt, ListenStmt, UnlistenStmt, LockStmt, OptimizableStmt,
Bruce Momjian's avatar
Bruce Momjian committed
132
		ProcedureStmt, RemoveAggrStmt, RemoveOperStmt,
Bruce Momjian's avatar
Bruce Momjian committed
133
		RemoveFuncStmt, RemoveStmt,
134
		RenameStmt, RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
135
		CreatedbStmt, DestroydbStmt, VacuumStmt, CursorStmt, SubSelect,
136
		UpdateStmt, InsertStmt, select_clause, SelectStmt, NotifyStmt, DeleteStmt, 
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
137
		ClusterStmt, ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt,
138
		CreateUserStmt, AlterUserStmt, DropUserStmt, RuleActionStmt
139

140
%type <str>		opt_database1, opt_database2, location, encoding
141

142 143
%type <ival>	opt_lock, lock_type
%type <boolean>	opt_lmode
144

145
%type <pboolean> user_createdb_clause, user_createuser_clause
146 147 148
%type <str>		user_passwd_clause
%type <str>		user_valid_clause
%type <list>	user_group_list, user_group_clause
149

150
%type <boolean>	TriggerActionTime, TriggerForSpec, PLangTrusted
151

152
%type <str>		TriggerEvents, TriggerFuncArg
153

154 155
%type <str>		relation_name, copy_file_name, copy_delimiter, def_name,
		database_name, access_method_clause, access_method, attr_name,
Bruce Momjian's avatar
Bruce Momjian committed
156
		class, index_name, name, func_name, file_name, aggr_argtype
157

158
%type <str>		opt_id, opt_portal_name,
Bruce Momjian's avatar
Bruce Momjian committed
159
		all_Op, MathOp, opt_name, opt_unique,
160
		OptUseOp, opt_class, SpecialRuleRelation
161

162
%type <str>		opt_level
163 164
%type <str>		privileges, operation_commalist, grantee
%type <chr>		operation, TriggerOneEvent
165

166
%type <list>	stmtblock, stmtmulti,
167
		result, relation_name_list, OptTableElementList,
168
		OptInherit, definition,
169
		opt_with, func_args, func_args_list,
170
		oper_argtypes, RuleActionList, RuleActionBlock, RuleActionMulti,
171 172
		opt_column_list, columnList, opt_va_list, va_list,
		sort_clause, sortby_list, index_params, index_list, name_list,
173
		from_clause, from_expr, table_list, opt_array_bounds, nest_array_bounds,
174
		expr_list, attrs, res_target_list, res_target_list2,
175 176
		def_list, opt_indirection, group_clause, TriggerFuncArgs,
		opt_select_limit
177

178 179 180
%type <node>	func_return
%type <boolean>	set_opt

181
%type <boolean>	TriggerForOpt, TriggerForType, OptTemp, OptTempType, OptTempScope
182

183
%type <list>	for_update_clause, update_list
184
%type <boolean>	opt_union
185
%type <boolean>	opt_table
186
%type <boolean>	opt_trans
187

188 189 190 191 192
%type <list>	join_clause_with_union, join_clause, join_list, join_qual, using_list
%type <node>	join_expr, using_expr
%type <str>		join_outer
%type <ival>	join_type

193
%type <node>	position_expr
194 195
%type <list>	extract_list, position_list
%type <list>	substr_list, substr_from, substr_for, trim_list
196
%type <list>	opt_interval
197

198 199
%type <boolean> opt_inh_star, opt_binary, opt_instead, opt_with_copy,
				index_opt_unique, opt_verbose, opt_analyze
Jan Wieck's avatar
Jan Wieck committed
200
%type <boolean> opt_cursor
201

Bruce Momjian's avatar
Bruce Momjian committed
202 203
%type <ival>	copy_dirn, def_type, opt_direction, remove_type,
				opt_column, event
204

Bruce Momjian's avatar
Bruce Momjian committed
205
%type <ival>	fetch_how_many
206

207 208
%type <node>	select_limit_value, select_offset_value

Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
209 210 211
%type <list>	OptSeqList
%type <defelt>	OptSeqElem

212 213 214
%type <dstmt>	def_rest
%type <astmt>	insert_rest

215 216
%type <node>	OptTableElement, ConstraintElem
%type <node>	columnDef, alter_clause
217
%type <defelt>	def_elem
218
%type <node>	def_arg, columnElem, where_clause,
219
				a_expr, a_expr_or_null, b_expr, AexprConst,
220
				in_expr, in_expr_nodes, not_in_expr, not_in_expr_nodes,
221
				having_clause
222
%type <list>	row_descriptor, row_list, c_list, c_expr
223
%type <node>	row_expr
224
%type <str>		row_op
225 226
%type <node>	case_expr, case_arg, when_clause, case_default
%type <list>	when_clause_list
227
%type <ival>	sub_type
228 229
%type <list>	OptCreateAs, CreateAsList
%type <node>	CreateAsElement
230
%type <value>	NumericOnly, FloatOnly, IntegerOnly
231
%type <attr>	event_object, attr
232
%type <sortgroupby>		sortby
233
%type <ielem>	index_elem, func_index
234
%type <range>	table_expr
235 236
%type <relexp>	relation_expr
%type <target>	res_target_el, res_target_el2
237
%type <paramno> ParamNo
238

239
%type <typnam>	Typename, opt_type, Array, Generic, Character, Datetime, Numeric
240
%type <str>		generic, numeric, character, datetime
241
%type <str>		extract_arg
242
%type <str>		opt_charset, opt_collate
243 244
%type <str>		opt_float
%type <ival>	opt_numeric, opt_decimal
245 246
%type <boolean>	opt_varying, opt_timezone

247
%type <ival>	Iconst
248
%type <str>		Sconst
249
%type <str>		UserId, var_value, zone_value
250
%type <str>		ColId, ColLabel
251
%type <str>		TypeId
252

253
%type <node>	TableConstraint
254 255
%type <list>	constraint_list, constraint_expr
%type <list>	default_list, default_expr
256
%type <list>	ColPrimaryKey, ColQualList, ColQualifier
257
%type <node>	ColConstraint, ColConstraintElem
258 259
%type <list>	key_actions, key_action
%type <str>		key_match, key_reference
260 261 262

/*
 * If you make any token changes, remember to:
263 264
 *		- use "yacc -d" and update parse.h
 *		- update the keyword table in parser/keywords.c
265 266
 */

267 268 269 270 271 272 273 274 275 276
/* Reserved word tokens
 * SQL92 syntax has many type-specific constructs.
 * So, go ahead and make these types reserved words,
 *  and call-out the syntax explicitly.
 * This gets annoying when trying to also retain Postgres' nice
 *  type-extensible features, but we don't really have a choice.
 * - thomas 1997-10-11
 */

/* Keywords (in SQL92 reserved words) */
277
%token	ABSOLUTE, ACTION, ADD, ALL, ALTER, AND, ANY, AS, ASC,
278
		BEGIN_TRANS, BETWEEN, BOTH, BY,
279
		CASCADE, CASE, CAST, CHAR, CHARACTER, CHECK, CLOSE,
280
		COALESCE, COLLATE, COLUMN, COMMIT,
281 282
		CONSTRAINT, CREATE, CROSS, CURRENT, CURRENT_DATE, CURRENT_TIME, 
		CURRENT_TIMESTAMP, CURRENT_USER, CURSOR,
283
		DAY_P, DECIMAL, DECLARE, DEFAULT, DELETE, DESC, DISTINCT, DOUBLE, DROP,
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
284
		ELSE, END_TRANS, EXCEPT, EXECUTE, EXISTS, EXTRACT,
285
		FALSE_P, FETCH, FLOAT, FOR, FOREIGN, FROM, FULL,
286
		GLOBAL, GRANT, GROUP, HAVING, HOUR_P,
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
287 288
		IN, INNER_P, INSENSITIVE, INSERT, INTERSECT, INTERVAL, INTO, IS,
		ISOLATION, JOIN, KEY, LANGUAGE, LEADING, LEFT, LEVEL, LIKE, LOCAL,
289
		MATCH, MINUTE_P, MONTH_P, NAMES,
290
		NATIONAL, NATURAL, NCHAR, NEXT, NO, NOT, NULLIF, NULL_P, NUMERIC,
291 292 293 294
		OF, ON, ONLY, OPTION, OR, ORDER, OUTER_P,
		PARTIAL, POSITION, PRECISION, PRIMARY, PRIOR, PRIVILEGES, PROCEDURE, PUBLIC,
		READ, REFERENCES, RELATIVE, REVOKE, RIGHT, ROLLBACK,
		SCROLL, SECOND_P, SELECT, SET, SUBSTRING,
Bruce Momjian's avatar
Bruce Momjian committed
295 296
		TABLE, TEMP, TEMPORARY, THEN, TIME, TIMESTAMP, TIMEZONE_HOUR,
		TIMEZONE_MINUTE, TO, TRAILING, TRANSACTION, TRIM, TRUE_P,
297
		UNION, UNIQUE, UPDATE, USER, USING,
298
		VALUES, VARCHAR, VARYING, VIEW,
299
		WHEN, WHERE, WITH, WORK, YEAR_P, ZONE
300 301

/* Keywords (in SQL3 reserved words) */
302
%token	TRIGGER
303 304

/* Keywords (in SQL92 non-reserved words) */
305
%token	COMMITTED, SERIALIZABLE, TYPE_P
306

307 308 309 310 311 312
/* Keywords for Postgres support (not in SQL92 reserved words)
 *
 * The CREATEDB and CREATEUSER tokens should go away
 * when some sort of pg_privileges relation is introduced.
 * - Todd A. Brandys 1998-01-01?
 */
313 314
%token	ABORT_TRANS, ACCESS, AFTER, AGGREGATE, ANALYZE,
		BACKWARD, BEFORE, BINARY, 
315
		CACHE, CLUSTER, COPY, CREATEDB, CREATEUSER, CYCLE,
316 317
		DATABASE, DELIMITERS, DO,
		EACH, ENCODING, EXCLUSIVE, EXPLAIN, EXTEND,
Bruce Momjian's avatar
Bruce Momjian committed
318
		FORWARD, FUNCTION, HANDLER,
319
		INCREMENT, INDEX, INHERITS, INSTEAD, ISNULL,
320
		LANCOMPILER, LIMIT, LISTEN, LOAD, LOCATION, LOCK_P,
321
		MAXVALUE, MINVALUE, MODE, MOVE,
322
		NEW, NOCREATEDB, NOCREATEUSER, NONE, NOTHING, NOTIFY, NOTNULL,
323
		OFFSET, OIDS, OPERATOR, PASSWORD, PROCEDURAL,
Bruce Momjian's avatar
Bruce Momjian committed
324
		RENAME, RESET, RETURNS, ROW, RULE,
325 326
		SEQUENCE, SERIAL, SETOF, SHARE, SHOW, START, STATEMENT, STDIN, STDOUT,
		TRUSTED, 
327
		UNLISTEN, UNTIL, VACUUM, VALID, VERBOSE, VERSION
328

329
/* Special keywords, not in the query language - see the "lex" file */
330
%token <str>	IDENT, SCONST, Op
331 332 333
%token <ival>	ICONST, PARAM
%token <dval>	FCONST

334
/* these are not real. they are here so that they get generated as #define's*/
335
%token			OP
336 337

/* precedence */
338 339 340 341
%left		OR
%left		AND
%right		NOT
%right		'='
342
%nonassoc	'<' '>'
343 344 345
%nonassoc	LIKE
%nonassoc	BETWEEN
%nonassoc	IN
346
%left		Op				/* multi-character ops and user-defined operators */
347 348
%nonassoc	NOTNULL
%nonassoc	ISNULL
349
%nonassoc	NULL_P
350 351
%nonassoc	IS
%left		'+' '-'
352
%left		'*' '/' '%'
353 354 355 356 357 358 359 360
%left		'|'				/* this is the relation union op, not logical or */
/* Unary Operators */
%right		':'
%left		';'				/* end of statement or natural log */
%right		UMINUS
%left		'.'
%left		'[' ']'
%nonassoc	TYPECAST
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
361
%left		UNION INTERSECT EXCEPT
362 363
%%

364
stmtblock:  stmtmulti opt_semi
365 366
				{ parsetree = $1; }
		;
367

368 369 370
stmtmulti:  stmtmulti ';' stmt
				{ $$ = lappend($1, $3); }
		| stmt
371 372
				{ $$ = lcons($1,NIL); }
		;
373

374 375 376 377
opt_semi:	';'
		|	/*EMPTY*/
		;
		
378
stmt :	  AddAttrStmt
379
		| AlterUserStmt
380 381 382
		| ClosePortalStmt
		| CopyStmt
		| CreateStmt
383
		| CreateAsStmt
384
		| CreateSeqStmt
385
		| CreatePLangStmt
386
		| CreateTrigStmt
387
		| CreateUserStmt
388 389 390
		| ClusterStmt
		| DefineStmt
		| DestroyStmt
391
		| DropPLangStmt
392
		| DropTrigStmt
393
		| DropUserStmt
394 395 396 397 398 399
		| ExtendStmt
		| ExplainStmt
		| FetchStmt
		| GrantStmt
		| IndexStmt
		| ListenStmt
400
		| UnlistenStmt
401
		| LockStmt
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
		| ProcedureStmt
		| RemoveAggrStmt
		| RemoveOperStmt
		| RemoveFuncStmt
		| RemoveStmt
		| RenameStmt
		| RevokeStmt
		| OptimizableStmt
		| RuleStmt
		| TransactionStmt
		| ViewStmt
		| LoadStmt
		| CreatedbStmt
		| DestroydbStmt
		| VacuumStmt
		| VariableSetStmt
		| VariableShowStmt
		| VariableResetStmt
		;
421

422 423
/*****************************************************************************
 *
424
 * Create a new Postgres DBMS user
425 426 427 428
 *
 *
 *****************************************************************************/

429
CreateUserStmt:  CREATE USER UserId user_passwd_clause user_createdb_clause
430 431 432 433 434 435 436 437 438 439 440 441
			user_createuser_clause user_group_clause user_valid_clause
				{
					CreateUserStmt *n = makeNode(CreateUserStmt);
					n->user = $3;
					n->password = $4;
					n->createdb = $5;
					n->createuser = $6;
					n->groupElts = $7;
					n->validUntil = $8;
					$$ = (Node *)n;
				}
		;
442 443 444 445 446 447 448 449

/*****************************************************************************
 *
 * Alter a postresql DBMS user
 *
 *
 *****************************************************************************/

450
AlterUserStmt:  ALTER USER UserId user_passwd_clause user_createdb_clause
451 452 453 454 455 456 457 458 459 460 461 462
			user_createuser_clause user_group_clause user_valid_clause
				{
					AlterUserStmt *n = makeNode(AlterUserStmt);
					n->user = $3;
					n->password = $4;
					n->createdb = $5;
					n->createuser = $6;
					n->groupElts = $7;
					n->validUntil = $8;
					$$ = (Node *)n;
				}
		;
463 464 465 466 467 468 469 470

/*****************************************************************************
 *
 * Drop a postresql DBMS user
 *
 *
 *****************************************************************************/

471
DropUserStmt:  DROP USER UserId
472 473 474 475 476 477 478
				{
					DropUserStmt *n = makeNode(DropUserStmt);
					n->user = $3;
					$$ = (Node *)n;
				}
		;

479
user_passwd_clause:  WITH PASSWORD UserId		{ $$ = $3; }
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
			| /*EMPTY*/							{ $$ = NULL; }
		;

user_createdb_clause:  CREATEDB
				{
					bool*  b;
					$$ = (b = (bool*)palloc(sizeof(bool)));
					*b = true;
				}
			| NOCREATEDB
				{
					bool*  b;
					$$ = (b = (bool*)palloc(sizeof(bool)));
					*b = false;
				}
			| /*EMPTY*/							{ $$ = NULL; }
		;

user_createuser_clause:  CREATEUSER
				{
					bool*  b;
					$$ = (b = (bool*)palloc(sizeof(bool)));
					*b = true;
				}
			| NOCREATEUSER
				{
					bool*  b;
					$$ = (b = (bool*)palloc(sizeof(bool)));
					*b = false;
				}
			| /*EMPTY*/							{ $$ = NULL; }
		;

513
user_group_list:  user_group_list ',' UserId
514 515 516
				{
					$$ = lcons((void*)makeString($3), $1);
				}
517
			| UserId
518 519 520 521 522 523 524 525 526 527 528 529
				{
					$$ = lcons((void*)makeString($1), NIL);
				}
		;

user_group_clause:  IN GROUP user_group_list	{ $$ = $3; }
			| /*EMPTY*/							{ $$ = NULL; }
		;

user_valid_clause:  VALID UNTIL SCONST			{ $$ = $3; }
			| /*EMPTY*/							{ $$ = NULL; }
		;
530

531
/*****************************************************************************
532
 *
533
 * Set PG internal variable
534
 *	  SET name TO 'var_value'
535 536
 * Include SQL92 syntax (thomas 1997-10-22):
 *    SET TIME ZONE 'var_value'
537
 *
538 539
 *****************************************************************************/

540
VariableSetStmt:  SET ColId TO var_value
541 542 543 544 545 546
				{
					VariableSetStmt *n = makeNode(VariableSetStmt);
					n->name  = $2;
					n->value = $4;
					$$ = (Node *) n;
				}
547
		| SET ColId '=' var_value
548 549 550 551 552 553
				{
					VariableSetStmt *n = makeNode(VariableSetStmt);
					n->name  = $2;
					n->value = $4;
					$$ = (Node *) n;
				}
554
		| SET TIME ZONE zone_value
555 556 557 558 559 560
				{
					VariableSetStmt *n = makeNode(VariableSetStmt);
					n->name  = "timezone";
					n->value = $4;
					$$ = (Node *) n;
				}
561
		| SET TRANSACTION ISOLATION LEVEL opt_level
562 563 564 565 566 567
				{
					VariableSetStmt *n = makeNode(VariableSetStmt);
					n->name  = "XactIsoLevel";
					n->value = $5;
					$$ = (Node *) n;
				}
568 569 570 571 572 573 574 575 576 577 578
		| SET NAMES encoding
				{
#ifdef MB
					VariableSetStmt *n = makeNode(VariableSetStmt);
					n->name  = "client_encoding";
					n->value = $3;
					$$ = (Node *) n;
#else
					elog(ERROR, "SET NAMES is not supported");
#endif
				}
579 580
		;

581 582 583 584
opt_level:  READ COMMITTED					{ $$ = "committed"; }
		| SERIALIZABLE						{ $$ = "serializable"; }
		;

585
var_value:  Sconst			{ $$ = $1; }
586
		| DEFAULT			{ $$ = NULL; }
587 588
		;

589
zone_value:  Sconst			{ $$ = $1; }
590
		| DEFAULT			{ $$ = NULL; }
591
		| LOCAL				{ $$ = NULL; }
592
		;
593

594
VariableShowStmt:  SHOW ColId
595 596 597 598 599
				{
					VariableShowStmt *n = makeNode(VariableShowStmt);
					n->name  = $2;
					$$ = (Node *) n;
				}
600 601 602 603 604 605
		| SHOW TIME ZONE
				{
					VariableShowStmt *n = makeNode(VariableShowStmt);
					n->name  = "timezone";
					$$ = (Node *) n;
				}
606 607 608 609 610 611
		| SHOW TRANSACTION ISOLATION LEVEL
				{
					VariableShowStmt *n = makeNode(VariableShowStmt);
					n->name  = "XactIsoLevel";
					$$ = (Node *) n;
				}
612 613
		;

614
VariableResetStmt:	RESET ColId
615 616 617 618 619
				{
					VariableResetStmt *n = makeNode(VariableResetStmt);
					n->name  = $2;
					$$ = (Node *) n;
				}
620 621 622 623 624 625
		| RESET TIME ZONE
				{
					VariableResetStmt *n = makeNode(VariableResetStmt);
					n->name  = "timezone";
					$$ = (Node *) n;
				}
626 627 628 629 630 631
		| RESET TRANSACTION ISOLATION LEVEL
				{
					VariableResetStmt *n = makeNode(VariableResetStmt);
					n->name  = "XactIsoLevel";
					$$ = (Node *) n;
				}
632
		;
633

634

635 636
/*****************************************************************************
 *
637 638
 *		QUERY :
 *				addattr ( attr1 = type1 .. attrn = typen ) to <relname> [*]
639 640 641
 *
 *****************************************************************************/

642
AddAttrStmt:  ALTER TABLE relation_name opt_inh_star alter_clause
643 644 645 646
				{
					AddAttrStmt *n = makeNode(AddAttrStmt);
					n->relname = $3;
					n->inh = $4;
647
					n->colDef = $5;
648 649 650
					$$ = (Node *)n;
				}
		;
651

652 653 654 655
alter_clause:  ADD opt_column columnDef
				{
					$$ = $3;
				}
656
			| ADD '(' OptTableElementList ')'
657
				{
658
					Node *lp = lfirst($3);
659 660

					if (length($3) != 1)
Bruce Momjian's avatar
Bruce Momjian committed
661
						elog(ERROR,"ALTER TABLE/ADD() allows one column only");
662 663
					$$ = lp;
				}
664
			| DROP opt_column ColId
Bruce Momjian's avatar
Bruce Momjian committed
665
				{	elog(ERROR,"ALTER TABLE/DROP COLUMN not yet implemented"); }
666
			| ALTER opt_column ColId SET DEFAULT default_expr
Bruce Momjian's avatar
Bruce Momjian committed
667
				{	elog(ERROR,"ALTER TABLE/ALTER COLUMN/SET DEFAULT not yet implemented"); }
668
			| ALTER opt_column ColId DROP DEFAULT
Bruce Momjian's avatar
Bruce Momjian committed
669
				{	elog(ERROR,"ALTER TABLE/ALTER COLUMN/DROP DEFAULT not yet implemented"); }
670
			| ADD ConstraintElem
Bruce Momjian's avatar
Bruce Momjian committed
671
				{	elog(ERROR,"ALTER TABLE/ADD CONSTRAINT not yet implemented"); }
672 673
		;

674 675

/*****************************************************************************
676
 *
677 678
 *		QUERY :
 *				close <optname>
679
 *
680 681
 *****************************************************************************/

682
ClosePortalStmt:  CLOSE opt_id
683 684 685 686 687 688
				{
					ClosePortalStmt *n = makeNode(ClosePortalStmt);
					n->portalname = $2;
					$$ = (Node *)n;
				}
		;
689 690 691 692


/*****************************************************************************
 *
693 694 695
 *		QUERY :
 *				COPY [BINARY] <relname> FROM/TO
 *				[USING DELIMITERS <delimiter>]
696 697 698
 *
 *****************************************************************************/

699
CopyStmt:  COPY opt_binary relation_name opt_with_copy copy_dirn copy_file_name copy_delimiter
700 701 702 703 704 705 706 707 708 709 710 711 712 713
				{
					CopyStmt *n = makeNode(CopyStmt);
					n->binary = $2;
					n->relname = $3;
					n->oids = $4;
					n->direction = $5;
					n->filename = $6;
					n->delimiter = $7;
					$$ = (Node *)n;
				}
		;

copy_dirn:	TO
				{ $$ = TO; }
714
		| FROM
715 716
				{ $$ = FROM; }
		;
717

718
/*
719 720
 * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
 * used depends on the direction. (It really doesn't make sense to copy from
721
 * stdout. We silently correct the "typo".		 - AY 9/94
722
 */
723 724 725 726
copy_file_name:  Sconst							{ $$ = $1; }
		| STDIN									{ $$ = NULL; }
		| STDOUT								{ $$ = NULL; }
		;
727

728 729
opt_binary:  BINARY								{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
730
		;
731

732
opt_with_copy:	WITH OIDS						{ $$ = TRUE; }
733
		| /*EMPTY*/								{ $$ = FALSE; }
734
		;
735

736 737 738
/*
 * the default copy delimiter is tab but the user can configure it
 */
739 740
copy_delimiter:  USING DELIMITERS Sconst		{ $$ = $3; }
		| /*EMPTY*/								{ $$ = "\t"; }
741
		;
742 743 744 745


/*****************************************************************************
 *
746 747
 *		QUERY :
 *				CREATE relname
748 749 750
 *
 *****************************************************************************/

751
CreateStmt:  CREATE OptTemp TABLE relation_name '(' OptTableElementList ')'
752
				OptInherit
753 754
				{
					CreateStmt *n = makeNode(CreateStmt);
755 756 757 758
					n->istemp = $2;
					n->relname = $4;
					n->tableElts = $6;
					n->inhRelnames = $8;
759
					n->constraints = NIL;
760 761 762 763
					$$ = (Node *)n;
				}
		;

764 765 766 767 768
OptTemp:  OptTempType						{ $$ = $1; }
			| OptTempScope OptTempType		{ $$ = $2; }
		;

OptTempType:  TEMP							{ $$ = TRUE; }
Bruce Momjian's avatar
Bruce Momjian committed
769
			| TEMPORARY						{ $$ = TRUE; }
770 771 772
			| /*EMPTY*/						{ $$ = FALSE; }
		;

773 774 775 776 777 778 779 780 781 782 783
OptTempScope:  GLOBAL
				{
					elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
					$$ = TRUE;
				}
			| LOCAL
				{
					 $$ = FALSE;
				}
		;

784
OptTableElementList:  OptTableElementList ',' OptTableElement
785 786 787 788 789 790 791 792 793 794 795 796 797
				{
					if ($3 != NULL)
						$$ = lappend($1, $3);
					else
						$$ = $1;
				}
			| OptTableElement
				{
					if ($1 != NULL)
						$$ = lcons($1, NIL);
					else
						$$ = NULL;
				}
798
			| /*EMPTY*/							{ $$ = NULL; }
799
		;
800

801 802
OptTableElement:  columnDef						{ $$ = $1; }
			| TableConstraint					{ $$ = $1; }
803
		;
804

805
columnDef:  ColId Typename ColQualifier
806 807 808 809 810 811 812
				{
					ColumnDef *n = makeNode(ColumnDef);
					n->colname = $1;
					n->typename = $2;
					n->defval = NULL;
					n->is_not_null = FALSE;
					n->constraints = $3;
813 814
					$$ = (Node *)n;
				}
815
			| ColId SERIAL ColPrimaryKey
816 817 818 819 820 821 822 823
				{
					ColumnDef *n = makeNode(ColumnDef);
					n->colname = $1;
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("integer");
					n->defval = NULL;
					n->is_not_null = TRUE;
					n->is_sequence = TRUE;
824
					n->constraints = $3;
825

826 827 828 829
					$$ = (Node *)n;
				}
		;

830
ColQualifier:  ColQualList						{ $$ = $1; }
831
			| /*EMPTY*/							{ $$ = NULL; }
832
		;
833

834 835 836 837 838 839 840 841 842 843 844 845 846 847
ColQualList:  ColQualList ColConstraint
				{
					if ($2 != NULL)
						$$ = lappend($1, $2);
					else
						$$ = $1;
				}
			| ColConstraint
				{
					if ($1 != NULL)
						$$ = lcons($1, NIL);
					else
						$$ = NULL;
				}
848 849
		;

850 851 852 853 854 855 856 857 858 859 860 861
ColPrimaryKey:  PRIMARY KEY
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_PRIMARY;
					n->name = NULL;
					n->def = NULL;
					n->keys = NULL;
					$$ = lcons((Node *)n, NIL);
				}
			| /*EMPTY*/							{ $$ = NULL; }
		;

862 863 864 865
ColConstraint:
		CONSTRAINT name ColConstraintElem
				{
						Constraint *n = (Constraint *)$3;
866
						if (n != NULL) n->name = fmtId($2);
867 868 869 870
						$$ = $3;
				}
		| ColConstraintElem
				{ $$ = $1; }
871
		;
872

873
/* DEFAULT NULL is already the default for Postgres.
874 875 876
 * Bue define it here and carry it forward into the system
 * to make it explicit.
 * - thomas 1998-09-13
877 878 879 880 881
 * WITH NULL and NULL are not SQL92-standard syntax elements,
 * so leave them out. Use DEFAULT NULL to explicitly indicate
 * that a column may have that value. WITH NULL leads to
 * shift/reduce conflicts with WITH TIME ZONE anyway.
 * - thomas 1999-01-08
882
 */
883 884 885 886 887 888 889 890 891
ColConstraintElem:  CHECK '(' constraint_expr ')'
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_CHECK;
					n->name = NULL;
					n->def = FlattenStringList($3);
					n->keys = NULL;
					$$ = (Node *)n;
				}
892 893 894 895 896 897 898 899 900
			| DEFAULT NULL_P
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_DEFAULT;
					n->name = NULL;
					n->def = NULL;
					n->keys = NULL;
					$$ = (Node *)n;
				}
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
			| DEFAULT default_expr
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_DEFAULT;
					n->name = NULL;
					n->def = FlattenStringList($2);
					n->keys = NULL;
					$$ = (Node *)n;
				}
			| NOT NULL_P
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_NOTNULL;
					n->name = NULL;
					n->def = NULL;
					n->keys = NULL;
					$$ = (Node *)n;
				}
			| UNIQUE
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_UNIQUE;
					n->name = NULL;
					n->def = NULL;
					n->keys = NULL;
					$$ = (Node *)n;
				}
			| PRIMARY KEY
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_PRIMARY;
					n->name = NULL;
					n->def = NULL;
					n->keys = NULL;
					$$ = (Node *)n;
				}
			| REFERENCES ColId opt_column_list key_match key_actions
				{
Bruce Momjian's avatar
Bruce Momjian committed
939
					elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented");
940 941
					$$ = NULL;
				}
942
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
943

944 945 946 947 948 949 950 951 952 953 954
default_list:  default_list ',' default_expr
				{
					$$ = lappend($1,makeString(","));
					$$ = nconc($$, $3);
				}
			| default_expr
				{
					$$ = $1;
				}
		;

955 956 957
/* The Postgres default column value is NULL.
 * Rather than carrying DEFAULT NULL forward as a clause,
 * let's just have it be a no-op.
958 959
			| NULL_P
				{	$$ = lcons( makeString("NULL"), NIL); }
960 961 962 963
 * - thomas 1998-09-13
 */
default_expr:  AexprConst
				{	$$ = makeConstantList((A_Const *) $1); }
964 965 966 967 968 969 970 971
			| '-' default_expr %prec UMINUS
				{	$$ = lcons( makeString( "-"), $2); }
			| default_expr '+' default_expr
				{	$$ = nconc( $1, lcons( makeString( "+"), $3)); }
			| default_expr '-' default_expr
				{	$$ = nconc( $1, lcons( makeString( "-"), $3)); }
			| default_expr '/' default_expr
				{	$$ = nconc( $1, lcons( makeString( "/"), $3)); }
972 973
			| default_expr '%' default_expr
				{	$$ = nconc( $1, lcons( makeString( "%"), $3)); }
974 975 976
			| default_expr '*' default_expr
				{	$$ = nconc( $1, lcons( makeString( "*"), $3)); }
			| default_expr '=' default_expr
Bruce Momjian's avatar
Bruce Momjian committed
977
				{	elog(ERROR,"boolean expressions not supported in DEFAULT"); }
978
			| default_expr '<' default_expr
Bruce Momjian's avatar
Bruce Momjian committed
979
				{	elog(ERROR,"boolean expressions not supported in DEFAULT"); }
980
			| default_expr '>' default_expr
Bruce Momjian's avatar
Bruce Momjian committed
981
				{	elog(ERROR,"boolean expressions not supported in DEFAULT"); }
982 983 984 985 986 987 988 989 990 991 992
			| ':' default_expr
				{	$$ = lcons( makeString( ":"), $2); }
			| ';' default_expr
				{	$$ = lcons( makeString( ";"), $2); }
			| '|' default_expr
				{	$$ = lcons( makeString( "|"), $2); }
			| default_expr TYPECAST Typename
				{
					$3->name = fmtId($3->name);
					$$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
				}
993
			| CAST '(' default_expr AS Typename ')'
994
				{
995 996
					$5->name = fmtId($5->name);
					$$ = nconc( lcons( makeString( "CAST"), $3), makeList( makeString("AS"), $5, -1));
997 998 999
				}
			| '(' default_expr ')'
				{	$$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
1000
			| func_name '(' ')'
1001 1002 1003 1004
				{
					$$ = makeList( makeString($1), makeString("("), -1);
					$$ = lappend( $$, makeString(")"));
				}
1005
			| func_name '(' default_list ')'
1006 1007
				{
					$$ = makeList( makeString($1), makeString("("), -1);
1008
					$$ = nconc( $$, $3);
1009 1010 1011 1012 1013
					$$ = lappend( $$, makeString(")"));
				}
			| default_expr Op default_expr
				{
					if (!strcmp("<=", $2) || !strcmp(">=", $2))
Bruce Momjian's avatar
Bruce Momjian committed
1014
						elog(ERROR,"boolean expressions not supported in DEFAULT");
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
					$$ = nconc( $1, lcons( makeString( $2), $3));
				}
			| Op default_expr
				{	$$ = lcons( makeString( $1), $2); }
			| default_expr Op
				{	$$ = lappend( $1, makeString( $2)); }
			/* XXX - thomas 1997-10-07 v6.2 function-specific code to be changed */
			| CURRENT_DATE
				{	$$ = lcons( makeString( "date( 'current'::datetime + '0 sec')"), NIL); }
			| CURRENT_TIME
				{	$$ = lcons( makeString( "'now'::time"), NIL); }
			| CURRENT_TIME '(' Iconst ')'
				{
					if ($3 != 0)
						elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
					$$ = lcons( makeString( "'now'::time"), NIL);
				}
			| CURRENT_TIMESTAMP
				{	$$ = lcons( makeString( "now()"), NIL); }
			| CURRENT_TIMESTAMP '(' Iconst ')'
				{
					if ($3 != 0)
						elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
					$$ = lcons( makeString( "now()"), NIL);
				}
			| CURRENT_USER
				{	$$ = lcons( makeString( "CURRENT_USER"), NIL); }
1042 1043
			| USER
				{	$$ = lcons( makeString( "USER"), NIL); }
1044 1045
		;

1046 1047 1048 1049 1050
/* ConstraintElem specifies constraint syntax which is not embedded into
 *  a column definition. ColConstraintElem specifies the embedded form.
 * - thomas 1997-12-03
 */
TableConstraint:  CONSTRAINT name ConstraintElem
1051
				{
1052
						Constraint *n = (Constraint *)$3;
1053
						if (n != NULL) n->name = fmtId($2);
1054 1055
						$$ = $3;
				}
1056 1057
		| ConstraintElem
				{ $$ = $1; }
1058 1059
		;

1060
ConstraintElem:  CHECK '(' constraint_expr ')'
1061
				{
1062 1063 1064 1065 1066
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_CHECK;
					n->name = NULL;
					n->def = FlattenStringList($3);
					$$ = (Node *)n;
1067
				}
1068
		| UNIQUE '(' columnList ')'
1069 1070 1071 1072 1073 1074 1075 1076
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_UNIQUE;
					n->name = NULL;
					n->def = NULL;
					n->keys = $3;
					$$ = (Node *)n;
				}
1077
		| PRIMARY KEY '(' columnList ')'
1078 1079 1080 1081 1082 1083 1084 1085
				{
					Constraint *n = makeNode(Constraint);
					n->contype = CONSTR_PRIMARY;
					n->name = NULL;
					n->def = NULL;
					n->keys = $4;
					$$ = (Node *)n;
				}
1086
		| FOREIGN KEY '(' columnList ')' REFERENCES ColId opt_column_list key_match key_actions
1087 1088 1089 1090
				{
					elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented");
					$$ = NULL;
				}
1091
		;
1092

1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
constraint_list:  constraint_list ',' constraint_expr
				{
					$$ = lappend($1,makeString(","));
					$$ = nconc($$, $3);
				}
			| constraint_expr
				{
					$$ = $1;
				}
		;

1104
constraint_expr:  AexprConst
1105
				{	$$ = makeConstantList((A_Const *) $1); }
1106
			| NULL_P
1107
				{	$$ = lcons( makeString("NULL"), NIL); }
1108
			| ColId
1109
				{
1110
					$$ = lcons( makeString(fmtId($1)), NIL);
1111
				}
1112
			| '-' constraint_expr %prec UMINUS
1113
				{	$$ = lcons( makeString( "-"), $2); }
1114
			| constraint_expr '+' constraint_expr
1115
				{	$$ = nconc( $1, lcons( makeString( "+"), $3)); }
1116
			| constraint_expr '-' constraint_expr
1117
				{	$$ = nconc( $1, lcons( makeString( "-"), $3)); }
1118
			| constraint_expr '/' constraint_expr
1119
				{	$$ = nconc( $1, lcons( makeString( "/"), $3)); }
1120 1121
			| constraint_expr '%' constraint_expr
				{	$$ = nconc( $1, lcons( makeString( "%"), $3)); }
1122
			| constraint_expr '*' constraint_expr
1123
				{	$$ = nconc( $1, lcons( makeString( "*"), $3)); }
1124
			| constraint_expr '=' constraint_expr
1125
				{	$$ = nconc( $1, lcons( makeString( "="), $3)); }
1126
			| constraint_expr '<' constraint_expr
1127
				{	$$ = nconc( $1, lcons( makeString( "<"), $3)); }
1128
			| constraint_expr '>' constraint_expr
1129
				{	$$ = nconc( $1, lcons( makeString( ">"), $3)); }
1130
			| ':' constraint_expr
1131
				{	$$ = lcons( makeString( ":"), $2); }
1132
			| ';' constraint_expr
1133
				{	$$ = lcons( makeString( ";"), $2); }
1134
			| '|' constraint_expr
1135
				{	$$ = lcons( makeString( "|"), $2); }
1136
			| constraint_expr TYPECAST Typename
1137
				{
1138 1139
					$3->name = fmtId($3->name);
					$$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
1140
				}
1141
			| CAST '(' constraint_expr AS Typename ')'
1142
				{
1143 1144
					$5->name = fmtId($5->name);
					$$ = nconc( lcons( makeString( "CAST"), $3), makeList( makeString("AS"), $5, -1));
1145
				}
1146
			| '(' constraint_expr ')'
1147
				{	$$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
1148
			| func_name '(' ')'
1149 1150 1151 1152
				{
					$$ = makeList( makeString($1), makeString("("), -1);
					$$ = lappend( $$, makeString(")"));
				}
1153
			| func_name '(' constraint_list ')'
1154 1155 1156 1157 1158
				{
					$$ = makeList( makeString($1), makeString("("), -1);
					$$ = nconc( $$, $3);
					$$ = lappend( $$, makeString(")"));
				}
1159
			| constraint_expr Op constraint_expr
1160
				{	$$ = nconc( $1, lcons( makeString( $2), $3)); }
1161
			| constraint_expr LIKE constraint_expr
1162 1163 1164
				{	$$ = nconc( $1, lcons( makeString( "LIKE"), $3)); }
			| constraint_expr NOT LIKE constraint_expr
				{	$$ = nconc( $1, lcons( makeString( "NOT LIKE"), $4)); }
1165
			| constraint_expr AND constraint_expr
1166
				{	$$ = nconc( $1, lcons( makeString( "AND"), $3)); }
1167
			| constraint_expr OR constraint_expr
1168
				{	$$ = nconc( $1, lcons( makeString( "OR"), $3)); }
1169 1170
			| NOT constraint_expr
				{	$$ = lcons( makeString( "NOT"), $2); }
1171
			| Op constraint_expr
1172
				{	$$ = lcons( makeString( $1), $2); }
1173
			| constraint_expr Op
1174
				{	$$ = lappend( $1, makeString( $2)); }
1175 1176 1177 1178 1179 1180 1181 1182
			| constraint_expr ISNULL
				{	$$ = lappend( $1, makeString( "IS NULL")); }
			| constraint_expr IS NULL_P
				{	$$ = lappend( $1, makeString( "IS NULL")); }
			| constraint_expr NOTNULL
				{	$$ = lappend( $1, makeString( "IS NOT NULL")); }
			| constraint_expr IS NOT NULL_P
				{	$$ = lappend( $1, makeString( "IS NOT NULL")); }
1183
			| constraint_expr IS TRUE_P
1184
				{	$$ = lappend( $1, makeString( "IS TRUE")); }
1185
			| constraint_expr IS FALSE_P
1186
				{	$$ = lappend( $1, makeString( "IS FALSE")); }
1187
			| constraint_expr IS NOT TRUE_P
1188
				{	$$ = lappend( $1, makeString( "IS NOT TRUE")); }
1189
			| constraint_expr IS NOT FALSE_P
1190
				{	$$ = lappend( $1, makeString( "IS NOT FALSE")); }
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
			| constraint_expr IN '(' c_list ')'
				{
					$$ = lappend( $1, makeString("IN"));
					$$ = lappend( $$, makeString("("));
					$$ = nconc( $$, $4);
					$$ = lappend( $$, makeString(")"));
				}
			| constraint_expr NOT IN '(' c_list ')'
				{
					$$ = lappend( $1, makeString("NOT IN"));
					$$ = lappend( $$, makeString("("));
					$$ = nconc( $$, $5);
					$$ = lappend( $$, makeString(")"));
				}
			| constraint_expr BETWEEN c_expr AND c_expr
				{
					$$ = lappend( $1, makeString("BETWEEN"));
					$$ = nconc( $$, $3);
					$$ = lappend( $$, makeString("AND"));
					$$ = nconc( $$, $5);
				}
			| constraint_expr NOT BETWEEN c_expr AND c_expr
				{
					$$ = lappend( $1, makeString("NOT BETWEEN"));
					$$ = nconc( $$, $4);
					$$ = lappend( $$, makeString("AND"));
					$$ = nconc( $$, $6);
				}
		;

c_list:  c_list ',' c_expr
				{
					$$ = lappend($1, makeString(","));
					$$ = nconc($$, $3);
				}
			| c_expr
				{
					$$ = $1;
				}
		;

c_expr:  AexprConst
				{	$$ = makeConstantList((A_Const *) $1); }
1234 1235
		;

1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
key_match:  MATCH FULL					{ $$ = NULL; }
		| MATCH PARTIAL					{ $$ = NULL; }
		| /*EMPTY*/						{ $$ = NULL; }
		;

key_actions:  key_action key_action		{ $$ = NIL; }
		| key_action					{ $$ = NIL; }
		| /*EMPTY*/						{ $$ = NIL; }
		;

key_action:  ON DELETE key_reference	{ $$ = NIL; }
		| ON UPDATE key_reference		{ $$ = NIL; }
		;

key_reference:  NO ACTION				{ $$ = NULL; }
		| CASCADE						{ $$ = NULL; }
		| SET DEFAULT					{ $$ = NULL; }
		| SET NULL_P					{ $$ = NULL; }
		;

1256 1257 1258 1259
OptInherit:  INHERITS '(' relation_name_list ')'		{ $$ = $3; }
		| /*EMPTY*/										{ $$ = NIL; }
		;

1260
CreateAsStmt:  CREATE OptTemp TABLE relation_name OptCreateAs AS SubSelect
1261
				{
1262 1263 1264 1265 1266
					SelectStmt *n = (SelectStmt *)$7;
					if ($5 != NIL)
						mapTargetColumns($5, n->targetList);
					n->istemp = $2;
					n->into = $4;
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
					$$ = (Node *)n;
				}
		;

OptCreateAs:  '(' CreateAsList ')'				{ $$ = $2; }
			| /*EMPTY*/							{ $$ = NULL; }
		;

CreateAsList:  CreateAsList ',' CreateAsElement	{ $$ = lappend($1, $3); }
			| CreateAsElement					{ $$ = lcons($1, NIL); }
		;

CreateAsElement:  ColId
				{
					ColumnDef *n = makeNode(ColumnDef);
					n->colname = $1;
					n->typename = NULL;
					n->defval = NULL;
					n->is_not_null = FALSE;
					n->constraints = NULL;
					$$ = (Node *)n;
				}
		;

1291

Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1292 1293
/*****************************************************************************
 *
1294 1295
 *		QUERY :
 *				CREATE SEQUENCE seqname
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1296 1297 1298
 *
 *****************************************************************************/

1299
CreateSeqStmt:  CREATE SEQUENCE relation_name OptSeqList
1300 1301 1302 1303 1304 1305 1306
				{
					CreateSeqStmt *n = makeNode(CreateSeqStmt);
					n->seqname = $3;
					n->options = $4;
					$$ = (Node *)n;
				}
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1307

1308
OptSeqList:  OptSeqList OptSeqElem
1309
				{ $$ = lappend($1, $2); }
1310
			|	{ $$ = NIL; }
1311 1312
		;

1313
OptSeqElem:  CACHE IntegerOnly
1314 1315
				{
					$$ = makeNode(DefElem);
1316
					$$->defname = "cache";
1317 1318
					$$->arg = (Node *)$2;
				}
1319
			| CYCLE
1320 1321
				{
					$$ = makeNode(DefElem);
1322
					$$->defname = "cycle";
1323 1324
					$$->arg = (Node *)NULL;
				}
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
			| INCREMENT IntegerOnly
				{
					$$ = makeNode(DefElem);
					$$->defname = "increment";
					$$->arg = (Node *)$2;
				}
			| MAXVALUE IntegerOnly
				{
					$$ = makeNode(DefElem);
					$$->defname = "maxvalue";
					$$->arg = (Node *)$2;
				}
			| MINVALUE IntegerOnly
				{
					$$ = makeNode(DefElem);
					$$->defname = "minvalue";
					$$->arg = (Node *)$2;
				}
			| START IntegerOnly
				{
					$$ = makeNode(DefElem);
					$$->defname = "start";
					$$->arg = (Node *)$2;
				}
		;

1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
NumericOnly:  FloatOnly					{ $$ = $1; }
			| IntegerOnly				{ $$ = $1; }

FloatOnly:  FCONST
				{
					$$ = makeFloat($1);
				}
			| '-' FCONST
				{
					$$ = makeFloat($2);
					$$->val.dval = - $$->val.dval;
				}
		;

1365 1366 1367 1368 1369 1370 1371 1372 1373
IntegerOnly:  Iconst
				{
					$$ = makeInteger($1);
				}
			| '-' Iconst
				{
					$$ = makeInteger($2);
					$$->val.ival = - $$->val.ival;
				}
1374
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1375

1376 1377 1378 1379 1380 1381 1382 1383
/*****************************************************************************
 *
 *		QUERIES :
 *				CREATE PROCEDURAL LANGUAGE ...
 *				DROP PROCEDURAL LANGUAGE ...
 *
 *****************************************************************************/

1384
CreatePLangStmt:  CREATE PLangTrusted PROCEDURAL LANGUAGE Sconst 
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
			HANDLER def_name LANCOMPILER Sconst
			{
				CreatePLangStmt *n = makeNode(CreatePLangStmt);
				n->plname = $5;
				n->plhandler = $7;
				n->plcompiler = $9;
				n->pltrusted = $2;
				$$ = (Node *)n;
			}
		;

PLangTrusted:		TRUSTED { $$ = TRUE; }
			|	{ $$ = FALSE; }

1399
DropPLangStmt:  DROP PROCEDURAL LANGUAGE Sconst
1400 1401 1402 1403 1404 1405
			{
				DropPLangStmt *n = makeNode(DropPLangStmt);
				n->plname = $4;
				$$ = (Node *)n;
			}
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1406

1407 1408
/*****************************************************************************
 *
1409 1410 1411
 *		QUERIES :
 *				CREATE TRIGGER ...
 *				DROP TRIGGER ...
1412 1413 1414
 *
 *****************************************************************************/

1415
CreateTrigStmt:  CREATE TRIGGER name TriggerActionTime TriggerEvents ON
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
				relation_name TriggerForSpec EXECUTE PROCEDURE
				name '(' TriggerFuncArgs ')'
				{
					CreateTrigStmt *n = makeNode(CreateTrigStmt);
					n->trigname = $3;
					n->relname = $7;
					n->funcname = $11;
					n->args = $13;
					n->before = $4;
					n->row = $8;
					memcpy (n->actions, $5, 4);
					$$ = (Node *)n;
				}
		;

1431 1432
TriggerActionTime:  BEFORE						{ $$ = TRUE; }
			| AFTER								{ $$ = FALSE; }
1433 1434 1435
		;

TriggerEvents:	TriggerOneEvent
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
				{
					char *e = palloc (4);
					e[0] = $1; e[1] = 0; $$ = e;
				}
			| TriggerOneEvent OR TriggerOneEvent
				{
					char *e = palloc (4);
					e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
				}
			| TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
				{
					char *e = palloc (4);
					e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
					$$ = e;
				}
1451 1452
		;

1453 1454 1455
TriggerOneEvent:  INSERT					{ $$ = 'i'; }
			| DELETE						{ $$ = 'd'; }
			| UPDATE						{ $$ = 'u'; }
1456 1457
		;

1458
TriggerForSpec:  FOR TriggerForOpt TriggerForType
1459
				{
1460
					$$ = $3;
1461 1462
				}
		;
1463

1464 1465 1466 1467 1468 1469 1470 1471
TriggerForOpt:  EACH						{ $$ = TRUE; }
			| /*EMPTY*/						{ $$ = FALSE; }
		;

TriggerForType:  ROW						{ $$ = TRUE; }
			| STATEMENT						{ $$ = FALSE; }
		;

1472
TriggerFuncArgs:  TriggerFuncArg
1473
				{ $$ = lcons($1, NIL); }
1474
			| TriggerFuncArgs ',' TriggerFuncArg
1475
				{ $$ = lappend($1, $3); }
1476
			| /*EMPTY*/
1477
				{ $$ = NIL; }
1478 1479
		;

1480
TriggerFuncArg:  ICONST
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
				{
					char *s = (char *) palloc (256);
					sprintf (s, "%d", $1);
					$$ = s;
				}
			| FCONST
				{
					char *s = (char *) palloc (256);
					sprintf (s, "%g", $1);
					$$ = s;
				}
			| Sconst						{  $$ = $1; }
			| IDENT							{  $$ = $1; }
1494
		;
1495

1496
DropTrigStmt:  DROP TRIGGER name ON relation_name
1497 1498 1499 1500 1501 1502 1503
				{
					DropTrigStmt *n = makeNode(DropTrigStmt);
					n->trigname = $3;
					n->relname = $5;
					$$ = (Node *) n;
				}
		;
1504

1505

1506 1507
/*****************************************************************************
 *
1508 1509
 *		QUERY :
 *				define (type,operator,aggregate)
1510 1511 1512 1513
 *
 *****************************************************************************/

DefineStmt:  CREATE def_type def_rest
1514 1515 1516 1517 1518
				{
					$3->defType = $2;
					$$ = (Node *)$3;
				}
		;
1519

1520
def_rest:  def_name definition
1521 1522 1523 1524 1525 1526 1527
				{
					$$ = makeNode(DefineStmt);
					$$->defname = $1;
					$$->definition = $2;
				}
		;

1528
def_type:  OPERATOR							{ $$ = OPERATOR; }
1529
		| TYPE_P							{ $$ = TYPE_P; }
1530
		| AGGREGATE							{ $$ = AGGREGATE; }
1531
		;
1532

1533
def_name:  PROCEDURE						{ $$ = "procedure"; }
1534 1535 1536 1537
		| JOIN								{ $$ = "join"; }
		| ColId								{ $$ = $1; }
		| MathOp							{ $$ = $1; }
		| Op								{ $$ = $1; }
1538
		;
1539

1540
definition:  '(' def_list ')'				{ $$ = $2; }
1541
		;
1542

1543
def_list:  def_elem							{ $$ = lcons($1, NIL); }
1544
		| def_list ',' def_elem				{ $$ = lappend($1, $3); }
1545
		;
1546 1547

def_elem:  def_name '=' def_arg
1548 1549 1550 1551 1552
				{
					$$ = makeNode(DefElem);
					$$->defname = $1;
					$$->arg = (Node *)$3;
				}
1553
		| def_name
1554 1555 1556 1557 1558
				{
					$$ = makeNode(DefElem);
					$$->defname = $1;
					$$->arg = (Node *)NULL;
				}
1559
		| DEFAULT '=' def_arg
1560 1561
				{
					$$ = makeNode(DefElem);
1562
					$$->defname = "default";
1563 1564 1565 1566
					$$->arg = (Node *)$3;
				}
		;

1567 1568
def_arg:  ColId							{  $$ = (Node *)makeString($1); }
		| all_Op						{  $$ = (Node *)makeString($1); }
1569
		| NumericOnly					{  $$ = (Node *)$1; }
1570 1571
		| Sconst						{  $$ = (Node *)makeString($1); }
		| SETOF ColId
1572 1573 1574 1575 1576
				{
					TypeName *n = makeNode(TypeName);
					n->name = $2;
					n->setof = TRUE;
					n->arrayBounds = NULL;
1577
					n->typmod = -1;
1578 1579
					$$ = (Node *)n;
				}
1580
		;
1581 1582 1583 1584


/*****************************************************************************
 *
1585 1586
 *		QUERY:
 *				destroy <relname1> [, <relname2> .. <relnameN> ]
1587 1588 1589
 *
 *****************************************************************************/

1590
DestroyStmt:  DROP TABLE relation_name_list
1591 1592 1593
				{
					DestroyStmt *n = makeNode(DestroyStmt);
					n->relNames = $3;
1594
					n->sequence = FALSE;
1595 1596
					$$ = (Node *)n;
				}
1597
		| DROP SEQUENCE relation_name_list
1598 1599 1600
				{
					DestroyStmt *n = makeNode(DestroyStmt);
					n->relNames = $3;
1601
					n->sequence = TRUE;
1602 1603 1604
					$$ = (Node *)n;
				}
		;
1605 1606 1607 1608


/*****************************************************************************
 *
1609
 *		QUERY:
1610 1611 1612
 *			fetch/move [forward | backward] [ # | all ] [ in <portalname> ]
 *			fetch [ forward | backward | absolute | relative ]
 *			      [ # | all | next | prior ] [ [ in | from ] <portalname> ]
1613 1614 1615
 *
 *****************************************************************************/

1616 1617 1618
FetchStmt:	FETCH opt_direction fetch_how_many opt_portal_name
				{
					FetchStmt *n = makeNode(FetchStmt);
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
					if ($2 == RELATIVE)
					{
						if ($3 == 0)
							elog(ERROR,"FETCH/RELATIVE at current position is not supported");
						$2 = FORWARD;
					}
					if ($3 < 0)
					{
						$3 = -$3;
						$2 = (($2 == FORWARD)? BACKWARD: FORWARD);
					}
1630 1631 1632
					n->direction = $2;
					n->howMany = $3;
					n->portalname = $4;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1633 1634 1635 1636 1637 1638
					n->ismove = false;
					$$ = (Node *)n;
				}
		|	MOVE opt_direction fetch_how_many opt_portal_name
				{
					FetchStmt *n = makeNode(FetchStmt);
1639 1640 1641 1642 1643
					if ($3 < 0)
					{
						$3 = -$3;
						$2 = (($2 == FORWARD)? BACKWARD: FORWARD);
					}
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1644 1645 1646
					n->direction = $2;
					n->howMany = $3;
					n->portalname = $4;
1647
					n->ismove = TRUE;
1648 1649 1650 1651
					$$ = (Node *)n;
				}
		;

1652 1653 1654 1655 1656 1657 1658 1659 1660
opt_direction:	FORWARD					{ $$ = FORWARD; }
		| BACKWARD						{ $$ = BACKWARD; }
		| RELATIVE						{ $$ = RELATIVE; }
		| ABSOLUTE
			{
				elog(NOTICE,"FETCH/ABSOLUTE not supported, using RELATIVE");
				$$ = RELATIVE;
			}
		| /*EMPTY*/						{ $$ = FORWARD; /* default */ }
1661
		;
1662

1663 1664
fetch_how_many:  Iconst					{ $$ = $1; }
		| '-' Iconst					{ $$ = - $2; }
1665
		| ALL							{ $$ = 0; /* 0 means fetch all tuples*/ }
1666 1667
		| NEXT							{ $$ = 1; }
		| PRIOR							{ $$ = -1; }
1668
		| /*EMPTY*/						{ $$ = 1; /*default*/ }
1669
		;
1670

1671
opt_portal_name:  IN name				{ $$ = $2; }
1672
		| FROM name						{ $$ = $2; }
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
1673 1674 1675
		| /*EMPTY*/						{ $$ = NULL; }
		;

1676

1677 1678
/*****************************************************************************
 *
1679 1680
 *		QUERY:
 *				GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
1681 1682 1683
 *
 *****************************************************************************/

1684
GrantStmt:  GRANT privileges ON relation_name_list TO grantee opt_with_grant
1685 1686 1687 1688
				{
					$$ = (Node*)makeAclStmt($2,$4,$6,'+');
				}
		;
1689 1690

privileges:  ALL PRIVILEGES
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
				{
				 $$ = aclmakepriv("rwaR",0);
				}
		| ALL
				{
				 $$ = aclmakepriv("rwaR",0);
				}
		| operation_commalist
				{
				 $$ = $1;
				}
		;

1704
operation_commalist:  operation
1705 1706 1707 1708 1709 1710 1711 1712 1713
				{
						$$ = aclmakepriv("",$1);
				}
		| operation_commalist ',' operation
				{
						$$ = aclmakepriv($1,$3);
				}
		;

1714
operation:  SELECT
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
				{
						$$ = ACL_MODE_RD_CHR;
				}
		| INSERT
				{
						$$ = ACL_MODE_AP_CHR;
				}
		| UPDATE
				{
						$$ = ACL_MODE_WR_CHR;
				}
		| DELETE
				{
						$$ = ACL_MODE_WR_CHR;
				}
1730
		| RULE
1731 1732 1733 1734 1735 1736 1737 1738 1739
				{
						$$ = ACL_MODE_RU_CHR;
				}
		;

grantee:  PUBLIC
				{
						$$ = aclmakeuser("A","");
				}
1740
		| GROUP ColId
1741 1742 1743
				{
						$$ = aclmakeuser("G",$2);
				}
1744
		| ColId
1745 1746 1747 1748
				{
						$$ = aclmakeuser("U",$1);
				}
		;
1749

1750
opt_with_grant:  WITH GRANT OPTION
1751 1752
				{
					yyerror("WITH GRANT OPTION is not supported.  Only relation owners can set privileges");
1753 1754
				 }
		| /*EMPTY*/
1755 1756
		;

1757

1758 1759
/*****************************************************************************
 *
1760 1761
 *		QUERY:
 *				REVOKE [privileges] ON [relation_name] FROM [user]
1762 1763 1764
 *
 *****************************************************************************/

1765
RevokeStmt:  REVOKE privileges ON relation_name_list FROM grantee
1766 1767 1768 1769
				{
					$$ = (Node*)makeAclStmt($2,$4,$6,'-');
				}
		;
1770

1771

1772 1773
/*****************************************************************************
 *
1774
 *		QUERY:
Bruce Momjian's avatar
Bruce Momjian committed
1775
 *				create index <indexname> on <relname>
1776 1777
 *				  using <access> "(" (<col> with <op>)+ ")" [with
 *				  <target_list>]
1778
 *
1779
 *	[where <qual>] is not supported anymore
1780 1781
 *****************************************************************************/

1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
IndexStmt:	CREATE index_opt_unique INDEX index_name ON relation_name
			access_method_clause '(' index_params ')' opt_with
				{
					/* should check that access_method is valid,
					   etc ... but doesn't */
					IndexStmt *n = makeNode(IndexStmt);
					n->unique = $2;
					n->idxname = $4;
					n->relname = $6;
					n->accessMethod = $7;
					n->indexParams = $9;
					n->withClause = $11;
					n->whereClause = NULL;
					$$ = (Node *)n;
				}
		;

1799 1800
index_opt_unique:  UNIQUE						{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
1801 1802
		;

1803 1804
access_method_clause:  USING access_method		{ $$ = $2; }
		| /*EMPTY*/								{ $$ = "btree"; }
1805
		;
1806

1807 1808 1809 1810 1811 1812 1813 1814
index_params:  index_list						{ $$ = $1; }
		| func_index							{ $$ = lcons($1,NIL); }
		;

index_list:  index_list ',' index_elem			{ $$ = lappend($1, $3); }
		| index_elem							{ $$ = lcons($1, NIL); }
		;

1815
func_index:  func_name '(' name_list ')' opt_type opt_class
1816 1817 1818 1819 1820
				{
					$$ = makeNode(IndexElem);
					$$->name = $1;
					$$->args = $3;
					$$->class = $6;
1821
					$$->typename = $5;
1822 1823 1824 1825 1826 1827 1828 1829 1830
				}
		  ;

index_elem:  attr_name opt_type opt_class
				{
					$$ = makeNode(IndexElem);
					$$->name = $1;
					$$->args = NIL;
					$$->class = $3;
1831
					$$->typename = $2;
1832 1833 1834
				}
		;

1835 1836 1837
opt_type:  ':' Typename							{ $$ = $2; }
		| FOR Typename							{ $$ = $2; }
		| /*EMPTY*/								{ $$ = NULL; }
1838 1839 1840 1841 1842 1843
		;

/* opt_class "WITH class" conflicts with preceeding opt_type
 *  for Typename of "TIMESTAMP WITH TIME ZONE"
 * So, remove "WITH class" from the syntax. OK??
 * - thomas 1997-10-12
1844
 *		| WITH class							{ $$ = $2; }
1845 1846
 */
opt_class:  class								{ $$ = $1; }
1847
		| USING class							{ $$ = $2; }
1848 1849 1850 1851
		| /*EMPTY*/								{ $$ = NULL; }
		;


1852 1853
/*****************************************************************************
 *
1854 1855
 *		QUERY:
 *				extend index <indexname> [where <qual>]
1856 1857 1858 1859
 *
 *****************************************************************************/

ExtendStmt:  EXTEND INDEX index_name where_clause
1860 1861 1862 1863 1864 1865 1866
				{
					ExtendStmt *n = makeNode(ExtendStmt);
					n->idxname = $3;
					n->whereClause = $4;
					$$ = (Node *)n;
				}
		;
1867 1868 1869

/*****************************************************************************
 *
1870 1871
 *		QUERY:
 *				execute recipe <recipeName>
1872 1873 1874
 *
 *****************************************************************************/

Bruce Momjian's avatar
Bruce Momjian committed
1875
/* NOT USED
1876
RecipeStmt:  EXECUTE RECIPE recipe_name
1877 1878 1879
				{
					RecipeStmt *n;
					if (!IsTransactionBlock())
Bruce Momjian's avatar
Bruce Momjian committed
1880
						elog(ERROR,"EXECUTE RECIPE may only be used in begin/end transaction blocks");
1881 1882 1883 1884 1885 1886

					n = makeNode(RecipeStmt);
					n->recipeName = $3;
					$$ = (Node *)n;
				}
		;
Bruce Momjian's avatar
Bruce Momjian committed
1887
*/
1888 1889 1890

/*****************************************************************************
 *
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
 *		QUERY:
 *				define function <fname>
 *					   (language = <lang>, returntype = <typename>
 *						[, arch_pct = <percentage | pre-defined>]
 *						[, disk_pct = <percentage | pre-defined>]
 *						[, byte_pct = <percentage | pre-defined>]
 *						[, perbyte_cpu = <int | pre-defined>]
 *						[, percall_cpu = <int | pre-defined>]
 *						[, iscachable])
 *						[arg is (<type-1> { , <type-n>})]
 *						as <filename or code in language as appropriate>
1902 1903 1904
 *
 *****************************************************************************/

1905 1906
ProcedureStmt:	CREATE FUNCTION func_name func_args
			 RETURNS func_return opt_with AS Sconst LANGUAGE Sconst
1907 1908 1909 1910
				{
					ProcedureStmt *n = makeNode(ProcedureStmt);
					n->funcname = $3;
					n->defArgs = $4;
1911
					n->returnType = $6;
1912 1913 1914 1915 1916 1917 1918
					n->withClause = $7;
					n->as = $9;
					n->language = $11;
					$$ = (Node *)n;
				};

opt_with:  WITH definition						{ $$ = $2; }
1919
		| /*EMPTY*/								{ $$ = NIL; }
1920 1921
		;

1922
func_args:  '(' func_args_list ')'				{ $$ = $2; }
1923
		| '(' ')'								{ $$ = NIL; }
1924
		;
1925

1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
func_args_list:  TypeId
				{	$$ = lcons(makeString($1),NIL); }
		| func_args_list ',' TypeId
				{	$$ = lappend($1,makeString($3)); }
		;

func_return:  set_opt TypeId
				{
					TypeName *n = makeNode(TypeName);
					n->name = $2;
					n->setof = $1;
					n->arrayBounds = NULL;
					$$ = (Node *)n;
				}
		;

set_opt:  SETOF									{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
		;
1945 1946 1947

/*****************************************************************************
 *
1948
 *		QUERY:
1949
 *
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959
 *		remove function <funcname>
 *				(REMOVE FUNCTION "funcname" (arg1, arg2, ...))
 *		remove aggregate <aggname>
 *				(REMOVE AGGREGATE "aggname" "aggtype")
 *		remove operator <opname>
 *				(REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
 *		remove type <typename>
 *				(REMOVE TYPE "typename")
 *		remove rule <rulename>
 *				(REMOVE RULE "rulename")
1960 1961 1962 1963
 *
 *****************************************************************************/

RemoveStmt:  DROP remove_type name
1964 1965 1966 1967 1968 1969 1970 1971
				{
					RemoveStmt *n = makeNode(RemoveStmt);
					n->removeType = $2;
					n->name = $3;
					$$ = (Node *)n;
				}
		;

1972
remove_type:  TYPE_P							{  $$ = TYPE_P; }
1973 1974 1975
		| INDEX									{  $$ = INDEX; }
		| RULE									{  $$ = RULE; }
		| VIEW									{  $$ = VIEW; }
1976
		;
1977

1978

1979
RemoveAggrStmt:  DROP AGGREGATE name aggr_argtype
1980 1981 1982 1983 1984 1985 1986 1987 1988
				{
						RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
						n->aggname = $3;
						n->aggtype = $4;
						$$ = (Node *)n;
				}
		;

aggr_argtype:  name								{ $$ = $1; }
1989
		| '*'									{ $$ = NULL; }
1990
		;
1991

1992 1993

RemoveFuncStmt:  DROP FUNCTION func_name func_args
1994 1995 1996
				{
					RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
					n->funcname = $3;
1997
					n->args = $4;
1998 1999 2000 2001
					$$ = (Node *)n;
				}
		;

2002 2003

RemoveOperStmt:  DROP OPERATOR all_Op '(' oper_argtypes ')'
2004 2005 2006 2007 2008 2009 2010
				{
					RemoveOperStmt *n = makeNode(RemoveOperStmt);
					n->opname = $3;
					n->args = $5;
					$$ = (Node *)n;
				}
		;
2011

2012
all_Op:  Op | MathOp;
2013

2014
MathOp:	'+'				{ $$ = "+"; }
2015 2016 2017
		| '-'			{ $$ = "-"; }
		| '*'			{ $$ = "*"; }
		| '/'			{ $$ = "/"; }
2018
		| '%'			{ $$ = "%"; }
2019 2020 2021
		| '<'			{ $$ = "<"; }
		| '>'			{ $$ = ">"; }
		| '='			{ $$ = "="; }
2022 2023 2024 2025
		;

oper_argtypes:	name
				{
Bruce Momjian's avatar
Bruce Momjian committed
2026
				   elog(ERROR,"parser: argument type missing (use NONE for unary operators)");
2027 2028 2029 2030 2031 2032 2033 2034
				}
		| name ',' name
				{ $$ = makeList(makeString($1), makeString($3), -1); }
		| NONE ',' name			/* left unary */
				{ $$ = makeList(NULL, makeString($3), -1); }
		| name ',' NONE			/* right unary */
				{ $$ = makeList(makeString($1), NULL, -1); }
		;
2035

2036

2037 2038
/*****************************************************************************
 *
2039 2040 2041
 *		QUERY:
 *				rename <attrname1> in <relname> [*] to <attrname2>
 *				rename <relname1> to <relname2>
2042
 *
2043 2044
 *****************************************************************************/

2045
RenameStmt:  ALTER TABLE relation_name opt_inh_star
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
				  RENAME opt_column opt_name TO name
				{
					RenameStmt *n = makeNode(RenameStmt);
					n->relname = $3;
					n->inh = $4;
					n->column = $7;
					n->newname = $9;
					$$ = (Node *)n;
				}
		;

opt_name:  name							{ $$ = $1; }
2058
		| /*EMPTY*/						{ $$ = NULL; }
2059 2060 2061 2062 2063
		;

opt_column:  COLUMN						{ $$ = COLUMN; }
		| /*EMPTY*/						{ $$ = 0; }
		;
2064 2065 2066


/*****************************************************************************
2067
 *
2068 2069
 *		QUERY:	Define Rewrite Rule , Define Tuple Rule
 *				Define Rule <old rules >
2070
 *
2071
 *		only rewrite rule is supported -- ay 9/94
2072
 *
2073 2074
 *****************************************************************************/

2075
RuleStmt:  CREATE RULE name AS
2076 2077
		   { QueryIsRule=TRUE; }
		   ON event TO event_object where_clause
2078
		   DO opt_instead RuleActionList
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
				{
					RuleStmt *n = makeNode(RuleStmt);
					n->rulename = $3;
					n->event = $7;
					n->object = $9;
					n->whereClause = $10;
					n->instead = $12;
					n->actions = $13;
					$$ = (Node *)n;
				}
		;

2091 2092 2093 2094 2095
RuleActionList:  NOTHING				{ $$ = NIL; }
		| SelectStmt					{ $$ = lcons($1, NIL); }
		| RuleActionStmt				{ $$ = lcons($1, NIL); }
		| '[' RuleActionBlock ']'		{ $$ = $2; }
		| '(' RuleActionBlock ')'		{ $$ = $2; } 
2096
		;
2097

2098 2099
RuleActionBlock:  RuleActionMulti		{  $$ = $1; }
		| RuleActionStmt				{ $$ = lcons($1, NIL); }
2100
		;
2101

2102
RuleActionMulti:  RuleActionMulti RuleActionStmt
2103
				{  $$ = lappend($1, $2); }
2104 2105 2106
		| RuleActionMulti RuleActionStmt ';'
				{  $$ = lappend($1, $2); }
		| RuleActionStmt ';'
2107 2108
				{ $$ = lcons($1, NIL); }
		;
2109

2110 2111 2112 2113 2114 2115
RuleActionStmt:	InsertStmt
		| UpdateStmt
		| DeleteStmt
		| NotifyStmt
		;

2116
event_object:  relation_name '.' attr_name
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132
				{
					$$ = makeNode(Attr);
					$$->relname = $1;
					$$->paramNo = NULL;
					$$->attrs = lcons(makeString($3), NIL);
					$$->indirection = NIL;
				}
		| relation_name
				{
					$$ = makeNode(Attr);
					$$->relname = $1;
					$$->paramNo = NULL;
					$$->attrs = NIL;
					$$->indirection = NIL;
				}
		;
2133 2134

/* change me to select, update, etc. some day */
2135 2136 2137 2138 2139
event:	SELECT							{ $$ = CMD_SELECT; }
		| UPDATE						{ $$ = CMD_UPDATE; }
		| DELETE						{ $$ = CMD_DELETE; }
		| INSERT						{ $$ = CMD_INSERT; }
		 ;
2140

2141
opt_instead:  INSTEAD					{ $$ = TRUE; }
2142
		| /*EMPTY*/						{ $$ = FALSE; }
2143
		;
2144 2145 2146 2147


/*****************************************************************************
 *
2148 2149 2150
 *		QUERY:
 *				NOTIFY <relation_name>	can appear both in rule bodies and
 *				as a query-level command
2151 2152 2153
 *
 *****************************************************************************/

2154
NotifyStmt:  NOTIFY relation_name
2155 2156 2157 2158 2159 2160
				{
					NotifyStmt *n = makeNode(NotifyStmt);
					n->relname = $2;
					$$ = (Node *)n;
				}
		;
2161

2162
ListenStmt:  LISTEN relation_name
2163 2164 2165 2166 2167
				{
					ListenStmt *n = makeNode(ListenStmt);
					n->relname = $2;
					$$ = (Node *)n;
				}
2168 2169
;

2170 2171 2172 2173 2174 2175
UnlistenStmt:  UNLISTEN relation_name
				{
					UnlistenStmt *n = makeNode(UnlistenStmt);
					n->relname = $2;
					$$ = (Node *)n;
				}
2176 2177 2178 2179 2180 2181
		| UNLISTEN '*'
				{
					UnlistenStmt *n = makeNode(UnlistenStmt);
					n->relname = "*";
					$$ = (Node *)n;
				}
2182 2183
;

2184 2185 2186

/*****************************************************************************
 *
2187
 *		Transactions:
2188
 *
2189 2190 2191 2192 2193 2194
 *		abort transaction
 *				(ABORT)
 *		begin transaction
 *				(BEGIN)
 *		end transaction
 *				(END)
2195
 *
2196 2197
 *****************************************************************************/

2198
TransactionStmt: ABORT_TRANS opt_trans
2199 2200 2201 2202 2203
				{
					TransactionStmt *n = makeNode(TransactionStmt);
					n->command = ABORT_TRANS;
					$$ = (Node *)n;
				}
2204
		| BEGIN_TRANS opt_trans
2205 2206 2207 2208 2209
				{
					TransactionStmt *n = makeNode(TransactionStmt);
					n->command = BEGIN_TRANS;
					$$ = (Node *)n;
				}
2210
		| COMMIT opt_trans
2211 2212 2213 2214 2215
				{
					TransactionStmt *n = makeNode(TransactionStmt);
					n->command = END_TRANS;
					$$ = (Node *)n;
				}
2216
		| END_TRANS opt_trans
2217 2218 2219 2220 2221
				{
					TransactionStmt *n = makeNode(TransactionStmt);
					n->command = END_TRANS;
					$$ = (Node *)n;
				}
2222
		| ROLLBACK opt_trans
2223 2224 2225 2226 2227
				{
					TransactionStmt *n = makeNode(TransactionStmt);
					n->command = ABORT_TRANS;
					$$ = (Node *)n;
				}
2228
		;
2229

2230 2231 2232
opt_trans: WORK									{ $$ = TRUE; }
		| TRANSACTION							{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = TRUE; }
2233
		;
2234 2235 2236 2237


/*****************************************************************************
 *
2238 2239
 *		QUERY:
 *				define view <viewname> '('target-list ')' [where <quals> ]
2240 2241 2242
 *
 *****************************************************************************/

Bruce Momjian's avatar
Bruce Momjian committed
2243
ViewStmt:  CREATE VIEW name AS SelectStmt
2244 2245 2246 2247
				{
					ViewStmt *n = makeNode(ViewStmt);
					n->viewname = $3;
					n->query = (Query *)$5;
Bruce Momjian's avatar
Bruce Momjian committed
2248 2249
					if (((SelectStmt *)n->query)->sortClause != NULL)
						elog(ERROR,"Order by and Distinct on views is not implemented.");
Bruce Momjian's avatar
Bruce Momjian committed
2250
					if (((SelectStmt *)n->query)->unionClause != NULL)
Bruce Momjian's avatar
Bruce Momjian committed
2251
						elog(ERROR,"Views on unions not implemented.");
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
2252 2253
					if (((SelectStmt *)n->query)->forUpdate != NULL)
						elog(ERROR, "SELECT FOR UPDATE is not allowed in CREATE VIEW");
2254 2255 2256
					$$ = (Node *)n;
				}
		;
2257 2258 2259 2260


/*****************************************************************************
 *
2261 2262
 *		QUERY:
 *				load "filename"
2263 2264 2265
 *
 *****************************************************************************/

2266
LoadStmt:  LOAD file_name
2267 2268 2269 2270 2271 2272
				{
					LoadStmt *n = makeNode(LoadStmt);
					n->filename = $2;
					$$ = (Node *)n;
				}
		;
2273 2274 2275 2276


/*****************************************************************************
 *
2277 2278
 *		QUERY:
 *				createdb dbname
2279 2280 2281
 *
 *****************************************************************************/

2282
CreatedbStmt:  CREATE DATABASE database_name WITH opt_database1 opt_database2
2283 2284
				{
					CreatedbStmt *n = makeNode(CreatedbStmt);
2285 2286 2287
					if ($5 == NULL && $6 == NULL) {
						elog(ERROR, "CREATE DATABASE WITH requires at least an option");
					}
2288
					n->dbname = $3;
2289
					n->dbpath = $5;
Marc G. Fournier's avatar
Marc G. Fournier committed
2290
#ifdef MULTIBYTE
2291 2292 2293 2294 2295 2296 2297 2298 2299
					if ($6 != NULL) {
						n->encoding = pg_char_to_encoding($6);
						if (n->encoding < 0) {
							elog(ERROR, "invalid encoding name %s", $6);
						}
					} else {
						n->encoding = GetTemplateEncoding();
					}
#else
2300 2301
					if ($6 != NULL)
						elog(ERROR, "WITH ENCODING is not supported");
2302
					n->encoding = 0;
2303
#endif
2304 2305
					$$ = (Node *)n;
				}
2306 2307 2308 2309 2310
		| CREATE DATABASE database_name
				{
					CreatedbStmt *n = makeNode(CreatedbStmt);
					n->dbname = $3;
					n->dbpath = NULL;
Marc G. Fournier's avatar
Marc G. Fournier committed
2311
#ifdef MULTIBYTE
2312
					n->encoding = GetTemplateEncoding();
2313 2314
#else
					n->encoding = 0;
2315 2316 2317 2318 2319 2320 2321
#endif
					$$ = (Node *)n;
				}
		;

opt_database1:  LOCATION '=' location			{ $$ = $3; }
		| /*EMPTY*/								{ $$ = NULL; }
2322
		;
2323

2324
opt_database2:  ENCODING '=' encoding			{ $$ = $3; }
2325 2326 2327 2328 2329 2330 2331
		| /*EMPTY*/								{ $$ = NULL; }
		;

location:  Sconst								{ $$ = $1; }
		| DEFAULT								{ $$ = NULL; }
		| /*EMPTY*/								{ $$ = NULL; }
		;
2332

2333 2334 2335 2336 2337
encoding:  Sconst								{ $$ = $1; }
		| DEFAULT								{ $$ = NULL; }
		| /*EMPTY*/								{ $$ = NULL; }
		;

2338 2339
/*****************************************************************************
 *
2340 2341
 *		QUERY:
 *				destroydb dbname
2342 2343 2344
 *
 *****************************************************************************/

2345 2346 2347 2348 2349 2350 2351
DestroydbStmt:	DROP DATABASE database_name
				{
					DestroydbStmt *n = makeNode(DestroydbStmt);
					n->dbname = $3;
					$$ = (Node *)n;
				}
		;
2352 2353 2354 2355


/*****************************************************************************
 *
2356 2357
 *		QUERY:
 *				cluster <index_name> on <relation_name>
2358 2359 2360
 *
 *****************************************************************************/

2361
ClusterStmt:  CLUSTER index_name ON relation_name
2362 2363 2364 2365 2366 2367 2368
				{
				   ClusterStmt *n = makeNode(ClusterStmt);
				   n->relname = $4;
				   n->indexname = $2;
				   $$ = (Node*)n;
				}
		;
2369

2370

2371 2372
/*****************************************************************************
 *
2373 2374
 *		QUERY:
 *				vacuum
2375 2376 2377
 *
 *****************************************************************************/

Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
2378
VacuumStmt:  VACUUM opt_verbose opt_analyze
2379 2380 2381 2382 2383 2384 2385 2386
				{
					VacuumStmt *n = makeNode(VacuumStmt);
					n->verbose = $2;
					n->analyze = $3;
					n->vacrel = NULL;
					n->va_spec = NIL;
					$$ = (Node *)n;
				}
2387
		| VACUUM opt_verbose opt_analyze relation_name opt_va_list
2388 2389 2390
				{
					VacuumStmt *n = makeNode(VacuumStmt);
					n->verbose = $2;
2391 2392
					n->analyze = $3;
					n->vacrel = $4;
2393 2394
					n->va_spec = $5;
					if ( $5 != NIL && !$4 )
Bruce Momjian's avatar
Bruce Momjian committed
2395
						elog(ERROR,"parser: syntax error at or near \"(\"");
2396 2397 2398 2399
					$$ = (Node *)n;
				}
		;

2400
opt_verbose:  VERBOSE							{ $$ = TRUE; }
2401
		| /*EMPTY*/								{ $$ = FALSE; }
2402 2403
		;

2404
opt_analyze:  ANALYZE							{ $$ = TRUE; }
2405
		| /*EMPTY*/								{ $$ = FALSE; }
2406
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
2407

2408 2409
opt_va_list:  '(' va_list ')'					{ $$ = $2; }
		| /*EMPTY*/								{ $$ = NIL; }
2410
		;
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
2411

2412
va_list:  name
2413 2414 2415 2416
				{ $$=lcons($1,NIL); }
		| va_list ',' name
				{ $$=lappend($1,$3); }
		;
2417

2418

2419 2420
/*****************************************************************************
 *
2421 2422
 *		QUERY:
 *				EXPLAIN query
2423 2424 2425
 *
 *****************************************************************************/

2426
ExplainStmt:  EXPLAIN opt_verbose OptimizableStmt
2427 2428 2429 2430 2431 2432 2433
				{
					ExplainStmt *n = makeNode(ExplainStmt);
					n->verbose = $2;
					n->query = (Query*)$3;
					$$ = (Node *)n;
				}
		;
2434

2435

2436
/*****************************************************************************
2437 2438 2439 2440 2441 2442 2443 2444
 *																			 *
 *		Optimizable Stmts:													 *
 *																			 *
 *		one of the five queries processed by the planner					 *
 *																			 *
 *		[ultimately] produces query-trees as specified						 *
 *		in the query-spec document in ~postgres/ref							 *
 *																			 *
2445 2446
 *****************************************************************************/

Bruce Momjian's avatar
Bruce Momjian committed
2447
OptimizableStmt:  SelectStmt
2448
		| CursorStmt
Bruce Momjian's avatar
Bruce Momjian committed
2449 2450
		| UpdateStmt
		| InsertStmt
2451 2452 2453
		| NotifyStmt
		| DeleteStmt					/* by default all are $$=$1 */
		;
2454 2455 2456 2457


/*****************************************************************************
 *
2458 2459
 *		QUERY:
 *				INSERT STATEMENTS
2460
 *
2461 2462
 *****************************************************************************/

Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2463 2464 2465 2466 2467 2468 2469
/***S*I***/
/* This rule used 'opt_column_list' between 'relation_name' and 'insert_rest'
 * originally. When the second rule of 'insert_rest' was changed to use
 * the new 'SelectStmt' rule (for INTERSECT and EXCEPT) it produced a shift/reduce
 * conflict. So I just changed the rules 'InsertStmt' and 'insert_rest' to accept
 * the same statements without any shift/reduce conflicts */
InsertStmt:  INSERT INTO relation_name  insert_rest
2470
				{
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2471 2472
 					$4->relname = $3;
					$$ = (Node *)$4;
2473 2474
				}
		;
2475

2476
insert_rest:  VALUES '(' res_target_list2 ')'
2477
				{
Bruce Momjian's avatar
Bruce Momjian committed
2478
					$$ = makeNode(InsertStmt);
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2479
					$$->cols = NULL;
2480
					$$->unique = NULL;
2481 2482
					$$->targetList = $3;
					$$->fromClause = NIL;
2483
					$$->whereClause = NULL;
2484
					$$->groupClause = NIL;
2485
					$$->havingClause = NULL;
2486
					$$->unionClause = NIL;
2487
				}
2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
		| DEFAULT VALUES
				{
					$$ = makeNode(InsertStmt);
					$$->unique = NULL;
					$$->targetList = NIL;
					$$->fromClause = NIL;
					$$->whereClause = NULL;
					$$->groupClause = NIL;
					$$->havingClause = NULL;
					$$->unionClause = NIL;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2498 2499
					/***S*I***/
				 	$$->intersectClause = NIL;
2500
				}
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2501 2502 2503 2504
		/***S*I***/
		/* We want the full power of SelectStatements including INTERSECT and EXCEPT
                 * for insertion */
		| SelectStmt
2505
				{
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2506 2507 2508
					SelectStmt *n;

					n = (SelectStmt *)$1;
Bruce Momjian's avatar
Bruce Momjian committed
2509
					$$ = makeNode(InsertStmt);
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2510 2511 2512 2513 2514 2515 2516 2517 2518
					$$->cols = NULL;
					$$->unique = n->unique;
					$$->targetList = n->targetList;
					$$->fromClause = n->fromClause;
					$$->whereClause = n->whereClause;
					$$->groupClause = n->groupClause;
					$$->havingClause = n->havingClause;
					$$->unionClause = n->unionClause;
					$$->intersectClause = n->intersectClause;
2519
					$$->forUpdate = n->forUpdate;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
				}
		| '(' columnList ')' VALUES '(' res_target_list2 ')'
				{
					$$ = makeNode(InsertStmt);
					$$->cols = $2;
					$$->unique = NULL;
					$$->targetList = $6;
					$$->fromClause = NIL;
					$$->whereClause = NULL;
					$$->groupClause = NIL;
					$$->havingClause = NULL;
					$$->unionClause = NIL; 
					/***S*I***/
				 	$$->intersectClause = NIL;
				}
		| '(' columnList ')' SelectStmt
				{
					SelectStmt *n;

					n = (SelectStmt *)$4;
					$$ = makeNode(InsertStmt);
					$$->cols = $2;
					$$->unique = n->unique;
					$$->targetList = n->targetList;
					$$->fromClause = n->fromClause;
					$$->whereClause = n->whereClause;
					$$->groupClause = n->groupClause;
					$$->havingClause = n->havingClause;
					$$->unionClause = n->unionClause;
					$$->intersectClause = n->intersectClause;
2550 2551 2552
				}
		;

2553
opt_column_list:  '(' columnList ')'			{ $$ = $2; }
2554 2555
		| /*EMPTY*/								{ $$ = NIL; }
		;
2556

2557
columnList:
2558 2559 2560 2561 2562
		  columnList ',' columnElem
				{ $$ = lappend($1, $3); }
		| columnElem
				{ $$ = lcons($1, NIL); }
		;
2563

2564
columnElem:  ColId opt_indirection
2565 2566 2567 2568 2569 2570 2571
				{
					Ident *id = makeNode(Ident);
					id->name = $1;
					id->indirection = $2;
					$$ = (Node *)id;
				}
		;
2572

2573

2574 2575
/*****************************************************************************
 *
2576 2577
 *		QUERY:
 *				DELETE STATEMENTS
2578 2579
 *
 *****************************************************************************/
2580

2581
DeleteStmt:  DELETE FROM relation_name
2582 2583 2584 2585 2586 2587 2588 2589
			 where_clause
				{
					DeleteStmt *n = makeNode(DeleteStmt);
					n->relname = $3;
					n->whereClause = $4;
					$$ = (Node *)n;
				}
		;
2590

Bruce Momjian's avatar
Bruce Momjian committed
2591
LockStmt:	LOCK_P opt_table relation_name opt_lock
2592
				{
2593 2594 2595
					LockStmt *n = makeNode(LockStmt);

					n->relname = $3;
Bruce Momjian's avatar
Bruce Momjian committed
2596
					n->mode = $4;
2597 2598
					$$ = (Node *)n;
				}
2599
		;
2600

Bruce Momjian's avatar
Bruce Momjian committed
2601
opt_lock:  IN lock_type MODE		{ $$ = $2; }
2602 2603
		| /*EMPTY*/				{ $$ = AccessExclusiveLock; }
		;
2604

2605 2606 2607 2608
lock_type:  SHARE ROW EXCLUSIVE	{ $$ = ShareRowExclusiveLock; }
		| ROW opt_lmode			{ $$ = ($2? RowShareLock: RowExclusiveLock); }
		| ACCESS opt_lmode		{ $$ = ($2? AccessShareLock: AccessExclusiveLock); }
		| opt_lmode				{ $$ = ($1? ShareLock: ExclusiveLock); }
2609 2610
		;

2611 2612
opt_lmode:	SHARE				{ $$ = TRUE; }
		| EXCLUSIVE				{ $$ = FALSE; }
2613
		;
2614

2615

2616 2617
/*****************************************************************************
 *
2618
 *		QUERY:
Bruce Momjian's avatar
Bruce Momjian committed
2619
 *				UpdateStmt (UPDATE)
2620 2621 2622
 *
 *****************************************************************************/

Bruce Momjian's avatar
Bruce Momjian committed
2623
UpdateStmt:  UPDATE relation_name
2624 2625 2626 2627
			  SET res_target_list
			  from_clause
			  where_clause
				{
Bruce Momjian's avatar
Bruce Momjian committed
2628
					UpdateStmt *n = makeNode(UpdateStmt);
2629 2630 2631 2632 2633 2634 2635
					n->relname = $2;
					n->targetList = $4;
					n->fromClause = $5;
					n->whereClause = $6;
					$$ = (Node *)n;
				}
		;
2636

2637 2638 2639

/*****************************************************************************
 *
2640 2641
 *		QUERY:
 *				CURSOR STATEMENTS
2642 2643
 *
 *****************************************************************************/
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2644
/***S*I***/
Jan Wieck's avatar
Jan Wieck committed
2645
CursorStmt:  DECLARE name opt_cursor CURSOR FOR SelectStmt
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2646 2647 2648 2649 2650 2651 2652
  				{
 					SelectStmt *n;
  
 					n= (SelectStmt *)$6;
  					/* from PORTAL name */
  					/*
  					 *	15 august 1991 -- since 3.0 postgres does locking
2653 2654 2655 2656 2657 2658
					 *	right, we discovered that portals were violating
					 *	locking protocol.  portal locks cannot span xacts.
					 *	as a short-term fix, we installed the check here.
					 *							-- mao
					 */
					if (!IsTransactionBlock())
Bruce Momjian's avatar
Bruce Momjian committed
2659
						elog(ERROR,"Named portals may only be used in begin/end transaction blocks");
2660 2661 2662

					n->portalname = $2;
					n->binary = $3;
Jan Wieck's avatar
Jan Wieck committed
2663 2664 2665
					if (n->forUpdate != NULL)
							elog(ERROR,"DECLARE/UPDATE not supported;"
								 		" Cursors must be READ ONLY.");
2666 2667 2668
					$$ = (Node *)n;
				}
		;
2669

2670 2671 2672 2673 2674 2675 2676
opt_cursor:  BINARY						{ $$ = TRUE; }
		| INSENSITIVE					{ $$ = FALSE; }
		| SCROLL						{ $$ = FALSE; }
		| INSENSITIVE SCROLL			{ $$ = FALSE; }
		| /*EMPTY*/						{ $$ = FALSE; }
		;

2677 2678
/*****************************************************************************
 *
2679 2680
 *		QUERY:
 *				SELECT STATEMENTS
2681 2682
 *
 *****************************************************************************/
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2683 2684 2685 2686 2687
/***S*I***/
/* The new 'SelectStmt' rule adapted for the optional use of INTERSECT EXCEPT and UNION
 * accepts the use of '(' and ')' to select an order of set operations.
 * 
 * The rule returns a SelectStmt Node having the set operations attached to 
2688 2689 2690 2691
 * unionClause and intersectClause (NIL if no set operations were present)
 */

SelectStmt:	  select_clause sort_clause for_update_clause opt_select_limit
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2692 2693 2694 2695 2696 2697 2698
			{
				/* There were no set operations, so just attach the sortClause */
				if IsA($1, SelectStmt)
				{
				  SelectStmt *n = (SelectStmt *)$1;
  				  n->sortClause = $2;
				  n->forUpdate = $3;
2699 2700
				  n->limitOffset = nth(0, $4);
				  n->limitCount = nth(1, $4);
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759
				  $$ = (Node *)n;
                }
				/* There were set operations: The root of the operator tree
				 * is delivered by $1 but we cannot hand back an A_Expr Node.
				 * So we search for the leftmost 'SelectStmt' in the operator
				 * tree $1 (which is the first Select Statement in the query 
				 * typed in by the user or where ever it came from). 
				 * 
				 * Then we attach the whole operator tree to 'intersectClause', 
				 * and a list of all 'SelectStmt' Nodes to 'unionClause' and 
				 * hand back the leftmost 'SelectStmt' Node. (We do it this way
				 * because the following functions (e.g. parse_analyze etc.)
				 * excpect a SelectStmt node and not an operator tree! The whole
				 * tree attached to 'intersectClause' won't be touched by 
				 * parse_analyze() etc. until the function 
				 * Except_Intersect_Rewrite() (in rewriteHandler.c) which performs
				 * the necessary steps to be able create a plan!) */
				else
				{
				  List *select_list = NIL;
				  SelectStmt *first_select;
				  Node *op = (Node *) $1;
				  bool intersect_present = FALSE, unionall_present = FALSE;

				  /* Take the operator tree as an argument and 
				   * create a list of all SelectStmt Nodes found in the tree.
				   *
				   * If one of the SelectStmt Nodes has the 'unionall' flag
				   * set to true the 'unionall_present' flag is also set to
				   * true */
				  create_select_list((Node *)op, &select_list, &unionall_present);

				  /* Replace all the A_Expr Nodes in the operator tree by
				   * Expr Nodes.
				   *
				   * If an INTERSECT or an EXCEPT is present, the 
				   * 'intersect_present' flag is set to true */
				  op = A_Expr_to_Expr(op, &intersect_present);

				  /* If both flags are set to true we have a UNION ALL
				   * statement mixed up with INTERSECT or EXCEPT 
				   * which can not be handled at the moment */
				  if (intersect_present && unionall_present)
				  {
				  	elog(ERROR,"UNION ALL not allowed in mixed set operations!");
				  }

				  /* Get the leftmost SeletStmt Node (which automatically
				   * represents the first Select Statement of the query!) */
				  first_select = (SelectStmt *)lfirst(select_list);

				  /* Attach the list of all SeletStmt Nodes to unionClause */
				  first_select->unionClause = select_list;

				  /* Attach the whole operator tree to intersectClause */
				  first_select->intersectClause = (List *) op;

				  /* finally attach the sort clause */
				  first_select->sortClause = $2;
Bruce Momjian's avatar
Bruce Momjian committed
2760
				  first_select->forUpdate = $3;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2761 2762
				  $$ = (Node *)first_select;
				}		
2763 2764
				if (((SelectStmt *)$$)->forUpdate != NULL && QueryIsRule)
					elog(ERROR, "SELECT FOR UPDATE is not allowed in RULES");
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781
			}
		;

/***S*I***/ 
/* This rule parses Select statements including UNION INTERSECT and EXCEPT.
 * '(' and ')' can be used to specify the order of the operations 
 * (UNION EXCEPT INTERSECT). Without the use of '(' and ')' we want the
 * operations to be left associative.
 *
 *  The sort_clause is not handled here!
 * 
 * The rule builds up an operator tree using A_Expr Nodes. AND Nodes represent
 * INTERSECTs OR Nodes represent UNIONs and AND NOT nodes represent EXCEPTs. 
 * The SelectStatements to be connected are the left and right arguments to
 * the A_Expr Nodes.
 * If no set operations show up in the query the tree consists only of one
 * SelectStmt Node */
2782
select_clause: '(' select_clause ')'
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2783 2784 2785 2786 2787 2788 2789
			{
				$$ = $2; 
			}
		| SubSelect
			{
				$$ = $1; 
			}
2790
		| select_clause EXCEPT select_clause
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2791 2792 2793 2794
			{
				$$ = (Node *)makeA_Expr(AND,NULL,$1,
							makeA_Expr(NOT,NULL,NULL,$3));
			}
2795
		| select_clause UNION opt_union select_clause
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2796 2797 2798 2799 2800 2801 2802 2803
			{	
				if (IsA($4, SelectStmt))
				  {
				     SelectStmt *n = (SelectStmt *)$4;
				     n->unionall = $3;
				  }
				$$ = (Node *)makeA_Expr(OR,NULL,$1,$4);
			}
2804
		| select_clause INTERSECT select_clause
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2805 2806 2807 2808
			{
				$$ = (Node *)makeA_Expr(AND,NULL,$1,$3);
			}
		; 
2809

Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2810 2811
/***S*I***/
SubSelect:	SELECT opt_unique res_target_list2
2812 2813
			 result from_clause where_clause
			 group_clause having_clause
2814
				{
Bruce Momjian's avatar
Bruce Momjian committed
2815
					SelectStmt *n = makeNode(SelectStmt);
2816
					n->unique = $2;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2817
					n->unionall = FALSE;
2818
					n->targetList = $3;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2819 2820 2821 2822 2823 2824 2825 2826
					/***S*I***/
					/* This is new: Subselects support the INTO clause
					 * which allows queries that are not part of the
					 * SQL92 standard and should not be formulated!
					 * We need it for INTERSECT and EXCEPT and I did not
					 * want to create a new rule 'SubSelect1' including the
					 * feature. If it makes troubles we will have to add 
					 * a new rule and change this to prevent INTOs in 
2827
					 * Subselects again */
2828 2829
					n->istemp = (bool) ((Value *) lfirst($4))->val.ival;
					n->into = (char *) lnext($4);
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2830

2831 2832 2833 2834 2835 2836 2837
					n->fromClause = $5;
					n->whereClause = $6;
					n->groupClause = $7;
					n->havingClause = $8;
					$$ = (Node *)n;
				}
		;
2838

2839 2840 2841
		/* easy way to return two values. Can someone improve this?  bjm */
result:  INTO OptTemp opt_table relation_name	{ $$ = lcons(makeInteger($2), (List *)$4); }
		| /*EMPTY*/								{ $$ = lcons(makeInteger(false), NIL); }
2842 2843 2844 2845
		;

opt_table:  TABLE								{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
2846
		;
2847

2848 2849 2850 2851
opt_union:  ALL									{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
		;

2852 2853
opt_unique:  DISTINCT							{ $$ = "*"; }
		| DISTINCT ON ColId						{ $$ = $3; }
2854 2855
		| ALL									{ $$ = NULL; }
		| /*EMPTY*/								{ $$ = NULL; }
2856
		;
2857

2858
sort_clause:  ORDER BY sortby_list				{ $$ = $3; }
2859
		| /*EMPTY*/								{ $$ = NIL; }
2860
		;
2861

2862 2863
sortby_list:  sortby							{ $$ = lcons($1, NIL); }
		| sortby_list ',' sortby				{ $$ = lappend($1, $3); }
2864
		;
2865

2866
sortby: a_expr OptUseOp
2867 2868
				{
					$$ = makeNode(SortGroupBy);
2869
					$$->node = $1;
2870 2871 2872 2873 2874
					$$->useOp = $2;
				}
		;

OptUseOp:  USING Op								{ $$ = $2; }
2875 2876 2877 2878 2879
		| USING '<'								{ $$ = "<"; }
		| USING '>'								{ $$ = ">"; }
		| ASC									{ $$ = "<"; }
		| DESC									{ $$ = ">"; }
		| /*EMPTY*/								{ $$ = "<"; /*default*/ }
2880
		;
2881

2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959

opt_select_limit:	LIMIT select_limit_value ',' select_offset_value
			{ $$ = lappend(lappend(NIL, $4), $2); }
		| LIMIT select_limit_value OFFSET select_offset_value
			{ $$ = lappend(lappend(NIL, $4), $2); }
		| LIMIT select_limit_value
			{ $$ = lappend(lappend(NIL, NULL), $2); }
		| OFFSET select_offset_value LIMIT select_limit_value
			{ $$ = lappend(lappend(NIL, $2), $4); }
		| OFFSET select_offset_value
			{ $$ = lappend(lappend(NIL, $2), NULL); }
		| /* EMPTY */
			{ $$ = lappend(lappend(NIL, NULL), NULL); }
		;

select_limit_value:		Iconst
			{
				Const	*n = makeNode(Const);

				if ($1 < 1)
					elog(ERROR, "selection limit must be ALL or a positive integer value > 0");

				n->consttype	= INT4OID;
				n->constlen		= sizeof(int4);
				n->constvalue	= (Datum)$1;
				n->constisnull	= FALSE;
				n->constbyval	= TRUE;
				n->constisset	= FALSE;
				n->constiscast	= FALSE;
				$$ = (Node *)n;
			}
		| ALL
			{
				Const	*n = makeNode(Const);

				n->consttype	= INT4OID;
				n->constlen		= sizeof(int4);
				n->constvalue	= (Datum)0;
				n->constisnull	= FALSE;
				n->constbyval	= TRUE;
				n->constisset	= FALSE;
				n->constiscast	= FALSE;
				$$ = (Node *)n;
			}
		| PARAM
			{
				Param	*n = makeNode(Param);

				n->paramkind	= PARAM_NUM;
				n->paramid		= $1;
				n->paramtype	= INT4OID;
				$$ = (Node *)n;
			}
		;

select_offset_value:	Iconst
			{
				Const	*n = makeNode(Const);

				n->consttype	= INT4OID;
				n->constlen		= sizeof(int4);
				n->constvalue	= (Datum)$1;
				n->constisnull	= FALSE;
				n->constbyval	= TRUE;
				n->constisset	= FALSE;
				n->constiscast	= FALSE;
				$$ = (Node *)n;
			}
		| PARAM
			{
				Param	*n = makeNode(Param);

				n->paramkind	= PARAM_NUM;
				n->paramid		= $1;
				n->paramtype	= INT4OID;
				$$ = (Node *)n;
			}
		;
2960
/*
2961 2962
 *	jimmy bell-style recursive queries aren't supported in the
 *	current system.
2963
 *
2964 2965
 *	...however, recursive addattr and rename supported.  make special
 *	cases for these.
2966
 */
2967 2968
opt_inh_star:  '*'								{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
2969
		;
2970

2971
relation_name_list:  name_list;
2972

2973
name_list:  name
2974
				{	$$ = lcons(makeString($1),NIL); }
2975
		| name_list ',' name
2976
				{	$$ = lappend($1,makeString($3)); }
2977
		;
2978

2979
group_clause:  GROUP BY expr_list				{ $$ = $3; }
2980 2981
		| /*EMPTY*/								{ $$ = NIL; }
		;
2982

Bruce Momjian's avatar
Bruce Momjian committed
2983 2984
having_clause:  HAVING a_expr
				{
2985
					$$ = $2;
Bruce Momjian's avatar
Bruce Momjian committed
2986
				}
2987 2988
		| /*EMPTY*/								{ $$ = NULL; }
		;
2989

2990
for_update_clause:  FOR UPDATE update_list		{ $$ = $3; }
Jan Wieck's avatar
Jan Wieck committed
2991
		| FOR READ ONLY							{ $$ = NULL; }
2992 2993 2994 2995 2996
		| /* EMPTY */							{ $$ = NULL; }
		;

update_list:  OF va_list						{ $$ = $2; }
		| /* EMPTY */							{ $$ = lcons(NULL, NULL); }
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
2997
		;
2998

2999
/*****************************************************************************
3000
 *
3001 3002 3003
 *	clauses common to all Optimizable Stmts:
 *		from_clause		-
 *		where_clause	-
3004
 *
3005 3006
 *****************************************************************************/

3007
from_clause:  FROM from_expr					{ $$ = $2; }
3008 3009 3010
		| /*EMPTY*/								{ $$ = NIL; }
		;

3011 3012 3013 3014 3015 3016 3017 3018 3019
from_expr:  '(' join_clause_with_union ')'
				{ $$ = $2; }
		| join_clause
				{ $$ = $1; }
		| table_list
				{ $$ = $1; }
		;

table_list:  table_list ',' table_expr
3020
				{ $$ = lappend($1, $3); }
3021
		| table_expr
3022 3023
				{ $$ = lcons($1, NIL); }
		;
3024

3025
table_expr:  relation_expr AS ColLabel
3026 3027 3028 3029 3030
				{
					$$ = makeNode(RangeVar);
					$$->relExpr = $1;
					$$->name = $3;
				}
3031
		| relation_expr ColId
3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043
				{
					$$ = makeNode(RangeVar);
					$$->relExpr = $1;
					$$->name = $2;
				}
		| relation_expr
				{
					$$ = makeNode(RangeVar);
					$$->relExpr = $1;
					$$->name = NULL;
				}
		;
3044

3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116
/* A UNION JOIN is the same as a FULL OUTER JOIN which *omits*
 * all result rows which would have matched on an INNER JOIN.
 * Let's reject this for now. - thomas 1999-01-08
 */
join_clause_with_union:  join_clause
				{	$$ = $1; }
		| table_expr UNION JOIN table_expr
				{	elog(ERROR,"UNION JOIN not yet implemented"); }
		;

join_clause:  table_expr join_list
				{
					Node *n = lfirst($2);

					/* JoinExpr came back? then it is a join of some sort...
					 */
					if (IsA(n, JoinExpr))
					{
						JoinExpr *j = (JoinExpr *)n;
						j->larg = $1;
						$$ = $2;
					}
					/* otherwise, it was a cross join,
					 * which we just represent as an inner join...
					 */
					else
						$$ = lcons($1, $2);
				}
		;

join_list:  join_list join_expr
				{
					$$ = lappend($1, $2);
				}
		| join_expr
				{
					$$ = lcons($1, NIL);
				}
		;

/* This is everything but the left side of a join.
 * Note that a CROSS JOIN is the same as an unqualified
 * inner join, so just pass back the right-side table.
 * A NATURAL JOIN implicitly matches column names between
 * tables, so we'll collect those during the later transformation.
 */
join_expr:  join_type JOIN table_expr join_qual
				{
					JoinExpr *n = makeNode(JoinExpr);
					n->jointype = $1;
					n->rarg = (Node *)$3;
					n->quals = $4;
					$$ = (Node *)n;
				}
		| NATURAL join_type JOIN table_expr
				{
					JoinExpr *n = makeNode(JoinExpr);
					n->jointype = $2;
					n->rarg = (Node *)$4;
					n->quals = NULL; /* figure out which columns later... */
					$$ = (Node *)n;
				}
		| CROSS JOIN table_expr
				{ $$ = (Node *)$3; }
		;

/* OUTER is just noise... */
join_type:  FULL join_outer
				{
					$$ = FULL;
					elog(NOTICE,"FULL OUTER JOIN not yet implemented");
				}
3117
		| LEFT join_outer
3118 3119 3120 3121
				{
					$$ = LEFT;
					elog(NOTICE,"LEFT OUTER JOIN not yet implemented");
				}
3122
		| RIGHT join_outer
3123 3124 3125 3126
				{
					$$ = RIGHT;
					elog(NOTICE,"RIGHT OUTER JOIN not yet implemented");
				}
3127
		| OUTER_P
3128 3129 3130 3131
				{
					$$ = LEFT;
					elog(NOTICE,"OUTER JOIN not yet implemented");
				}
3132
		| INNER_P
3133 3134 3135
				{
					$$ = INNER_P;
				}
3136
		| /*EMPTY*/
3137 3138 3139
				{
					$$ = INNER_P;
				}
3140 3141
		;

3142 3143
join_outer:  OUTER_P							{ $$ = NULL; }
		| /*EMPTY*/								{ $$ = NULL;  /* no qualifiers */ }
3144 3145
		;

3146 3147 3148 3149 3150 3151 3152 3153 3154 3155
/* JOIN qualification clauses
 * Possibilities are:
 *  USING ( column list ) allows only unqualified column names,
 *                        which must match between tables.
 *  ON expr allows more general qualifications.
 * - thomas 1999-01-07
 */

join_qual:  USING '(' using_list ')'			{ $$ = $3; }
		| ON a_expr								{ $$ = lcons($2, NIL); }
3156 3157
		;

3158 3159
using_list:  using_list ',' using_expr			{ $$ = lappend($1, $3); }
		| using_expr							{ $$ = lcons($1, NIL); }
3160
		;
3161

3162
using_expr:  ColId
3163
				{
3164 3165 3166 3167 3168
					/* could be a column name or a relation_name */
					Ident *n = makeNode(Ident);
					n->name = $1;
					n->indirection = NULL;
					$$ = (Node *)n;
3169 3170 3171
				}
		;

3172 3173
where_clause:  WHERE a_expr						{ $$ = $2; }
		| /*EMPTY*/								{ $$ = NULL;  /* no qualifiers */ }
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184
		;

relation_expr:	relation_name
				{
					/* normal relations */
					$$ = makeNode(RelExpr);
					$$->relname = $1;
					$$->inh = FALSE;
				}
		| relation_name '*'				  %prec '='
				{
3185
					/* inheritance query */
3186 3187 3188 3189
					$$ = makeNode(RelExpr);
					$$->relname = $1;
					$$->inh = TRUE;
				}
3190 3191

opt_array_bounds:  '[' ']' nest_array_bounds
3192 3193 3194
				{  $$ = lcons(makeInteger(-1), $3); }
		| '[' Iconst ']' nest_array_bounds
				{  $$ = lcons(makeInteger($2), $4); }
3195
		| /*EMPTY*/
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
				{  $$ = NIL; }
		;

nest_array_bounds:	'[' ']' nest_array_bounds
				{  $$ = lcons(makeInteger(-1), $3); }
		| '[' Iconst ']' nest_array_bounds
				{  $$ = lcons(makeInteger($2), $4); }
		| /*EMPTY*/
				{  $$ = NIL; }
		;
3206

3207

3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
/*****************************************************************************
 *
 *	Type syntax
 *		SQL92 introduces a large amount of type-specific syntax.
 *		Define individual clauses to handle these cases, and use
 *		 the generic case to handle regular type-extensible Postgres syntax.
 *		- thomas 1997-10-10
 *
 *****************************************************************************/

Typename:  Array opt_array_bounds
				{
					$$ = $1;
					$$->arrayBounds = $2;
3222 3223 3224 3225

					/* Is this the name of a complex type? If so, implement
					 * it as a set.
					 */
3226
					if (!strcmp(saved_relname, $$->name))
3227 3228 3229 3230 3231
						/* This attr is the same type as the relation
						 * being defined. The classic example: create
						 * emp(name=text,mgr=emp)
						 */
						$$->setof = TRUE;
3232
					else if (typeTypeRelid(typenameType($$->name)) != InvalidOid)
3233 3234 3235 3236 3237 3238 3239
						 /* (Eventually add in here that the set can only
						  * contain one element.)
						  */
						$$->setof = TRUE;
					else
						$$->setof = FALSE;
				}
3240
		| SETOF Array
3241
				{
3242
					$$ = $2;
3243 3244 3245 3246
					$$->setof = TRUE;
				}
		;

3247 3248 3249
Array:  Generic
		| Datetime
		| Numeric
3250
		| Character
3251
		;
3252

3253
Generic:  generic
3254
				{
3255 3256
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType($1);
3257
					$$->typmod = -1;
3258 3259 3260
				}
		;

3261
generic:  IDENT									{ $$ = $1; }
3262 3263 3264 3265 3266
		| TYPE_P								{ $$ = xlateSqlType("type"); }
		;

/* SQL92 numeric data types
 * Check FLOAT() precision limits assuming IEEE floating types.
3267
 * Provide real DECIMAL() and NUMERIC() implementations now - Jan 1998-12-30
3268 3269 3270 3271 3272 3273
 * - thomas 1997-09-18
 */
Numeric:  FLOAT opt_float
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType($2);
3274
					$$->typmod = -1;
3275
				}
3276 3277 3278 3279 3280
		| DOUBLE PRECISION
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType("float");
				}
3281
		| DECIMAL opt_decimal
3282
				{
3283
					$$ = makeNode(TypeName);
3284
					$$->name = xlateSqlType("numeric");
3285
					$$->typmod = $2;
3286 3287 3288 3289
				}
		| NUMERIC opt_numeric
				{
					$$ = makeNode(TypeName);
3290 3291
					$$->name = xlateSqlType("numeric");
					$$->typmod = $2;
3292 3293
				}
		;
3294

3295 3296 3297 3298 3299
numeric:  FLOAT
				{	$$ = xlateSqlType("float8"); }
		| DOUBLE PRECISION
				{	$$ = xlateSqlType("float8"); }
		| DECIMAL
3300
				{	$$ = xlateSqlType("numeric"); }
3301 3302 3303 3304
		| NUMERIC
				{	$$ = xlateSqlType("numeric"); }
		;

3305 3306 3307
opt_float:  '(' Iconst ')'
				{
					if ($2 < 1)
Bruce Momjian's avatar
Bruce Momjian committed
3308
						elog(ERROR,"precision for FLOAT must be at least 1");
3309 3310 3311 3312 3313
					else if ($2 < 7)
						$$ = xlateSqlType("float4");
					else if ($2 < 16)
						$$ = xlateSqlType("float8");
					else
Bruce Momjian's avatar
Bruce Momjian committed
3314
						elog(ERROR,"precision for FLOAT must be less than 16");
3315 3316 3317 3318 3319 3320 3321 3322 3323
				}
		| /*EMPTY*/
				{
					$$ = xlateSqlType("float8");
				}
		;

opt_numeric:  '(' Iconst ',' Iconst ')'
				{
3324 3325 3326 3327 3328 3329 3330 3331
					if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
						elog(ERROR,"NUMERIC precision %d must be beween 1 and %d",
									$2, NUMERIC_MAX_PRECISION);
					if ($4 < 0 || $4 > $2)
						elog(ERROR,"NUMERIC scale %d must be between 0 and precision %d",
									$4,$2);

					$$ = (($2 << 16) | $4) + VARHDRSZ;
3332 3333 3334
				}
		| '(' Iconst ')'
				{
3335 3336 3337 3338 3339
					if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
						elog(ERROR,"NUMERIC precision %d must be beween 1 and %d",
									$2, NUMERIC_MAX_PRECISION);

					$$ = ($2 << 16) + VARHDRSZ;
3340 3341 3342
				}
		| /*EMPTY*/
				{
3343
					$$ = ((NUMERIC_DEFAULT_PRECISION << 16) | NUMERIC_DEFAULT_SCALE) + VARHDRSZ;
3344 3345 3346 3347 3348
				}
		;

opt_decimal:  '(' Iconst ',' Iconst ')'
				{
3349 3350 3351 3352 3353 3354 3355 3356
					if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
						elog(ERROR,"DECIMAL precision %d must be beween 1 and %d",
									$2, NUMERIC_MAX_PRECISION);
					if ($4 < 0 || $4 > $2)
						elog(ERROR,"DECIMAL scale %d must be between 0 and precision %d",
									$4,$2);

					$$ = (($2 << 16) | $4) + VARHDRSZ;
3357 3358 3359
				}
		| '(' Iconst ')'
				{
3360 3361 3362 3363 3364
					if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
						elog(ERROR,"DECIMAL precision %d must be beween 1 and %d",
									$2, NUMERIC_MAX_PRECISION);

					$$ = ($2 << 16) + VARHDRSZ;
3365 3366 3367
				}
		| /*EMPTY*/
				{
3368
					$$ = ((NUMERIC_DEFAULT_PRECISION << 16) | NUMERIC_DEFAULT_SCALE) + VARHDRSZ;
3369 3370 3371
				}
		;

3372

3373 3374 3375 3376 3377 3378
/* SQL92 character data types
 * The following implements CHAR() and VARCHAR().
 */
Character:  character '(' Iconst ')'
				{
					$$ = makeNode(TypeName);
3379
					if (strcasecmp($1, "char") == 0)
3380
						$$->name = xlateSqlType("bpchar");
3381
					else if (strcasecmp($1, "varchar") == 0)
3382 3383
						$$->name = xlateSqlType("varchar");
					else
3384 3385
						yyerror("internal parsing error; unrecognized character type");

3386
					if ($3 < 1)
3387
						elog(ERROR,"length for '%s' type must be at least 1",$1);
3388 3389 3390
					else if ($3 > MaxTupleSize)
						elog(ERROR,"length for type '%s' cannot exceed %d",$1,
							MaxTupleSize);
3391 3392 3393 3394 3395 3396

					/* we actually implement this sort of like a varlen, so
					 * the first 4 bytes is the length. (the difference
					 * between this and "text" is that we blank-pad and
					 * truncate where necessary
					 */
3397
					$$->typmod = VARHDRSZ + $3;
3398
				}
3399
		| character
3400 3401
				{
					$$ = makeNode(TypeName);
3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
					/* Let's try to make all single-character types into bpchar(1)
					 * - thomas 1998-05-07
					 */
					if (strcasecmp($1, "char") == 0)
					{
						$$->name = xlateSqlType("bpchar");
						$$->typmod = VARHDRSZ + 1;
					}
					else
					{
						$$->name = xlateSqlType($1);
						$$->typmod = -1;
					}
3415 3416
				}
		;
3417

3418 3419 3420 3421 3422 3423
character:  CHARACTER opt_varying opt_charset opt_collate
				{
					char *type, *c;
					if (($3 == NULL) || (strcasecmp($3, "sql_text") == 0)) {
						if ($2) type = xlateSqlType("varchar");
						else type = xlateSqlType("char");
3424
					} else {
3425 3426 3427 3428 3429 3430 3431 3432 3433 3434
						if ($2) {
							c = palloc(strlen("var") + strlen($3) + 1);
							strcpy(c, "var");
							strcat(c, $3);
							type = xlateSqlType(c);
						} else {
							type = xlateSqlType($3);
						}
					};
					if ($4 != NULL)
3435
						elog(NOTICE,"COLLATE %s not yet implemented; clause ignored",$4);
3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459
					$$ = type;
				}
		| CHAR opt_varying						{ $$ = xlateSqlType($2? "varchar": "char"); }
		| VARCHAR								{ $$ = xlateSqlType("varchar"); }
		| NATIONAL CHARACTER opt_varying		{ $$ = xlateSqlType($3? "varchar": "char"); }
		| NCHAR opt_varying						{ $$ = xlateSqlType($2? "varchar": "char"); }
		;

opt_varying:  VARYING							{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
		;

opt_charset:  CHARACTER SET ColId				{ $$ = $3; }
		| /*EMPTY*/								{ $$ = NULL; }
		;

opt_collate:  COLLATE ColId						{ $$ = $2; }
		| /*EMPTY*/								{ $$ = NULL; }
		;

Datetime:  datetime
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType($1);
3460
					$$->typmod = -1;
3461 3462 3463 3464 3465 3466
				}
		| TIMESTAMP opt_timezone
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType("timestamp");
					$$->timezone = $2;
3467
					$$->typmod = -1;
3468 3469 3470 3471 3472
				}
		| TIME
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType("time");
3473
					$$->typmod = -1;
3474 3475 3476 3477 3478
				}
		| INTERVAL opt_interval
				{
					$$ = makeNode(TypeName);
					$$->name = xlateSqlType("interval");
3479
					$$->typmod = -1;
3480
				}
3481
		;
3482

3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
datetime:  YEAR_P								{ $$ = "year"; }
		| MONTH_P								{ $$ = "month"; }
		| DAY_P									{ $$ = "day"; }
		| HOUR_P								{ $$ = "hour"; }
		| MINUTE_P								{ $$ = "minute"; }
		| SECOND_P								{ $$ = "second"; }
		;

opt_timezone:  WITH TIME ZONE					{ $$ = TRUE; }
		| /*EMPTY*/								{ $$ = FALSE; }
		;

opt_interval:  datetime							{ $$ = lcons($1, NIL); }
		| YEAR_P TO MONTH_P						{ $$ = NIL; }
		| DAY_P TO HOUR_P						{ $$ = NIL; }
		| DAY_P TO MINUTE_P						{ $$ = NIL; }
		| DAY_P TO SECOND_P						{ $$ = NIL; }
		| HOUR_P TO MINUTE_P					{ $$ = NIL; }
		| HOUR_P TO SECOND_P					{ $$ = NIL; }
3502
		| MINUTE_P TO SECOND_P					{ $$ = NIL; }
3503
		| /*EMPTY*/								{ $$ = NIL; }
3504 3505
		;

3506 3507 3508

/*****************************************************************************
 *
3509
 *	expression grammar, still needs some cleanup
3510 3511 3512
 *
 *****************************************************************************/

3513
a_expr_or_null:  a_expr
3514
				{ $$ = $1; }
3515
		| NULL_P
3516 3517 3518 3519 3520
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_Null;
					$$ = (Node *)n;
				}
3521 3522 3523 3524 3525
		;

/* Expressions using row descriptors
 * Define row_descriptor to allow yacc to break the reduce/reduce conflict
 *  with singleton expressions.
3526 3527 3528 3529 3530
 * Eliminated lots of code by defining row_op and sub_type clauses.
 * However, can not consolidate EXPR_LINK case with others subselects
 *  due to shift/reduce conflict with the non-subselect clause (the parser
 *  would have to look ahead more than one token to resolve the conflict).
 * - thomas 1998-05-09
3531 3532 3533
 */
row_expr: '(' row_descriptor ')' IN '(' SubSelect ')'
				{
3534 3535
					SubLink *n = makeNode(SubLink);
					n->lefthand = $2;
3536 3537 3538
					n->oper = lcons("=",NIL);
					n->useor = false;
					n->subLinkType = ANY_SUBLINK;
3539 3540
					n->subselect = $6;
					$$ = (Node *)n;
3541 3542 3543
				}
		| '(' row_descriptor ')' NOT IN '(' SubSelect ')'
				{
3544 3545
					SubLink *n = makeNode(SubLink);
					n->lefthand = $2;
3546 3547 3548 3549 3550 3551
					n->oper = lcons("<>",NIL);
					n->useor = true;
					n->subLinkType = ALL_SUBLINK;
					n->subselect = $7;
					$$ = (Node *)n;
				}
3552
		| '(' row_descriptor ')' row_op sub_type '(' SubSelect ')'
3553 3554 3555 3556 3557 3558 3559 3560
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = $2;
					n->oper = lcons($4, NIL);
					if (strcmp($4,"<>") == 0)
						n->useor = true;
					else
						n->useor = false;
3561
					n->subLinkType = $5;
Bruce Momjian's avatar
Bruce Momjian committed
3562 3563 3564
					n->subselect = $7;
					$$ = (Node *)n;
				}
3565
		| '(' row_descriptor ')' row_op '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
3566 3567 3568
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = $2;
3569
					n->oper = lcons($4, NIL);
3570 3571 3572 3573
					if (strcmp($4,"<>") == 0)
						n->useor = true;
					else
						n->useor = false;
3574 3575
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $6;
Bruce Momjian's avatar
Bruce Momjian committed
3576 3577
					$$ = (Node *)n;
				}
3578
		| '(' row_descriptor ')' row_op '(' row_descriptor ')'
3579
				{
Bruce Momjian's avatar
Bruce Momjian committed
3580
					$$ = makeRowExpr($4, $2, $6);
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
				}
		;

row_descriptor:  row_list ',' a_expr
				{
					$$ = lappend($1, $3);
				}
		;

row_list:  row_list ',' a_expr
				{
					$$ = lappend($1, $3);
				}
		| a_expr
				{
					$$ = lcons($1, NIL);
				}
		;
3599

3600 3601 3602 3603 3604 3605 3606 3607
row_op:  Op									{ $$ = $1; }
		| '<'								{ $$ = "<"; }
		| '='								{ $$ = "="; }
		| '>'								{ $$ = ">"; }
		| '+'								{ $$ = "+"; }
		| '-'								{ $$ = "-"; }
		| '*'								{ $$ = "*"; }
		| '/'								{ $$ = "/"; }
3608
		| '%'								{ $$ = "%"; }
3609 3610 3611 3612 3613 3614
		;

sub_type:  ANY								{ $$ = ANY_SUBLINK; }
		| ALL								{ $$ = ALL_SUBLINK; }
		;

3615
/* General expressions
3616 3617 3618 3619
 * This is the heart of the expression syntax.
 * Note that the BETWEEN clause looks similar to a boolean expression
 *  and so we must define b_expr which is almost the same as a_expr
 *  but without the boolean expressions.
3620 3621
 * All operations/expressions are allowed in a BETWEEN clause
 *  if surrounded by parens.
3622
 */
3623
a_expr:  attr opt_indirection
3624 3625 3626 3627
				{
					$1->indirection = $2;
					$$ = (Node *)$1;
				}
3628 3629
		| row_expr
				{	$$ = $1;  }
3630 3631
		| AexprConst
				{	$$ = $1;  }
3632 3633 3634 3635 3636 3637 3638 3639
		| ColId
				{
					/* could be a column name or a relation_name */
					Ident *n = makeNode(Ident);
					n->name = $1;
					n->indirection = NULL;
					$$ = (Node *)n;
				}
3640
		| '-' a_expr %prec UMINUS
3641
				{	$$ = doNegate($2); }
Bruce Momjian's avatar
Bruce Momjian committed
3642
		| '%' a_expr
Bruce Momjian's avatar
Bruce Momjian committed
3643
				{	$$ = makeA_Expr(OP, "%", NULL, $2); }
Bruce Momjian's avatar
Bruce Momjian committed
3644
		| a_expr '%'
Bruce Momjian's avatar
Bruce Momjian committed
3645
				{	$$ = makeA_Expr(OP, "%", $1, NULL); }
3646 3647 3648 3649 3650 3651
		| a_expr '+' a_expr
				{	$$ = makeA_Expr(OP, "+", $1, $3); }
		| a_expr '-' a_expr
				{	$$ = makeA_Expr(OP, "-", $1, $3); }
		| a_expr '/' a_expr
				{	$$ = makeA_Expr(OP, "/", $1, $3); }
3652 3653
		| a_expr '%' a_expr
				{	$$ = makeA_Expr(OP, "%", $1, $3); }
3654 3655 3656 3657 3658 3659
		| a_expr '*' a_expr
				{	$$ = makeA_Expr(OP, "*", $1, $3); }
		| a_expr '<' a_expr
				{	$$ = makeA_Expr(OP, "<", $1, $3); }
		| a_expr '>' a_expr
				{	$$ = makeA_Expr(OP, ">", $1, $3); }
3660

3661 3662
  		| a_expr '=' NULL_P
  				{	$$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
Bruce Momjian's avatar
Bruce Momjian committed
3663 3664
		/* We allow this for standards-broken SQL products, like MS stuff */
  		| NULL_P '=' a_expr
3665 3666
  				{	$$ = makeA_Expr(ISNULL, NULL, $3, NULL); }

3667 3668 3669 3670 3671 3672 3673 3674
		| a_expr '=' a_expr
				{	$$ = makeA_Expr(OP, "=", $1, $3); }
		| ':' a_expr
				{	$$ = makeA_Expr(OP, ":", NULL, $2); }
		| ';' a_expr
				{	$$ = makeA_Expr(OP, ";", NULL, $2); }
		| '|' a_expr
				{	$$ = makeA_Expr(OP, "|", NULL, $2); }
3675
		| a_expr TYPECAST Typename
3676
				{
3677
					$$ = (Node *)$1;
3678
					/* AexprConst can be either A_Const or ParamNo */
3679
					if (nodeTag($1) == T_A_Const) {
3680
						((A_Const *)$1)->typename = $3;
3681
					} else if (nodeTag($1) == T_Param) {
3682
						((ParamNo *)$1)->typename = $3;
3683 3684 3685 3686 3687 3688 3689
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
						n->funcname = $3->name;
						n->args = lcons($1,NIL);
						$$ = (Node *)n;
					}
3690
				}
3691
		| CAST '(' a_expr AS Typename ')'
3692
				{
3693
					$$ = (Node *)$3;
3694
					/* AexprConst can be either A_Const or ParamNo */
3695 3696 3697 3698
					if (nodeTag($3) == T_A_Const) {
						((A_Const *)$3)->typename = $5;
					} else if (nodeTag($5) == T_Param) {
						((ParamNo *)$3)->typename = $5;
3699 3700 3701
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
3702 3703
						n->funcname = $5->name;
						n->args = lcons($3,NIL);
3704 3705
						$$ = (Node *)n;
					}
3706 3707 3708 3709
				}
		| '(' a_expr_or_null ')'
				{	$$ = $2; }
		| a_expr Op a_expr
3710
				{	$$ = makeIndexable($2,$1,$3);	}
3711
		| a_expr LIKE a_expr
3712
				{	$$ = makeIndexable("~~", $1, $3); }
3713 3714 3715 3716 3717 3718
		| a_expr NOT LIKE a_expr
				{	$$ = makeA_Expr(OP, "!~~", $1, $4); }
		| Op a_expr
				{	$$ = makeA_Expr(OP, $1, NULL, $2); }
		| a_expr Op
				{	$$ = makeA_Expr(OP, $2, $1, NULL); }
3719
		| func_name '(' '*' ')'
3720
				{
3721
					/* cheap hack for aggregate (eg. count) */
3722
					FuncCall *n = makeNode(FuncCall);
3723
					A_Const *star = makeNode(A_Const);
3724

3725 3726
					star->val.type = T_String;
					star->val.val.str = "";
3727 3728 3729 3730
					n->funcname = $1;
					n->args = lcons(star, NIL);
					$$ = (Node *)n;
				}
3731
		| func_name '(' ')'
3732 3733 3734 3735
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = NIL;
3736 3737
					$$ = (Node *)n;
				}
3738
		| func_name '(' expr_list ')'
3739 3740 3741 3742 3743 3744
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = $3;
					$$ = (Node *)n;
				}
3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755
		| CURRENT_DATE
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("date");
					t->setof = FALSE;
3756 3757
					t->typmod = -1;
 
3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770
					$$ = (Node *)n;
				}
		| CURRENT_TIME
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("time");
					t->setof = FALSE;
3771
					t->typmod = -1;
3772 3773 3774

					$$ = (Node *)n;
				}
3775
		| CURRENT_TIME '(' Iconst ')'
3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789
				{
					FuncCall *n = makeNode(FuncCall);
					A_Const *s = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->funcname = xlateSqlType("time");
					n->args = lcons(s, NIL);

					s->val.type = T_String;
					s->val.val.str = "now";
					s->typename = t;

					t->name = xlateSqlType("time");
					t->setof = FALSE;
3790
					t->typmod = -1;
3791

3792
					if ($3 != 0)
3793
						elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807

					$$ = (Node *)n;
				}
		| CURRENT_TIMESTAMP
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("timestamp");
					t->setof = FALSE;
3808
					t->typmod = -1;
3809 3810 3811

					$$ = (Node *)n;
				}
3812
		| CURRENT_TIMESTAMP '(' Iconst ')'
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
				{
					FuncCall *n = makeNode(FuncCall);
					A_Const *s = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->funcname = xlateSqlType("timestamp");
					n->args = lcons(s, NIL);

					s->val.type = T_String;
					s->val.val.str = "now";
					s->typename = t;

					t->name = xlateSqlType("timestamp");
					t->setof = FALSE;
3827
					t->typmod = -1;
3828

3829
					if ($3 != 0)
3830
						elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
3831

3832 3833
					$$ = (Node *)n;
				}
3834
		| CURRENT_USER
3835 3836 3837 3838 3839 3840
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "getpgusername";
					n->args = NIL;
					$$ = (Node *)n;
				}
3841 3842 3843 3844 3845 3846 3847
		| USER
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "getpgusername";
					n->args = NIL;
					$$ = (Node *)n;
				}
3848 3849
		| EXISTS '(' SubSelect ')'
				{
3850 3851
					SubLink *n = makeNode(SubLink);
					n->lefthand = NIL;
3852
					n->useor = false;
3853
					n->oper = NIL;
3854
					n->subLinkType = EXISTS_SUBLINK;
3855 3856
					n->subselect = $3;
					$$ = (Node *)n;
3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909
				}
		| EXTRACT '(' extract_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "date_part";
					n->args = $3;
					$$ = (Node *)n;
				}
		| POSITION '(' position_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "strpos";
					n->args = $3;
					$$ = (Node *)n;
				}
		| SUBSTRING '(' substr_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "substr";
					n->args = $3;
					$$ = (Node *)n;
				}
		/* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
		| TRIM '(' BOTH trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' LEADING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "ltrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' TRAILING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "rtrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $3;
					$$ = (Node *)n;
				}
		| a_expr ISNULL
				{	$$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3910
		| a_expr IS NULL_P
3911 3912 3913
				{	$$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
		| a_expr NOTNULL
				{	$$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3914
		| a_expr IS NOT NULL_P
3915
				{	$$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3916 3917 3918 3919 3920
		/* IS TRUE, IS FALSE, etc used to be function calls
		 *  but let's make them expressions to allow the optimizer
		 *  a chance to eliminate them if a_expr is a constant string.
		 * - thomas 1997-12-22
		 */
3921 3922
		| a_expr IS TRUE_P
				{
3923 3924 3925 3926 3927
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "t";
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
3928
					n->typename->typmod = -1;
3929
					$$ = makeA_Expr(OP, "=", $1,(Node *)n);
3930
				}
3931
		| a_expr IS NOT FALSE_P
3932
				{
3933 3934 3935 3936 3937
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "t";
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
3938
					n->typename->typmod = -1;
3939
					$$ = makeA_Expr(OP, "=", $1,(Node *)n);
3940
				}
3941
		| a_expr IS FALSE_P
3942
				{
3943 3944 3945 3946 3947
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "f";
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
3948
					n->typename->typmod = -1;
3949
					$$ = makeA_Expr(OP, "=", $1,(Node *)n);
3950
				}
3951
		| a_expr IS NOT TRUE_P
3952
				{
3953 3954 3955 3956 3957
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "f";
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
3958
					n->typename->typmod = -1;
3959
					$$ = makeA_Expr(OP, "=", $1,(Node *)n);
3960
				}
3961
		| a_expr BETWEEN b_expr AND b_expr
3962 3963 3964 3965 3966
				{
					$$ = makeA_Expr(AND, NULL,
						makeA_Expr(OP, ">=", $1, $3),
						makeA_Expr(OP, "<=", $1, $5));
				}
3967
		| a_expr NOT BETWEEN b_expr AND b_expr
3968 3969 3970 3971 3972
				{
					$$ = makeA_Expr(OR, NULL,
						makeA_Expr(OP, "<", $1, $4),
						makeA_Expr(OP, ">", $1, $6));
				}
3973
		| a_expr IN { saved_In_Expr = lcons($1,saved_In_Expr); } '(' in_expr ')'
3974
				{
3975
					saved_In_Expr = lnext(saved_In_Expr);
3976 3977
					if (nodeTag($5) == T_SubLink)
					{
3978 3979 3980 3981 3982 3983
							SubLink *n = (SubLink *)$5;
							n->lefthand = lcons($1, NIL);
							n->oper = lcons("=",NIL);
							n->useor = false;
							n->subLinkType = ANY_SUBLINK;
							$$ = (Node *)n;
3984 3985 3986
					}
					else	$$ = $5;
				}
3987
		| a_expr NOT IN { saved_In_Expr = lcons($1,saved_In_Expr); } '(' not_in_expr ')'
3988
				{
3989
					saved_In_Expr = lnext(saved_In_Expr);
3990 3991
					if (nodeTag($6) == T_SubLink)
					{
3992 3993 3994 3995 3996 3997
							SubLink *n = (SubLink *)$6;
							n->lefthand = lcons($1, NIL);
							n->oper = lcons("<>",NIL);
							n->useor = false;
							n->subLinkType = ALL_SUBLINK;
							$$ = (Node *)n;
3998 3999 4000
					}
					else	$$ = $6;
				}
4001
		| a_expr Op '(' SubSelect ')'
4002 4003
				{
					SubLink *n = makeNode(SubLink);
4004
					n->lefthand = lcons($1, NULL);
4005 4006
					n->oper = lcons($2,NIL);
					n->useor = false;
4007 4008
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
4009 4010
					$$ = (Node *)n;
				}
4011
		| a_expr '+' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4012 4013
				{
					SubLink *n = makeNode(SubLink);
4014
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4015 4016
					n->oper = lcons("+",NIL);
					n->useor = false;
4017 4018
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4019 4020
					$$ = (Node *)n;
				}
4021
		| a_expr '-' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4022 4023
				{
					SubLink *n = makeNode(SubLink);
4024
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4025 4026
					n->oper = lcons("-",NIL);
					n->useor = false;
4027 4028
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4029 4030
					$$ = (Node *)n;
				}
4031
		| a_expr '/' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4032 4033
				{
					SubLink *n = makeNode(SubLink);
4034
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4035 4036
					n->oper = lcons("/",NIL);
					n->useor = false;
4037 4038
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4039 4040
					$$ = (Node *)n;
				}
4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
		| a_expr '%' '(' SubSelect ')'
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("%",NIL);
					n->useor = false;
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
					$$ = (Node *)n;
				}
4051
		| a_expr '*' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4052 4053
				{
					SubLink *n = makeNode(SubLink);
4054
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4055 4056
					n->oper = lcons("*",NIL);
					n->useor = false;
4057 4058
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4059 4060
					$$ = (Node *)n;
				}
4061
		| a_expr '<' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4062 4063
				{
					SubLink *n = makeNode(SubLink);
4064
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4065 4066
					n->oper = lcons("<",NIL);
					n->useor = false;
4067 4068
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4069 4070
					$$ = (Node *)n;
				}
4071
		| a_expr '>' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4072 4073
				{
					SubLink *n = makeNode(SubLink);
4074
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4075 4076
					n->oper = lcons(">",NIL);
					n->useor = false;
4077 4078
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4079 4080
					$$ = (Node *)n;
				}
4081
		| a_expr '=' '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4082 4083
				{
					SubLink *n = makeNode(SubLink);
4084
					n->lefthand = lcons($1, NULL);
Bruce Momjian's avatar
Bruce Momjian committed
4085 4086
					n->oper = lcons("=",NIL);
					n->useor = false;
4087 4088
					n->subLinkType = EXPR_SUBLINK;
					n->subselect = $4;
Bruce Momjian's avatar
Bruce Momjian committed
4089 4090
					$$ = (Node *)n;
				}
4091
		| a_expr Op ANY '(' SubSelect ')'
4092 4093
				{
					SubLink *n = makeNode(SubLink);
4094
					n->lefthand = lcons($1,NIL);
4095 4096
					n->oper = lcons($2,NIL);
					n->useor = false;
4097
					n->subLinkType = ANY_SUBLINK;
4098 4099 4100
					n->subselect = $5;
					$$ = (Node *)n;
				}
4101
		| a_expr '+' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4102 4103
				{
					SubLink *n = makeNode(SubLink);
4104
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4105 4106
					n->oper = lcons("+",NIL);
					n->useor = false;
4107
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4108 4109 4110
					n->subselect = $5;
					$$ = (Node *)n;
				}
4111
		| a_expr '-' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4112 4113
				{
					SubLink *n = makeNode(SubLink);
4114
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4115 4116
					n->oper = lcons("-",NIL);
					n->useor = false;
4117
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4118 4119 4120
					n->subselect = $5;
					$$ = (Node *)n;
				}
4121
		| a_expr '/' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4122 4123
				{
					SubLink *n = makeNode(SubLink);
4124
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4125 4126
					n->oper = lcons("/",NIL);
					n->useor = false;
4127
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4128 4129 4130
					n->subselect = $5;
					$$ = (Node *)n;
				}
4131 4132 4133 4134 4135 4136 4137 4138 4139 4140
		| a_expr '%' ANY '(' SubSelect ')'
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1,NIL);
					n->oper = lcons("%",NIL);
					n->useor = false;
					n->subLinkType = ANY_SUBLINK;
					n->subselect = $5;
					$$ = (Node *)n;
				}
4141
		| a_expr '*' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4142 4143
				{
					SubLink *n = makeNode(SubLink);
4144
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4145 4146
					n->oper = lcons("*",NIL);
					n->useor = false;
4147
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4148 4149 4150
					n->subselect = $5;
					$$ = (Node *)n;
				}
4151
		| a_expr '<' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4152 4153
				{
					SubLink *n = makeNode(SubLink);
4154
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4155 4156
					n->oper = lcons("<",NIL);
					n->useor = false;
4157
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4158 4159 4160
					n->subselect = $5;
					$$ = (Node *)n;
				}
4161
		| a_expr '>' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4162 4163
				{
					SubLink *n = makeNode(SubLink);
4164
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4165 4166
					n->oper = lcons(">",NIL);
					n->useor = false;
4167
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4168 4169 4170
					n->subselect = $5;
					$$ = (Node *)n;
				}
4171
		| a_expr '=' ANY '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4172 4173
				{
					SubLink *n = makeNode(SubLink);
4174
					n->lefthand = lcons($1,NIL);
Bruce Momjian's avatar
Bruce Momjian committed
4175 4176
					n->oper = lcons("=",NIL);
					n->useor = false;
4177
					n->subLinkType = ANY_SUBLINK;
Bruce Momjian's avatar
Bruce Momjian committed
4178 4179 4180
					n->subselect = $5;
					$$ = (Node *)n;
				}
4181
		| a_expr Op ALL '(' SubSelect ')'
4182 4183 4184 4185 4186 4187
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons($2,NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4188
					n->subselect = $5;
4189 4190
					$$ = (Node *)n;
				}
4191
		| a_expr '+' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4192 4193 4194 4195 4196 4197
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("+",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4198
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4199 4200
					$$ = (Node *)n;
				}
4201
		| a_expr '-' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4202 4203 4204 4205 4206 4207
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("-",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4208
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4209 4210
					$$ = (Node *)n;
				}
4211
		| a_expr '/' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4212 4213 4214 4215 4216 4217
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("/",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4218
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4219 4220
					$$ = (Node *)n;
				}
4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
		| a_expr '%' ALL '(' SubSelect ')'
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("%",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
					n->subselect = $5;
					$$ = (Node *)n;
				}
4231
		| a_expr '*' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4232 4233 4234 4235 4236 4237
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("*",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4238
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4239 4240
					$$ = (Node *)n;
				}
4241
		| a_expr '<' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4242 4243 4244 4245 4246 4247
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("<",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4248
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4249 4250
					$$ = (Node *)n;
				}
4251
		| a_expr '>' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4252 4253 4254 4255 4256 4257
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons(">",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4258
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4259 4260
					$$ = (Node *)n;
				}
4261
		| a_expr '=' ALL '(' SubSelect ')'
Bruce Momjian's avatar
Bruce Momjian committed
4262 4263 4264 4265 4266 4267
				{
					SubLink *n = makeNode(SubLink);
					n->lefthand = lcons($1, NULL);
					n->oper = lcons("=",NIL);
					n->useor = false;
					n->subLinkType = ALL_SUBLINK;
4268
					n->subselect = $5;
Bruce Momjian's avatar
Bruce Momjian committed
4269 4270
					$$ = (Node *)n;
				}
4271 4272 4273 4274 4275 4276
		| a_expr AND a_expr
				{	$$ = makeA_Expr(AND, NULL, $1, $3); }
		| a_expr OR a_expr
				{	$$ = makeA_Expr(OR, NULL, $1, $3); }
		| NOT a_expr
				{	$$ = makeA_Expr(NOT, NULL, NULL, $2); }
4277 4278
		| case_expr
				{	$$ = $1; }
4279
		;
4280

4281
/* Restricted expressions
4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301
 * b_expr is a subset of the complete expression syntax
 *  defined by a_expr. b_expr is used in BETWEEN clauses
 *  to eliminate parser ambiguities stemming from the AND keyword.
 */
b_expr:  attr opt_indirection
				{
					$1->indirection = $2;
					$$ = (Node *)$1;
				}
		| AexprConst
				{	$$ = $1;  }
		| ColId
				{
					/* could be a column name or a relation_name */
					Ident *n = makeNode(Ident);
					n->name = $1;
					n->indirection = NULL;
					$$ = (Node *)n;
				}
		| '-' b_expr %prec UMINUS
4302
				{	$$ = doNegate($2); }
Bruce Momjian's avatar
Bruce Momjian committed
4303 4304 4305 4306
		| '%' b_expr
				{	$$ = makeA_Expr(OP, "%", NULL, $2); }
		| b_expr '%'
				{	$$ = makeA_Expr(OP, "%", $1, NULL); }
4307 4308 4309 4310 4311 4312
		| b_expr '+' b_expr
				{	$$ = makeA_Expr(OP, "+", $1, $3); }
		| b_expr '-' b_expr
				{	$$ = makeA_Expr(OP, "-", $1, $3); }
		| b_expr '/' b_expr
				{	$$ = makeA_Expr(OP, "/", $1, $3); }
4313 4314
		| b_expr '%' b_expr
				{	$$ = makeA_Expr(OP, "%", $1, $3); }
4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338
		| b_expr '*' b_expr
				{	$$ = makeA_Expr(OP, "*", $1, $3); }
		| ':' b_expr
				{	$$ = makeA_Expr(OP, ":", NULL, $2); }
		| ';' b_expr
				{	$$ = makeA_Expr(OP, ";", NULL, $2); }
		| '|' b_expr
				{	$$ = makeA_Expr(OP, "|", NULL, $2); }
		| b_expr TYPECAST Typename
				{
					$$ = (Node *)$1;
					/* AexprConst can be either A_Const or ParamNo */
					if (nodeTag($1) == T_A_Const) {
						((A_Const *)$1)->typename = $3;
					} else if (nodeTag($1) == T_Param) {
						((ParamNo *)$1)->typename = $3;
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
						n->funcname = $3->name;
						n->args = lcons($1,NIL);
						$$ = (Node *)n;
					}
				}
4339
		| CAST '(' b_expr AS Typename ')'
4340
				{
4341
					$$ = (Node *)$3;
4342
					/* AexprConst can be either A_Const or ParamNo */
4343 4344 4345 4346
					if (nodeTag($3) == T_A_Const) {
						((A_Const *)$3)->typename = $5;
					} else if (nodeTag($3) == T_Param) {
						((ParamNo *)$3)->typename = $5;
4347 4348 4349
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
4350 4351
						n->funcname = $5->name;
						n->args = lcons($3,NIL);
4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362
						$$ = (Node *)n;
					}
				}
		| '(' a_expr ')'
				{	$$ = $2; }
		| b_expr Op b_expr
				{	$$ = makeIndexable($2,$1,$3);	}
		| Op b_expr
				{	$$ = makeA_Expr(OP, $1, NULL, $2); }
		| b_expr Op
				{	$$ = makeA_Expr(OP, $2, $1, NULL); }
4363
		| func_name '(' ')'
4364 4365 4366 4367 4368 4369
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = NIL;
					$$ = (Node *)n;
				}
4370
		| func_name '(' expr_list ')'
4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = $3;
					$$ = (Node *)n;
				}
		| CURRENT_DATE
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("date");
					t->setof = FALSE;
4388
					t->typmod = -1;
4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402

					$$ = (Node *)n;
				}
		| CURRENT_TIME
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("time");
					t->setof = FALSE;
4403
					t->typmod = -1;
4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421

					$$ = (Node *)n;
				}
		| CURRENT_TIME '(' Iconst ')'
				{
					FuncCall *n = makeNode(FuncCall);
					A_Const *s = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->funcname = xlateSqlType("time");
					n->args = lcons(s, NIL);

					s->val.type = T_String;
					s->val.val.str = "now";
					s->typename = t;

					t->name = xlateSqlType("time");
					t->setof = FALSE;
4422
					t->typmod = -1;
4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439

					if ($3 != 0)
						elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);

					$$ = (Node *)n;
				}
		| CURRENT_TIMESTAMP
				{
					A_Const *n = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->val.type = T_String;
					n->val.val.str = "now";
					n->typename = t;

					t->name = xlateSqlType("timestamp");
					t->setof = FALSE;
4440
					t->typmod = -1;
4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458

					$$ = (Node *)n;
				}
		| CURRENT_TIMESTAMP '(' Iconst ')'
				{
					FuncCall *n = makeNode(FuncCall);
					A_Const *s = makeNode(A_Const);
					TypeName *t = makeNode(TypeName);

					n->funcname = xlateSqlType("timestamp");
					n->args = lcons(s, NIL);

					s->val.type = T_String;
					s->val.val.str = "now";
					s->typename = t;

					t->name = xlateSqlType("timestamp");
					t->setof = FALSE;
4459
					t->typmod = -1;
4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472

					if ($3 != 0)
						elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);

					$$ = (Node *)n;
				}
		| CURRENT_USER
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "getpgusername";
					n->args = NIL;
					$$ = (Node *)n;
				}
4473 4474 4475 4476 4477 4478 4479
		| USER
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "getpgusername";
					n->args = NIL;
					$$ = (Node *)n;
				}
4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524
		| POSITION '(' position_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "strpos";
					n->args = $3;
					$$ = (Node *)n;
				}
		| SUBSTRING '(' substr_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "substr";
					n->args = $3;
					$$ = (Node *)n;
				}
		/* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
		| TRIM '(' BOTH trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' LEADING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "ltrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' TRAILING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "rtrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $3;
					$$ = (Node *)n;
				}
		;

4525
opt_indirection:  '[' a_expr ']' opt_indirection
4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538
				{
					A_Indices *ai = makeNode(A_Indices);
					ai->lidx = NULL;
					ai->uidx = $2;
					$$ = lcons(ai, $4);
				}
		| '[' a_expr ':' a_expr ']' opt_indirection
				{
					A_Indices *ai = makeNode(A_Indices);
					ai->lidx = $2;
					ai->uidx = $4;
					$$ = lcons(ai, $6);
				}
4539
		| /*EMPTY*/
4540 4541
				{	$$ = NIL; }
		;
4542

4543
expr_list:  a_expr_or_null
4544
				{ $$ = lcons($1, NIL); }
4545
		| expr_list ',' a_expr_or_null
4546
				{ $$ = lappend($1, $3); }
4547
		| expr_list USING a_expr
4548 4549
				{ $$ = lappend($1, $3); }
		;
4550

4551
extract_list:  extract_arg FROM a_expr
4552 4553 4554 4555 4556 4557
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = $1;
					$$ = lappend(lcons((Node *)n,NIL), $3);
				}
4558
		| /*EMPTY*/
4559 4560
				{	$$ = NIL; }
		;
4561

4562 4563 4564
extract_arg:  datetime						{ $$ = $1; }
		| TIMEZONE_HOUR						{ $$ = "tz_hour"; }
		| TIMEZONE_MINUTE					{ $$ = "tz_minute"; }
4565 4566
		;

4567
position_list:  position_expr IN position_expr
4568
				{	$$ = makeList($3, $1, -1); }
4569
		| /*EMPTY*/
4570 4571
				{	$$ = NIL; }
		;
4572

4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587
position_expr:  attr opt_indirection
				{
					$1->indirection = $2;
					$$ = (Node *)$1;
				}
		| AexprConst
				{	$$ = $1;  }
		| '-' position_expr %prec UMINUS
				{	$$ = makeA_Expr(OP, "-", NULL, $2); }
		| position_expr '+' position_expr
				{	$$ = makeA_Expr(OP, "+", $1, $3); }
		| position_expr '-' position_expr
				{	$$ = makeA_Expr(OP, "-", $1, $3); }
		| position_expr '/' position_expr
				{	$$ = makeA_Expr(OP, "/", $1, $3); }
4588 4589
		| position_expr '%' position_expr
				{	$$ = makeA_Expr(OP, "%", $1, $3); }
4590 4591 4592 4593
		| position_expr '*' position_expr
				{	$$ = makeA_Expr(OP, "*", $1, $3); }
		| '|' position_expr
				{	$$ = makeA_Expr(OP, "|", NULL, $2); }
4594
		| position_expr TYPECAST Typename
4595
				{
4596
					$$ = (Node *)$1;
4597
					/* AexprConst can be either A_Const or ParamNo */
4598
					if (nodeTag($1) == T_A_Const) {
4599
						((A_Const *)$1)->typename = $3;
4600
					} else if (nodeTag($1) == T_Param) {
4601
						((ParamNo *)$1)->typename = $3;
4602 4603 4604 4605 4606 4607 4608
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
						n->funcname = $3->name;
						n->args = lcons($1,NIL);
						$$ = (Node *)n;
					}
4609
				}
4610
		| CAST '(' position_expr AS Typename ')'
4611
				{
4612
					$$ = (Node *)$3;
4613
					/* AexprConst can be either A_Const or ParamNo */
4614 4615 4616 4617
					if (nodeTag($3) == T_A_Const) {
						((A_Const *)$3)->typename = $5;
					} else if (nodeTag($3) == T_Param) {
						((ParamNo *)$3)->typename = $5;
4618 4619 4620
					/* otherwise, try to transform to a function call */
					} else {
						FuncCall *n = makeNode(FuncCall);
4621 4622
						n->funcname = $5->name;
						n->args = lcons($3,NIL);
4623 4624
						$$ = (Node *)n;
					}
4625 4626 4627 4628 4629 4630 4631 4632 4633
				}
		| '(' position_expr ')'
				{	$$ = $2; }
		| position_expr Op position_expr
				{	$$ = makeA_Expr(OP, $2, $1, $3); }
		| Op position_expr
				{	$$ = makeA_Expr(OP, $1, NULL, $2); }
		| position_expr Op
				{	$$ = makeA_Expr(OP, $2, $1, NULL); }
4634
		| ColId
4635 4636 4637 4638 4639 4640 4641
				{
					/* could be a column name or a relation_name */
					Ident *n = makeNode(Ident);
					n->name = $1;
					n->indirection = NULL;
					$$ = (Node *)n;
				}
4642
		| func_name '(' ')'
4643 4644 4645 4646 4647 4648
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = NIL;
					$$ = (Node *)n;
				}
4649
		| func_name '(' expr_list ')'
4650 4651 4652 4653 4654 4655
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = $1;
					n->args = $3;
					$$ = (Node *)n;
				}
4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700
		| POSITION '(' position_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "strpos";
					n->args = $3;
					$$ = (Node *)n;
				}
		| SUBSTRING '(' substr_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "substr";
					n->args = $3;
					$$ = (Node *)n;
				}
		/* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
		| TRIM '(' BOTH trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' LEADING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "ltrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' TRAILING trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "rtrim";
					n->args = $4;
					$$ = (Node *)n;
				}
		| TRIM '(' trim_list ')'
				{
					FuncCall *n = makeNode(FuncCall);
					n->funcname = "btrim";
					n->args = $3;
					$$ = (Node *)n;
				}
		;

4701
substr_list:  expr_list substr_from substr_for
4702
				{
4703
					$$ = nconc(nconc($1,$2),$3);
4704
				}
4705
		| /*EMPTY*/
4706 4707
				{	$$ = NIL; }
		;
4708

4709
substr_from:  FROM expr_list
4710
				{	$$ = $2; }
4711
		| /*EMPTY*/
4712 4713 4714 4715 4716 4717
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_Integer;
					n->val.val.ival = 1;
					$$ = lcons((Node *)n,NIL);
				}
4718
		;
4719

4720
substr_for:  FOR expr_list
4721
				{	$$ = $2; }
4722
		| /*EMPTY*/
4723 4724
				{	$$ = NIL; }
		;
4725

4726
trim_list:  a_expr FROM expr_list
4727
				{ $$ = lappend($3, $1); }
4728
		| FROM expr_list
4729
				{ $$ = $2; }
4730
		| expr_list
4731 4732
				{ $$ = $1; }
		;
4733

4734 4735
in_expr:  SubSelect
				{
4736 4737 4738
					SubLink *n = makeNode(SubLink);
					n->subselect = $1;
					$$ = (Node *)n;
4739 4740 4741 4742 4743
				}
		| in_expr_nodes
				{	$$ = $1; }
		;

4744
in_expr_nodes:  AexprConst
4745
				{	$$ = makeA_Expr(OP, "=", lfirst(saved_In_Expr), $1); }
4746
		| in_expr_nodes ',' AexprConst
4747
				{	$$ = makeA_Expr(OR, NULL, $1,
4748
						makeA_Expr(OP, "=", lfirst(saved_In_Expr), $3));
4749 4750
				}
		;
4751

4752 4753
not_in_expr:  SubSelect
				{
4754 4755 4756
					SubLink *n = makeNode(SubLink);
					n->subselect = $1;
					$$ = (Node *)n;
4757 4758 4759 4760 4761
				}
		| not_in_expr_nodes
				{	$$ = $1; }
		;

4762
not_in_expr_nodes:  AexprConst
4763
				{	$$ = makeA_Expr(OP, "<>", lfirst(saved_In_Expr), $1); }
4764
		| not_in_expr_nodes ',' AexprConst
4765
				{	$$ = makeA_Expr(AND, NULL, $1,
4766
						makeA_Expr(OP, "<>", lfirst(saved_In_Expr), $3));
4767 4768
				}
		;
4769

4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796
/* Case clause
 * Define SQL92-style case clause.
 * Allow all four forms described in the standard:
 * - Full specification
 *  CASE WHEN a = b THEN c ... ELSE d END
 * - Implicit argument
 *  CASE a WHEN b THEN c ... ELSE d END
 * - Conditional NULL
 *  NULLIF(x,y)
 *  same as CASE WHEN x = y THEN NULL ELSE x END
 * - Conditional substitution from list, use first non-null argument
 *  COALESCE(a,b,...)
 * same as CASE WHEN a IS NOT NULL THEN a WHEN b IS NOT NULL THEN b ... END
 * - thomas 1998-11-09
 */
case_expr:  CASE case_arg when_clause_list case_default END_TRANS
				{
					CaseExpr *c = makeNode(CaseExpr);
					c->arg = $2;
					c->args = $3;
					c->defresult = $4;
					$$ = (Node *)c;
				}
		| NULLIF '(' a_expr ',' a_expr ')'
				{
					CaseExpr *c = makeNode(CaseExpr);
					CaseWhen *w = makeNode(CaseWhen);
4797 4798 4799 4800 4801 4802
/*
					A_Const *n = makeNode(A_Const);
					n->val.type = T_Null;
					w->result = (Node *)n;
*/
					w->expr = makeA_Expr(OP, "=", $3, $5);
4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858
					c->args = lcons(w, NIL);
					c->defresult = $3;
					$$ = (Node *)c;
				}
		| COALESCE '(' expr_list ')'
				{
					CaseExpr *c = makeNode(CaseExpr);
					CaseWhen *w;
					List *l;
					foreach (l,$3)
					{
						w = makeNode(CaseWhen);
						w->expr = makeA_Expr(NOTNULL, NULL, lfirst(l), NULL);
						w->result = lfirst(l);
						c->args = lappend(c->args, w);
					}
					$$ = (Node *)c;
				}
		;

when_clause_list:  when_clause_list when_clause
				{ $$ = lappend($1, $2); }
		| when_clause
				{ $$ = lcons($1, NIL); }
		;

when_clause:  WHEN a_expr THEN a_expr_or_null
				{
					CaseWhen *w = makeNode(CaseWhen);
					w->expr = $2;
					w->result = $4;
					$$ = (Node *)w;
				}
		;

case_default:  ELSE a_expr_or_null				{ $$ = $2; }
		| /*EMPTY*/								{ $$ = NULL; }
		;

case_arg:  attr opt_indirection
				{
					$1->indirection = $2;
					$$ = (Node *)$1;
				}
		| ColId
				{
					/* could be a column name or a relation_name */
					Ident *n = makeNode(Ident);
					n->name = $1;
					n->indirection = NULL;
					$$ = (Node *)n;
				}
		| /*EMPTY*/
				{	$$ = NULL; }
		;

4859
attr:  relation_name '.' attrs
4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884
				{
					$$ = makeNode(Attr);
					$$->relname = $1;
					$$->paramNo = NULL;
					$$->attrs = $3;
					$$->indirection = NULL;
				}
		| ParamNo '.' attrs
				{
					$$ = makeNode(Attr);
					$$->relname = NULL;
					$$->paramNo = $1;
					$$->attrs = $3;
					$$->indirection = NULL;
				}
		;

attrs:	  attr_name
				{ $$ = lcons(makeString($1), NIL); }
		| attrs '.' attr_name
				{ $$ = lappend($1, makeString($3)); }
		| attrs '.' '*'
				{ $$ = lappend($1, makeString("*")); }
		;

4885 4886 4887

/*****************************************************************************
 *
4888
 *	target lists
4889 4890 4891
 *
 *****************************************************************************/

4892
res_target_list:  res_target_list ',' res_target_el
4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909
				{	$$ = lappend($1,$3);  }
		| res_target_el
				{	$$ = lcons($1, NIL);  }
		| '*'
				{
					ResTarget *rt = makeNode(ResTarget);
					Attr *att = makeNode(Attr);
					att->relname = "*";
					att->paramNo = NULL;
					att->attrs = NULL;
					att->indirection = NIL;
					rt->name = NULL;
					rt->indirection = NULL;
					rt->val = (Node *)att;
					$$ = lcons(rt, NIL);
				}
		;
4910

4911
res_target_el:  ColId opt_indirection '=' a_expr_or_null
4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937
				{
					$$ = makeNode(ResTarget);
					$$->name = $1;
					$$->indirection = $2;
					$$->val = (Node *)$4;
				}
		| attr opt_indirection
				{
					$$ = makeNode(ResTarget);
					$$->name = NULL;
					$$->indirection = $2;
					$$->val = (Node *)$1;
				}
		| relation_name '.' '*'
				{
					Attr *att = makeNode(Attr);
					att->relname = $1;
					att->paramNo = NULL;
					att->attrs = lcons(makeString("*"), NIL);
					att->indirection = NIL;
					$$ = makeNode(ResTarget);
					$$->name = NULL;
					$$->indirection = NULL;
					$$->val = (Node *)att;
				}
		;
4938 4939 4940

/*
** target list for select.
Bruce Momjian's avatar
Bruce Momjian committed
4941
** should get rid of the other but is still needed by the defunct select into
4942 4943
** and update (uses a subset)
*/
4944
res_target_list2:  res_target_list2 ',' res_target_el2
4945 4946 4947 4948
				{	$$ = lappend($1, $3);  }
		| res_target_el2
				{	$$ = lcons($1, NIL);  }
		;
4949 4950

/* AS is not optional because shift/red conflict with unary ops */
4951
res_target_el2:  a_expr_or_null AS ColLabel
4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990
				{
					$$ = makeNode(ResTarget);
					$$->name = $3;
					$$->indirection = NULL;
					$$->val = (Node *)$1;
				}
		| a_expr_or_null
				{
					$$ = makeNode(ResTarget);
					$$->name = NULL;
					$$->indirection = NULL;
					$$->val = (Node *)$1;
				}
		| relation_name '.' '*'
				{
					Attr *att = makeNode(Attr);
					att->relname = $1;
					att->paramNo = NULL;
					att->attrs = lcons(makeString("*"), NIL);
					att->indirection = NIL;
					$$ = makeNode(ResTarget);
					$$->name = NULL;
					$$->indirection = NULL;
					$$->val = (Node *)att;
				}
		| '*'
				{
					Attr *att = makeNode(Attr);
					att->relname = "*";
					att->paramNo = NULL;
					att->attrs = NULL;
					att->indirection = NIL;
					$$ = makeNode(ResTarget);
					$$->name = NULL;
					$$->indirection = NULL;
					$$->val = (Node *)att;
				}
		;

4991
opt_id:  ColId									{ $$ = $1; }
4992
		| /*EMPTY*/								{ $$ = NULL; }
4993 4994 4995 4996 4997
		;

relation_name:	SpecialRuleRelation
				{
					$$ = $1;
4998
					StrNCpy(saved_relname, $1, NAMEDATALEN);
4999 5000 5001
				}
		| ColId
				{
5002
					/* disallow refs to variable system tables */
5003
					if (strcmp(LogRelationName, $1) == 0
5004
					   || strcmp(VariableRelationName, $1) == 0)
5005
						elog(ERROR,"%s cannot be accessed by users",$1);
5006 5007
					else
						$$ = $1;
5008
					StrNCpy(saved_relname, $1, NAMEDATALEN);
5009 5010 5011
				}
		;

5012
database_name:			ColId			{ $$ = $1; };
5013
access_method:			IDENT			{ $$ = $1; };
5014
attr_name:				ColId			{ $$ = $1; };
5015
class:					IDENT			{ $$ = $1; };
5016
index_name:				ColId			{ $$ = $1; };
5017

5018 5019 5020 5021 5022
/* Functions
 * Include date/time keywords as SQL92 extension.
 * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
 */
name:					ColId			{ $$ = $1; };
5023
func_name:				ColId			{ $$ = xlateSqlFunc($1); };
5024 5025

file_name:				Sconst			{ $$ = $1; };
Bruce Momjian's avatar
Bruce Momjian committed
5026
/* NOT USED recipe_name:			IDENT			{ $$ = $1; };*/
5027

5028 5029 5030
/* Constants
 * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
 */
5031
AexprConst:  Iconst
5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_Integer;
					n->val.val.ival = $1;
					$$ = (Node *)n;
				}
		| FCONST
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_Float;
					n->val.val.dval = $1;
					$$ = (Node *)n;
				}
		| Sconst
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = $1;
					$$ = (Node *)n;
				}
5052 5053 5054 5055 5056 5057 5058 5059
		| Typename Sconst
				{
					A_Const *n = makeNode(A_Const);
					n->typename = $1;
					n->val.type = T_String;
					n->val.val.str = $2;
					$$ = (Node *)n;
				}
5060 5061
		| ParamNo
				{	$$ = (Node *)$1;  }
5062 5063 5064 5065 5066
		| TRUE_P
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "t";
5067 5068
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
5069
					n->typename->typmod = -1;
5070 5071 5072 5073 5074 5075 5076
					$$ = (Node *)n;
				}
		| FALSE_P
				{
					A_Const *n = makeNode(A_Const);
					n->val.type = T_String;
					n->val.val.str = "f";
5077 5078
					n->typename = makeNode(TypeName);
					n->typename->name = xlateSqlType("bool");
5079
					n->typename->typmod = -1;
5080 5081
					$$ = (Node *)n;
				}
5082
		;
5083

5084
ParamNo:  PARAM opt_indirection
5085 5086 5087
				{
					$$ = makeNode(ParamNo);
					$$->number = $1;
5088
					$$->indirection = $2;
5089 5090
				}
		;
5091

5092 5093
Iconst:  ICONST							{ $$ = $1; };
Sconst:  SCONST							{ $$ = $1; };
5094
UserId:  IDENT							{ $$ = $1; };
5095

5096 5097 5098 5099 5100
/* Column and type identifier
 * Does not include explicit datetime types
 *  since these must be decoupled in Typename syntax.
 * Use ColId for most identifiers. - thomas 1997-10-21
 */
5101 5102 5103 5104 5105 5106 5107
TypeId:  ColId
			{	$$ = xlateSqlType($1); }
		| numeric
			{	$$ = xlateSqlType($1); }
		| character
			{	$$ = xlateSqlType($1); }
		;
5108 5109 5110
/* Column identifier
 * Include date/time keywords as SQL92 extension.
 * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
5111 5112 5113 5114
 * Add other keywords. Note that as the syntax expands,
 *  some of these keywords will have to be removed from this
 *  list due to shift/reduce conflicts in yacc. If so, move
 *  down to the ColLabel entity. - thomas 1997-11-06
5115
 */
5116
ColId:  IDENT							{ $$ = $1; }
5117
		| datetime						{ $$ = $1; }
5118
		| ABSOLUTE						{ $$ = "absolute"; }
5119
		| ACCESS						{ $$ = "access"; }
5120
		| ACTION						{ $$ = "action"; }
5121 5122 5123 5124
		| AFTER							{ $$ = "after"; }
		| AGGREGATE						{ $$ = "aggregate"; }
		| BACKWARD						{ $$ = "backward"; }
		| BEFORE						{ $$ = "before"; }
5125
		| CACHE							{ $$ = "cache"; }
5126
		| COMMITTED						{ $$ = "committed"; }
5127 5128
		| CREATEDB						{ $$ = "createdb"; }
		| CREATEUSER					{ $$ = "createuser"; }
5129
		| CYCLE							{ $$ = "cycle"; }
5130 5131
		| DATABASE						{ $$ = "database"; }
		| DELIMITERS					{ $$ = "delimiters"; }
5132 5133
		| DOUBLE						{ $$ = "double"; }
		| EACH							{ $$ = "each"; }
5134
		| ENCODING						{ $$ = "encoding"; }
5135
		| EXCLUSIVE						{ $$ = "exclusive"; }
5136
		| FORWARD						{ $$ = "forward"; }
5137
		| FUNCTION						{ $$ = "function"; }
5138
		| HANDLER						{ $$ = "handler"; }
5139
		| INCREMENT						{ $$ = "increment"; }
5140
		| INDEX							{ $$ = "index"; }
5141
		| INHERITS						{ $$ = "inherits"; }
5142
		| INSENSITIVE					{ $$ = "insensitive"; }
5143 5144
		| INSTEAD						{ $$ = "instead"; }
		| ISNULL						{ $$ = "isnull"; }
5145 5146
		| KEY							{ $$ = "key"; }
		| LANGUAGE						{ $$ = "language"; }
5147
		| LANCOMPILER					{ $$ = "lancompiler"; }
5148 5149
		| LOCATION						{ $$ = "location"; }
		| MATCH							{ $$ = "match"; }
5150 5151
		| MAXVALUE						{ $$ = "maxvalue"; }
		| MINVALUE						{ $$ = "minvalue"; }
5152
		| MODE							{ $$ = "mode"; }
5153
		| NEXT							{ $$ = "next"; }
5154 5155 5156 5157
		| NOCREATEDB					{ $$ = "nocreatedb"; }
		| NOCREATEUSER					{ $$ = "nocreateuser"; }
		| NOTHING						{ $$ = "nothing"; }
		| NOTNULL						{ $$ = "notnull"; }
5158
		| OF							{ $$ = "of"; }
5159
		| OIDS							{ $$ = "oids"; }
5160
		| ONLY							{ $$ = "only"; }
5161 5162
		| OPERATOR						{ $$ = "operator"; }
		| OPTION						{ $$ = "option"; }
5163
		| PASSWORD						{ $$ = "password"; }
5164
		| PRIOR							{ $$ = "prior"; }
5165
		| PRIVILEGES					{ $$ = "privileges"; }
5166
		| PROCEDURAL					{ $$ = "procedural"; }
5167 5168
		| READ							{ $$ = "read"; }
		| RELATIVE						{ $$ = "relative"; }
5169 5170
		| RENAME						{ $$ = "rename"; }
		| RETURNS						{ $$ = "returns"; }
5171
		| ROW							{ $$ = "row"; }
5172
		| RULE							{ $$ = "rule"; }
5173
		| SCROLL						{ $$ = "scroll"; }
5174
		| SEQUENCE						{ $$ = "sequence"; }
5175
		| SERIAL						{ $$ = "serial"; }
5176 5177
		| SERIALIZABLE					{ $$ = "serializable"; }
		| SHARE							{ $$ = "share"; }
5178
		| START							{ $$ = "start"; }
5179
		| STATEMENT						{ $$ = "statement"; }
5180 5181
		| STDIN							{ $$ = "stdin"; }
		| STDOUT						{ $$ = "stdout"; }
5182
		| TIME							{ $$ = "time"; }
5183
		| TIMESTAMP						{ $$ = "timestamp"; }
5184 5185
		| TIMEZONE_HOUR					{ $$ = "timezone_hour"; }
		| TIMEZONE_MINUTE				{ $$ = "timezone_minute"; }
5186
		| TRIGGER						{ $$ = "trigger"; }
5187
		| TRUSTED						{ $$ = "trusted"; }
5188
		| TYPE_P						{ $$ = "type"; }
5189
		| VALID							{ $$ = "valid"; }
5190 5191
		| VERSION						{ $$ = "version"; }
		| ZONE							{ $$ = "zone"; }
5192 5193 5194 5195 5196 5197 5198 5199
		;

/* Column label
 * Allowed labels in "AS" clauses.
 * Include TRUE/FALSE SQL3 reserved words for Postgres backward
 *  compatibility. Cannot allow this for column names since the
 *  syntax would not distinguish between the constant value and
 *  a column name. - thomas 1997-10-24
5200 5201 5202
 * Add other keywords to this list. Note that they appear here
 *  rather than in ColId if there was a shift/reduce conflict
 *  when used as a full identifier. - thomas 1997-11-06
5203 5204
 */
ColLabel:  ColId						{ $$ = $1; }
5205 5206 5207
		| ABORT_TRANS					{ $$ = "abort"; }
		| ANALYZE						{ $$ = "analyze"; }
		| BINARY						{ $$ = "binary"; }
5208
		| CASE							{ $$ = "case"; }
5209
		| CLUSTER						{ $$ = "cluster"; }
5210
		| COALESCE						{ $$ = "coalesce"; }
5211
		| CONSTRAINT					{ $$ = "constraint"; }
5212 5213 5214
		| COPY							{ $$ = "copy"; }
		| CURRENT						{ $$ = "current"; }
		| DO							{ $$ = "do"; }
5215 5216
		| ELSE							{ $$ = "else"; }
		| END_TRANS						{ $$ = "end"; }
5217 5218 5219
		| EXPLAIN						{ $$ = "explain"; }
		| EXTEND						{ $$ = "extend"; }
		| FALSE_P						{ $$ = "false"; }
5220
		| FOREIGN						{ $$ = "foreign"; }
5221
		| GLOBAL						{ $$ = "global"; }
5222
		| GROUP							{ $$ = "group"; }
5223
		| LISTEN						{ $$ = "listen"; }
5224
		| LOAD							{ $$ = "load"; }
5225
		| LOCAL							{ $$ = "local"; }
5226 5227 5228 5229
		| LOCK_P						{ $$ = "lock"; }
		| MOVE							{ $$ = "move"; }
		| NEW							{ $$ = "new"; }
		| NONE							{ $$ = "none"; }
5230
		| NULLIF						{ $$ = "nullif"; }
5231 5232 5233
		| ORDER							{ $$ = "order"; }
		| POSITION						{ $$ = "position"; }
		| PRECISION						{ $$ = "precision"; }
5234 5235 5236
		| RESET							{ $$ = "reset"; }
		| SETOF							{ $$ = "setof"; }
		| SHOW							{ $$ = "show"; }
5237
		| TABLE							{ $$ = "table"; }
5238
		| THEN							{ $$ = "then"; }
5239
		| TRANSACTION					{ $$ = "transaction"; }
5240
		| TRUE_P						{ $$ = "true"; }
5241 5242
		| VACUUM						{ $$ = "vacuum"; }
		| VERBOSE						{ $$ = "verbose"; }
5243
		| WHEN							{ $$ = "when"; }
5244
		;
5245 5246

SpecialRuleRelation:  CURRENT
5247 5248 5249 5250
				{
					if (QueryIsRule)
						$$ = "*CURRENT*";
					else
Bruce Momjian's avatar
Bruce Momjian committed
5251
						elog(ERROR,"CURRENT used in non-rule query");
5252 5253 5254 5255 5256 5257
				}
		| NEW
				{
					if (QueryIsRule)
						$$ = "*NEW*";
					else
Bruce Momjian's avatar
Bruce Momjian committed
5258
						elog(ERROR,"NEW used in non-rule query");
5259 5260
				}
		;
5261 5262 5263

%%

5264 5265
static Node *
makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
5266
{
5267 5268 5269 5270 5271 5272
	A_Expr *a = makeNode(A_Expr);
	a->oper = oper;
	a->opname = opname;
	a->lexpr = lexpr;
	a->rexpr = rexpr;
	return (Node *)a;
5273 5274
}

Bruce Momjian's avatar
Bruce Momjian committed
5275 5276
/* makeRowExpr()
 * Generate separate operator nodes for a single row descriptor expression.
5277 5278
 * Perhaps this should go deeper in the parser someday...
 * - thomas 1997-12-22
Bruce Momjian's avatar
Bruce Momjian committed
5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
 */
static Node *
makeRowExpr(char *opr, List *largs, List *rargs)
{
	Node *expr = NULL;
	Node *larg, *rarg;

	if (length(largs) != length(rargs))
		elog(ERROR,"Unequal number of entries in row expression");

	if (lnext(largs) != NIL)
		expr = makeRowExpr(opr,lnext(largs),lnext(rargs));

	larg = lfirst(largs);
	rarg = lfirst(rargs);

	if ((strcmp(opr, "=") == 0)
	 || (strcmp(opr, "<") == 0)
	 || (strcmp(opr, "<=") == 0)
	 || (strcmp(opr, ">") == 0)
	 || (strcmp(opr, ">=") == 0))
	{
		if (expr == NULL)
			expr = makeA_Expr(OP, opr, larg, rarg);
		else
			expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
	}
	else if (strcmp(opr, "<>") == 0)
	{
		if (expr == NULL)
			expr = makeA_Expr(OP, opr, larg, rarg);
		else
			expr = makeA_Expr(OR, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
	}
	else
	{
		elog(ERROR,"Operator '%s' not implemented for row expressions",opr);
	}

	return expr;
}

5321
static void
5322 5323 5324 5325 5326 5327
mapTargetColumns(List *src, List *dst)
{
	ColumnDef *s;
	ResTarget *d;

	if (length(src) != length(dst))
Bruce Momjian's avatar
Bruce Momjian committed
5328
		elog(ERROR,"CREATE TABLE/AS SELECT has mismatched column count");
5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342

	while ((src != NIL) && (dst != NIL))
	{
		s = (ColumnDef *)lfirst(src);
		d = (ResTarget *)lfirst(dst);

		d->name = s->colname;

		src = lnext(src);
		dst = lnext(dst);
	}

	return;
} /* mapTargetColumns() */
5343

5344 5345 5346
static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr)
{
	Node *result = NULL;
5347
	
5348
	/* we do this so indexes can be used */
5349 5350
	if (strcmp(opname,"~") == 0 ||
		strcmp(opname,"~*") == 0)
5351 5352 5353 5354 5355 5356 5357 5358 5359
	{
		if (nodeTag(rexpr) == T_A_Const &&
		   ((A_Const *)rexpr)->val.type == T_String &&
		   ((A_Const *)rexpr)->val.val.str[0] == '^')
		{
			A_Const *n = (A_Const *)rexpr;
			char *match_least = palloc(strlen(n->val.val.str)+2);
			char *match_most = palloc(strlen(n->val.val.str)+2);
			int pos, match_pos=0;
5360
			bool found_special = false;
5361

5362
			/* Cannot optimize if unquoted | { } is present in pattern */
5363 5364
			for (pos = 1; n->val.val.str[pos]; pos++)
			{
5365
				if (n->val.val.str[pos] == '|' ||
5366 5367
				    n->val.val.str[pos] == '{' ||
				    n->val.val.str[pos] == '}')
5368
				{
5369
					found_special = true;
5370 5371
					break;
				}
5372
		     	if (n->val.val.str[pos] == '\\')
5373
				{
5374
					pos++;
5375 5376 5377
					if (n->val.val.str[pos] == '\0')
						break;
				}
5378 5379
			}

5380
			if (!found_special)
5381
			{
5382
				/* note start at pos 1 to skip leading ^ */
5383 5384 5385 5386 5387 5388 5389 5390 5391 5392
				for (pos = 1; n->val.val.str[pos]; pos++)
				{
					if (n->val.val.str[pos] == '.' ||
						n->val.val.str[pos] == '?' ||
						n->val.val.str[pos] == '*' ||
						n->val.val.str[pos] == '[' ||
						n->val.val.str[pos] == '$' ||
						(strcmp(opname,"~*") == 0 && isalpha(n->val.val.str[pos])))
			     		break;
			     	if (n->val.val.str[pos] == '\\')
5393
					{
5394
						pos++;
5395 5396 5397
						if (n->val.val.str[pos] == '\0')
							break;
					}
5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414
					match_least[match_pos] = n->val.val.str[pos];
					match_most[match_pos++] = n->val.val.str[pos];
				}
	
				if (match_pos != 0)
				{
					A_Const *least = makeNode(A_Const);
					A_Const *most = makeNode(A_Const);
					
					/* make strings to be used in index use */
					match_least[match_pos] = '\0';
					match_most[match_pos] = '\377';
					match_most[match_pos+1] = '\0';
					least->val.type = T_String;
					least->val.val.str = match_least;
					most->val.type = T_String;
					most->val.val.str = match_most;
Bruce Momjian's avatar
Bruce Momjian committed
5415
#ifdef USE_LOCALE
5416 5417 5418
					result = makeA_Expr(AND, NULL,
							makeA_Expr(OP, "~", lexpr, rexpr),
							makeA_Expr(OP, ">=", lexpr, (Node *)least));
Bruce Momjian's avatar
Bruce Momjian committed
5419
#else
5420 5421 5422 5423 5424
					result = makeA_Expr(AND, NULL,
							makeA_Expr(OP, "~", lexpr, rexpr),
							makeA_Expr(AND, NULL,
								makeA_Expr(OP, ">=", lexpr, (Node *)least),
								makeA_Expr(OP, "<=", lexpr, (Node *)most)));
Bruce Momjian's avatar
Bruce Momjian committed
5425
#endif
5426
				}
5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441
			}
		}
	}
	else if (strcmp(opname,"~~") == 0)
	{
		if (nodeTag(rexpr) == T_A_Const &&
		   ((A_Const *)rexpr)->val.type == T_String)
		{
			A_Const *n = (A_Const *)rexpr;
			char *match_least = palloc(strlen(n->val.val.str)+2);
			char *match_most = palloc(strlen(n->val.val.str)+2);
			int pos, match_pos=0;
	
			for (pos = 0; n->val.val.str[pos]; pos++)
			{
5442 5443 5444
				/* % and _ are wildcard characters in LIKE */
				if (n->val.val.str[pos] == '%' ||
					n->val.val.str[pos] == '_')
5445
					break;
5446 5447 5448
				/* Backslash quotes the next character */
				if (n->val.val.str[pos] == '\\')
				{
5449
					pos++;
5450 5451 5452 5453 5454 5455 5456 5457
					if (n->val.val.str[pos] == '\0')
						break;
				}
				/*
				 * NOTE: this code used to think that %% meant a literal %,
				 * but textlike() itself does not think that, and the SQL92
				 * spec doesn't say any such thing either.
				 */
5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474
				match_least[match_pos] = n->val.val.str[pos];
				match_most[match_pos++] = n->val.val.str[pos];
			}
	
			if (match_pos != 0)
			{
				A_Const *least = makeNode(A_Const);
				A_Const *most = makeNode(A_Const);
				
				/* make strings to be used in index use */
				match_least[match_pos] = '\0';
				match_most[match_pos] = '\377';
				match_most[match_pos+1] = '\0';
				least->val.type = T_String;
				least->val.val.str = match_least;
				most->val.type = T_String;
				most->val.val.str = match_most;
Bruce Momjian's avatar
Bruce Momjian committed
5475 5476 5477 5478 5479
#ifdef USE_LOCALE
				result = makeA_Expr(AND, NULL,
						makeA_Expr(OP, "~~", lexpr, rexpr),
						makeA_Expr(OP, ">=", lexpr, (Node *)least));
#else
5480 5481 5482 5483 5484
				result = makeA_Expr(AND, NULL,
						makeA_Expr(OP, "~~", lexpr, rexpr),
						makeA_Expr(AND, NULL,
							makeA_Expr(OP, ">=", lexpr, (Node *)least),
							makeA_Expr(OP, "<=", lexpr, (Node *)most)));
Bruce Momjian's avatar
Bruce Momjian committed
5485
#endif
5486 5487 5488 5489 5490 5491 5492
			}
		}
	}
	
	if (result == NULL)
		result = makeA_Expr(OP, opname, lexpr, rexpr);
	return result;
5493
} /* makeIndexable() */
5494 5495


5496
/* xlateSqlFunc()
5497
 * Convert alternate type names to internal Postgres types.
5498 5499
 * Do not convert "float", since that is handled elsewhere
 *  for FLOAT(p) syntax.
5500
 */
5501
static char *
5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514
xlateSqlFunc(char *name)
{
	if (!strcasecmp(name,"character_length")
	 || !strcasecmp(name,"char_length"))
		return "length";
	else
		return name;
} /* xlateSqlFunc() */

/* xlateSqlType()
 * Convert alternate type names to internal Postgres types.
 */
static char *
5515 5516
xlateSqlType(char *name)
{
5517 5518
	if (!strcasecmp(name,"int")
	 || !strcasecmp(name,"integer"))
5519
		return "int4";
5520 5521
	else if (!strcasecmp(name, "smallint"))
		return "int2";
5522 5523
	else if (!strcasecmp(name, "real")
	 || !strcasecmp(name, "float"))
5524 5525 5526
		return "float8";
	else if (!strcasecmp(name, "interval"))
		return "timespan";
5527 5528
	else if (!strcasecmp(name, "boolean"))
		return "bool";
5529 5530
	else
		return name;
5531
} /* xlateSqlType() */
5532

5533

5534 5535
void parser_init(Oid *typev, int nargs)
{
5536
	QueryIsRule = FALSE;
5537 5538
	saved_relname[0]= '\0';
	saved_In_Expr = NULL;
5539

5540
	param_type_init(typev, nargs);
5541
}
5542

5543

5544 5545 5546
/* FlattenStringList()
 * Traverse list of string nodes and convert to a single string.
 * Used for reconstructing string form of complex expressions.
5547 5548
 *
 * Allocate at least one byte for terminator.
5549 5550 5551 5552
 */
static char *
FlattenStringList(List *list)
{
5553 5554
	List *l;
	Value *v;
5555 5556
	char *s;
	char *sp;
5557
	int nlist, len = 0;
5558 5559 5560 5561

	nlist = length(list);
	l = list;
	while(l != NIL) {
5562 5563
		v = (Value *)lfirst(l);
		sp = v->val.str;
5564
		l = lnext(l);
5565
		len += strlen(sp);
5566
	};
5567
	len += nlist;
5568

5569
	s = (char*) palloc(len+1);
5570 5571 5572 5573
	*s = '\0';

	l = list;
	while(l != NIL) {
5574 5575
		v = (Value *)lfirst(l);
		sp = v->val.str;
5576 5577
		l = lnext(l);
		strcat(s,sp);
5578
		if (l != NIL) strcat(s," ");
5579
	};
5580
	*(s+len) = '\0';
5581

5582
	return s;
5583 5584
} /* FlattenStringList() */

5585

5586 5587 5588 5589 5590 5591
/* makeConstantList()
 * Convert constant value node into string node.
 */
static List *
makeConstantList( A_Const *n)
{
5592 5593
	List *result = NIL;
	char *typval = NULL;
5594
	char *defval = NULL;
5595

5596
	if (nodeTag(n) != T_A_Const) {
Bruce Momjian's avatar
Bruce Momjian committed
5597
		elog(ERROR,"Cannot handle non-constant parameter");
5598 5599 5600 5601

	} else if (n->val.type == T_Float) {
		defval = (char*) palloc(20+1);
		sprintf( defval, "%g", n->val.val.dval);
5602
		result = lcons( makeString(defval), NIL);
5603 5604 5605 5606

	} else if (n->val.type == T_Integer) {
		defval = (char*) palloc(20+1);
		sprintf( defval, "%ld", n->val.val.ival);
5607
		result = lcons( makeString(defval), NIL);
5608 5609 5610 5611 5612 5613

	} else if (n->val.type == T_String) {
		defval = (char*) palloc(strlen( ((A_Const *) n)->val.val.str) + 3);
		strcpy( defval, "'");
		strcat( defval, ((A_Const *) n)->val.val.str);
		strcat( defval, "'");
5614 5615 5616 5617 5618 5619 5620 5621 5622 5623
		if (n->typename != NULL)
		{
			typval = (char*) palloc(strlen( n->typename->name) + 1);
			strcpy(typval, n->typename->name);
			result = lappend( lcons( makeString(typval), NIL), makeString(defval));
		}
		else
		{
			result = lcons( makeString(defval), NIL);
		}
5624 5625

	} else {
Bruce Momjian's avatar
Bruce Momjian committed
5626
		elog(ERROR,"Internal error in makeConstantList(): cannot encode node");
5627 5628
	};

5629
	return result;
5630
} /* makeConstantList() */
5631

5632

5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
/* fmtId()
 * Check input string for non-lowercase/non-numeric characters.
 * Returns either input string or input surrounded by double quotes.
 */
static char *
fmtId(char *rawid)
{
	static char *cp;

	for (cp = rawid; *cp != '\0'; cp++)
		if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;

	if (*cp != '\0') {
5646
		cp = palloc(strlen(rawid)+3);
5647 5648 5649 5650 5651 5652 5653
		strcpy(cp,"\"");
		strcat(cp,rawid);
		strcat(cp,"\"");
	} else {
		cp = rawid;
	};

5654
	return cp;
5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675
}

/*
 * param_type_init()
 *
 * keep enough information around fill out the type of param nodes
 * used in postquel functions
 */
static void
param_type_init(Oid *typev, int nargs)
{
	pfunc_num_args = nargs;
	param_type_info = typev;
}

Oid param_type(int t)
{
	if ((t > pfunc_num_args) || (t == 0))
		return InvalidOid;
	return param_type_info[t - 1];
}
5676 5677

/*
Bruce Momjian's avatar
Bruce Momjian committed
5678 5679 5680
 *	The optimizer doesn't like '-' 4 for index use.  It only checks for
 *	Var '=' Const.  It wants an integer of -4, so we try to merge the
 *	minus into the constant.
5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701
 */
static Node *doNegate(Node *n)
{
	if (IsA(n, A_Const))
	{
		A_Const *con = (A_Const *)n;

		if (con->val.type == T_Integer)
		{
			con->val.val.ival = -con->val.val.ival;
			return n;
		}
		if (con->val.type == T_Float)
		{
			con->val.val.dval = -con->val.val.dval;
			return n;
		}
	}

	return makeA_Expr(OP, "-", NULL, n);
}