upstream/postgresql
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2026-02-17 01:31:07 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
postgresql/src/include/parser/parse_clause.h

47 lines
1.8 KiB
C
Raw Normal View History

Break parser functions into smaller files, group together.
1997-11-25 17:07:18 -05:00
/*-------------------------------------------------------------------------
*
* parse_clause.h
Adjust subquery qual pushdown rules to be more forgiving: if a qual refers to a non-DISTINCT output column of a DISTINCT ON subquery, or if it refers to a function-returning-set, we cannot push it down. But the old implementation refused to push down *any* quals if the subquery had any such 'dangerous' outputs. Now we just look at the output columns actually referenced by each qual expression. More code than before, but probably no slower since we don't make unnecessary checks.
2003-03-21 20:49:38 -05:00
* handle clauses in parser
Break parser functions into smaller files, group together.
1997-11-25 17:07:18 -05:00
*
*
Update copyrights to 2003.
2003-08-03 22:40:20 -04:00
* Portions Copyright (c) 1996-2003, 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
*
Still another place to make the world safe for zero-column tables: remove the ancient (and always pretty dodgy) assumption in parse_clause.c that a query can't have an empty targetlist.
2004-05-23 13:10:54 -04:00
* $PostgreSQL: pgsql/src/include/parser/parse_clause.h,v 1.41 2004/05/23 17:10:54 tgl Exp $
Break parser functions into smaller files, group together.
1997-11-25 17:07:18 -05:00
*
*-------------------------------------------------------------------------
*/
#ifndef PARSE_CLAUSE_H
#define PARSE_CLAUSE_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
Change scoping of table and join refnames to conform to SQL92: a JOIN clause with an alias is a <subquery> and therefore hides table references appearing within it, according to the spec. This is the same as the preliminary patch I posted to pgsql-patches yesterday, plus some really grotty code in ruleutils.c to reverse-list a query tree with the correct alias name depending on context. I'd rather not have done that, but unless we want to force another initdb for 7.1, there's no other way for now.
2001-02-14 16:35:07 -05:00
extern void transformFromClause(ParseState *pstate, List *frmList);
A little further progress on schemas: push down RangeVars into addRangeTableEntry calls. Remove relname field from RTEs, since it will no longer be a useful unique identifier of relations; we want to encourage people to rely on the relation OID instead. Further work on dumping qual expressions in EXPLAIN, too.
2002-03-21 21:56:37 -05:00
extern int setTargetTable(ParseState *pstate, RangeVar *relation,
Fix permission-checking bug reported by Tim Burgess 10-Feb-03 (this time for sure...). Rather than relying on the query context of a rangetable entry to identify what permissions it wants checked, store a full AclMode mask in each RTE, and check exactly those bits. This allows an RTE specifying, say, INSERT privilege on a view to be copied into a derived UPDATE query without changing meaning. Per recent discussion thread. initdb forced due to change of stored rule representation.
2004-01-14 18:01:55 -05:00
bool inh, bool alsoSource, AclMode requiredPerms);
Remove not-really-standard implementation of CREATE TABLE's UNDER clause, and revert documentation to describe the existing INHERITS clause instead, per recent discussion in pghackers. Also fix implementation of SQL_inheritance SET variable: it is not cool to look at this var during the initial parsing phase, only during parse_analyze(). See recent bug report concerning misinterpretation of date constants just after a SET TIMEZONE command. gram.y really has to be an invariant transformation of the query string to a raw parsetree; anything that can vary with time must be done during parse analysis.
2001-01-05 01:34:23 -05:00
extern bool interpretInhOption(InhOption inhOpt);
Fix a minor bug introduced by the recent CREATE TABLE AS / WITH OIDS patch: a 3-value enum was mistakenly assigned directly to a 'bool' in transformCreateStmt(). Along the way, change makeObjectName() to be static, as it isn't used outside analyze.c
2004-01-22 21:13:12 -05:00
extern bool interpretOidsOption(ContainsOids opt);
Allow GROUP BY, ORDER BY, DISTINCT targets to be unknown literals, silently resolving them to type TEXT. This is comparable to what we do when faced with UNKNOWN in CASE, UNION, and other contexts. It gets rid of this and related annoyances: select distinct f1, '' from int4_tbl; ERROR: Unable to identify an ordering operator '<' for type unknown This was discussed many moons ago, but no one got round to fixing it.
2003-06-15 22:03:38 -04:00
Do honest transformation and preprocessing of LIMIT/OFFSET clauses, instead of the former kluge whereby gram.y emitted already-transformed expressions. This is needed so that Params appearing in these clauses actually work correctly. I suppose some might claim that the side effect of 'SELECT ... LIMIT 2+2' working is a new feature, but I say this is a bug fix.
2003-07-03 15:07:54 -04:00
extern Node *transformWhereClause(ParseState *pstate, Node *clause,
pgindent run.
2003-08-03 20:43:34 -04:00
const char *constructName);
Do honest transformation and preprocessing of LIMIT/OFFSET clauses, instead of the former kluge whereby gram.y emitted already-transformed expressions. This is needed so that Params appearing in these clauses actually work correctly. I suppose some might claim that the side effect of 'SELECT ... LIMIT 2+2' working is a new feature, but I say this is a bug fix.
2003-07-03 15:07:54 -04:00
extern Node *transformLimitClause(ParseState *pstate, Node *clause,
pgindent run.
2003-08-03 20:43:34 -04:00
const char *constructName);
OK, folks, here is the pgindent output.
1998-09-01 00:40:42 -04:00
extern List *transformGroupClause(ParseState *pstate, List *grouplist,
Still another place to make the world safe for zero-column tables: remove the ancient (and always pretty dodgy) assumption in parse_clause.c that a query can't have an empty targetlist.
2004-05-23 13:10:54 -04:00
List **targetlist, List *sortClause);
Major revision of sort-node handling: push knowledge of query sort order down into planner, instead of handling it only at the very top level of the planner. This fixes many things. An explicit sort is now avoided if there is a cheaper alternative (typically an indexscan) not only for ORDER BY, but also for the internal sort of GROUP BY. It works even when there is no other reason (such as a WHERE condition) to consider the indexscan. It works for indexes on functions. It works for indexes on functions, backwards. It's just so cool... CAUTION: I have changed the representation of SortClause nodes, therefore THIS UPDATE BREAKS STORED RULES. You will need to initdb.
1999-08-20 23:49:17 -04:00
extern List *transformSortClause(ParseState *pstate, List *orderlist,
Still another place to make the world safe for zero-column tables: remove the ancient (and always pretty dodgy) assumption in parse_clause.c that a query can't have an empty targetlist.
2004-05-23 13:10:54 -04:00
List **targetlist, bool resolveUnknown);
Redesign DISTINCT ON as discussed in pgsql-sql 1/25/00: syntax is now SELECT DISTINCT ON (expr [, expr ...]) targetlist ... and there is a check to make sure that the user didn't specify an ORDER BY that's incompatible with the DISTINCT operation. Reimplement nodeUnique and nodeGroup to use the proper datatype-specific equality function for each column being compared --- they used to do bitwise comparisons or convert the data to text strings and strcmp(). (To add insult to injury, they'd look up the conversion functions once for each tuple...) Parse/plan representation of DISTINCT is now a list of SortClause nodes. initdb forced by querytree change...
2000-01-27 13:11:50 -05:00
extern List *transformDistinctClause(ParseState *pstate, List *distinctlist,
Still another place to make the world safe for zero-column tables: remove the ancient (and always pretty dodgy) assumption in parse_clause.c that a query can't have an empty targetlist.
2004-05-23 13:10:54 -04:00
List **targetlist, List **sortClause);
Major revision of sort-node handling: push knowledge of query sort order down into planner, instead of handling it only at the very top level of the planner. This fixes many things. An explicit sort is now avoided if there is a cheaper alternative (typically an indexscan) not only for ORDER BY, but also for the internal sort of GROUP BY. It works even when there is no other reason (such as a WHERE condition) to consider the indexscan. It works for indexes on functions. It works for indexes on functions, backwards. It's just so cool... CAUTION: I have changed the representation of SortClause nodes, therefore THIS UPDATE BREAKS STORED RULES. You will need to initdb.
1999-08-20 23:49:17 -04:00
Allow GROUP BY, ORDER BY, DISTINCT targets to be unknown literals, silently resolving them to type TEXT. This is comparable to what we do when faced with UNKNOWN in CASE, UNION, and other contexts. It gets rid of this and related annoyances: select distinct f1, '' from int4_tbl; ERROR: Unable to identify an ordering operator '<' for type unknown This was discussed many moons ago, but no one got round to fixing it.
2003-06-15 22:03:38 -04:00
extern List *addAllTargetsToSortList(ParseState *pstate,
pgindent run.
2003-08-03 20:43:34 -04:00
List *sortlist, List *targetlist,
bool resolveUnknown);
create_unique_plan() should not discard existing output columns of the subplan it starts with, as they may be needed at upper join levels. See comments added to code for the non-obvious reason why. Per bug report from Robert Creager.
2003-08-07 15:20:24 -04:00
extern List *addTargetToSortList(ParseState *pstate, TargetEntry *tle,
List *sortlist, List *targetlist,
Create a 'type cache' that keeps track of the data needed for any particular datatype by array_eq and array_cmp; use this to solve problems with memory leaks in array indexing support. The parser's equality_oper and ordering_oper routines also use the cache. Change the operator search algorithms to look for appropriate btree or hash index opclasses, instead of assuming operators named '<' or '=' have the right semantics. (ORDER BY ASC/DESC now also look at opclasses, instead of assuming '<' and '>' are the right things.) Add several more index opclasses so that there is no regression in functionality for base datatypes. initdb forced due to catalog additions.
2003-08-17 15:58:06 -04:00
int sortby_kind, List *sortby_opname,
bool resolveUnknown);
Major revision of sort-node handling: push knowledge of query sort order down into planner, instead of handling it only at the very top level of the planner. This fixes many things. An explicit sort is now avoided if there is a cheaper alternative (typically an indexscan) not only for ORDER BY, but also for the internal sort of GROUP BY. It works even when there is no other reason (such as a WHERE condition) to consider the indexscan. It works for indexes on functions. It works for indexes on functions, backwards. It's just so cool... CAUTION: I have changed the representation of SortClause nodes, therefore THIS UPDATE BREAKS STORED RULES. You will need to initdb.
1999-08-20 23:49:17 -04:00
extern Index assignSortGroupRef(TargetEntry *tle, List *tlist);
Adjust subquery qual pushdown rules to be more forgiving: if a qual refers to a non-DISTINCT output column of a DISTINCT ON subquery, or if it refers to a function-returning-set, we cannot push it down. But the old implementation refused to push down *any* quals if the subquery had any such 'dangerous' outputs. Now we just look at the output columns actually referenced by each qual expression. More code than before, but probably no slower since we don't make unnecessary checks.
2003-03-21 20:49:38 -05:00
extern bool targetIsInSortList(TargetEntry *tle, List *sortList);
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_CLAUSE_H */
Reference in a new issue Copy permalink