postgresql/src/include/parser/parse_expr.h

/*-------------------------------------------------------------------------
 *
 * parse_expr.h
 *	  handle expressions in parser
 *
 * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/parser/parse_expr.h
 *
 *-------------------------------------------------------------------------
 */
#ifndef PARSE_EXPR_H
#define PARSE_EXPR_H

#include "parser/parse_node.h"

/* GUC parameters */
extern bool operator_precedence_warning;
extern bool Transform_null_equals;

extern Node *transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind);

extern const char *ParseExprKindName(ParseExprKind exprKind);

#endif   /* PARSE_EXPR_H */
Break parser functions into smaller files, group together. 1997-11-25 17:07:18 -05:00			`/*-------------------------------------------------------------------------`
			`*`
Rewrite parser's handling of INSERT ... SELECT so that processing of the SELECT part of the statement is just like a plain SELECT. All INSERT-specific processing happens after the SELECT parsing is done. This eliminates many problems, e.g. INSERT ... SELECT ... GROUP BY using the wrong column labels. Ensure that DEFAULT clauses are coerced to the target column type, whether or not stored clause produces the right type. Substantial cleanup of parser's array support. 1999-07-18 20:26:20 -04:00			`* parse_expr.h`
Move exprType(), exprTypmod(), expression_tree_walker(), and related routines into nodes/nodeFuncs, so as to reduce wanton cross-subsystem #includes inside the backend. There's probably more that should be done along this line, but this is a start anyway. 2008-08-25 18:42:34 -04:00			`* handle expressions in parser`
Break parser functions into smaller files, group together. 1997-11-25 17:07:18 -05:00			`*`
Update copyright via script for 2017 2017-01-03 13:48:53 -05:00			`* Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group`
Add: * Portions Copyright (c) 1996-2000, PostgreSQL, Inc to all files copyright Regents of Berkeley. Man, that's a lot of files. 2000-01-26 00:58:53 -05:00			`* Portions Copyright (c) 1994, Regents of the University of California`
Break parser functions into smaller files, group together. 1997-11-25 17:07:18 -05:00			`*`
Remove cvs keywords from all files. 2010-09-20 16:08:53 -04:00			`* src/include/parser/parse_expr.h`
Break parser functions into smaller files, group together. 1997-11-25 17:07:18 -05:00			`*`
			`*-------------------------------------------------------------------------`
			`*/`
			`#ifndef PARSE_EXPR_H`
			`#define PARSE_EXPR_H`

Change #include's to use <> and "" as appropriate. 1999-07-15 19:04:24 -04:00			`#include "parser/parse_node.h"`
Break parser functions into smaller files, group together. 1997-11-25 17:07:18 -05:00
First phase of SCHEMA changes, concentrating on fixing the grammar and the parsetree representation. As yet we don't do anything with schema names, just drop 'em on the floor; but you can enter schema-compatible command syntax, and there's even a primitive CREATE SCHEMA command. No doc updates yet, except to note that you can now extract a field from a function-returning-row's result with (foo(...)).fieldname. 2002-03-21 11:02:16 -05:00			`/* GUC parameters */`
Make operator precedence follow the SQL standard more closely. While the SQL standard is pretty vague on the overall topic of operator precedence (because it never presents a unified BNF for all expressions), it does seem reasonable to conclude from the spec for <boolean value expression> that OR has the lowest precedence, then AND, then NOT, then IS tests, then the six standard comparison operators, then everything else (since any non-boolean operator in a WHERE clause would need to be an argument of one of these). We were only sort of on board with that: most notably, while "<" ">" and "=" had properly low precedence, "<=" ">=" and "<>" were treated as generic operators and so had significantly higher precedence. And "IS" tests were even higher precedence than those, which is very clearly wrong per spec. Another problem was that "foo NOT SOMETHING bar" constructs, such as "x NOT LIKE y", were treated inconsistently because of a bison implementation artifact: they had the documented precedence with respect to operators to their right, but behaved like NOT (i.e., very low priority) with respect to operators to their left. Fixing the precedence issues is just a small matter of rearranging the precedence declarations in gram.y, except for the NOT problem, which requires adding an additional lookahead case in base_yylex() so that we can attach a different token precedence to NOT LIKE and allied two-word operators. The bulk of this patch is not the bug fix per se, but adding logic to parse_expr.c to allow giving warnings if an expression has changed meaning because of these precedence changes. These warnings are off by default and are enabled by the new GUC operator_precedence_warning. It's believed that very few applications will be affected by these changes, but it was agreed that a warning mechanism is essential to help debug any that are. 2015-03-11 13:22:52 -04:00			`extern bool operator_precedence_warning;`
Provide tunable knob for x = NULL -> x IS NULL transformation, default to off. 2001-09-20 10:20:28 -04:00			`extern bool Transform_null_equals;`
Add safety check on expression nesting depth. Default value is set by a config.h #define, and the runtime value can be controlled via SET. 2000-03-17 00:29:07 -05:00
Centralize the logic for detecting misplaced aggregates, window funcs, etc. Formerly we relied on checking after-the-fact to see if an expression contained aggregates, window functions, or sub-selects when it shouldn't. This is grotty, easily forgotten (indeed, we had forgotten to teach DefineIndex about rejecting window functions), and none too efficient since it requires extra traversals of the parse tree. To improve matters, define an enum type that classifies all SQL sub-expressions, store it in ParseState to show what kind of expression we are currently parsing, and make transformAggregateCall, transformWindowFuncCall, and transformSubLink check the expression type and throw error if the type indicates the construct is disallowed. This allows removal of a large number of ad-hoc checks scattered around the code base. The enum type is sufficiently fine-grained that we can still produce error messages of at least the same specificity as before. Bringing these error checks together revealed that we'd been none too consistent about phrasing of the error messages, so standardize the wording a bit. Also, rewrite checking of aggregate arguments so that it requires only one traversal of the arguments, rather than up to three as before. In passing, clean up some more comments left over from add_missing_from support, and annotate some tests that I think are dead code now that that's gone. (I didn't risk actually removing said dead code, though.) 2012-08-10 11:35:33 -04:00			`extern Node transformExpr(ParseState pstate, Node *expr, ParseExprKind exprKind);`

			`extern const char *ParseExprKindName(ParseExprKind exprKind);`
Another pgindent run. Fixes enum indenting, and improves #endif spacing. Also adds space for one-line comments. 2001-10-28 01:26:15 -05:00
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass. 2001-11-05 12:46:40 -05:00			`#endif /* PARSE_EXPR_H */`