upstream/postgresql
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2026-03-27 04:44:15 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
postgresql/src/include/optimizer/clauses.h

89 lines
3.1 KiB
C
Raw Normal View History

Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*-------------------------------------------------------------------------
*
Change my-function-name-- to my_function_name, and optimizer renames.
1999-02-13 18:22:53 -05:00
* clauses.h
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 01:04:48 -04:00
* prototypes for clauses.c.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04: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
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*
Adjust the definition of RestrictInfo's left_relids and right_relids fields: now they are valid whenever the clause is a binary opclause, not only when it is a potential join clause (there is a new boolean field canjoin to signal the latter condition). This lets us avoid recomputing the relid sets over and over while examining indexes. Still more work to do to make this as useful as it could be, because there are places that could use the info but don't have access to the RestrictInfo node.
2003-12-30 18:53:15 -05:00
* $PostgreSQL: pgsql/src/include/optimizer/clauses.h,v 1.70 2003/12/30 23:53:15 tgl Exp $
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*
*-------------------------------------------------------------------------
*/
#ifndef CLAUSES_H
#define CLAUSES_H
Change #include's to use <> and "" as appropriate.
1999-07-15 19:04:24 -04:00
#include "nodes/relation.h"
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
Create a generic expression-tree-walker subroutine, which will gradually replace all of the boilerplate tree-walk-recursion code that currently exists in O(N) slightly different forms in N subroutines. I've had it with adding missing cases to these subroutines...
1999-06-18 23:41:45 -04:00
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 10:49:42 -05:00
#define is_opclause(clause) ((clause) != NULL && IsA(clause, OpExpr))
#define is_funcclause(clause) ((clause) != NULL && IsA(clause, FuncExpr))
Clean up plantree representation of SubPlan-s --- SubLink does not appear in the planned representation of a subplan at all any more, only SubPlan. This means subselect.c doesn't scribble on its input anymore, which seems like a good thing; and there are no longer three different possible interpretations of a SubLink. Simplify node naming and improve comments in primnodes.h. No change to stored rules, though.
2002-12-13 19:17:59 -05:00
#define is_subplan(clause) ((clause) != NULL && IsA(clause, SubPlan))
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 10:49:42 -05:00
extern Expr *make_opclause(Oid opno, Oid opresulttype, bool opretset,
pgindent run.
2003-08-03 20:43:34 -04:00
Expr *leftop, Expr *rightop);
Allow merge and hash joins to occur on arbitrary expressions (anything not containing a volatile function), rather than only on 'Var = Var' clauses as before. This makes it practical to do flatten_join_alias_vars at the start of planning, which in turn eliminates a bunch of klugery inside the planner to deal with alias vars. As a free side effect, we now detect implied equality of non-Var expressions; for example in SELECT ... WHERE a.x = b.y and b.y = 42 we will deduce a.x = 42 and use that as a restriction qual on a. Also, we can remove the restriction introduced 12/5/02 to prevent pullup of subqueries whose targetlists contain sublinks. Still TODO: make statistical estimation routines in selfuncs.c and costsize.c smarter about expressions that are more complex than plain Vars. The need for this is considerably greater now that we have to be able to estimate the suitability of merge and hash join techniques on such expressions.
2003-01-15 14:35:48 -05:00
extern Node *get_leftop(Expr *clause);
extern Node *get_rightop(Expr *clause);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern bool not_clause(Node *clause);
extern Expr *make_notclause(Expr *notclause);
extern Expr *get_notclausearg(Expr *notclause);
Phase 2 of read-only-plans project: restructure expression-tree nodes so that all executable expression nodes inherit from a common supertype Expr. This is somewhat of an exercise in code purity rather than any real functional advance, but getting rid of the extra Oper or Func node formerly used in each operator or function call should provide at least a little space and speed improvement. initdb forced by changes in stored-rules representation.
2002-12-12 10:49:42 -05:00
extern bool or_clause(Node *clause);
extern Expr *make_orclause(List *orclauses);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern bool and_clause(Node *clause);
extern Expr *make_andclause(List *andclauses);
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 14:21:41 -04:00
extern Node *make_and_qual(Node *qual1, Node *qual2);
Clean up messy clause-selectivity code in clausesel.c; repair bug identified by Hiroshi (incorrect cost attributed to OR clauses after multiple passes through set_rest_selec()). I think the code was trying to allow selectivities of OR subclauses to be passed in from outside, but noplace was actually passing any useful data, and set_rest_selec() was passing wrong data. Restructure representation of "indexqual" in IndexPath nodes so that it is the same as for indxqual in completed IndexScan nodes: namely, a toplevel list with an entry for each pass of the index scan, having sublists that are implicitly-ANDed index qual conditions for that pass. You don't want to know what the old representation was :-( Improve documentation of OR-clause indexscan functions. Remove useless 'notclause' field from RestrictInfo nodes. (This might force an initdb for anyone who has stored rules containing RestrictInfos, but I do not think that RestrictInfo ever appears in completed plans.)
1999-07-24 19:21:14 -04:00
extern Expr *make_ands_explicit(List *andclauses);
First cut at doing LIKE/regex indexing optimization in optimizer rather than parser. This has many advantages, such as not getting fooled by chance uses of operator names ~ and ~~ (the operators are identified by OID now), and not creating useless comparison operations in contexts where the comparisons will not actually be used as indexquals. The new code also recognizes exact-match LIKE and regex patterns, and produces an = indexqual instead of >= and <=. This change does NOT fix the problem with non-ASCII locales: the code still doesn't know how to generate an upper bound indexqual for non-ASCII collation order. But it's no worse than before, just the same deficiency in a different place... Also, dike out loc_restrictinfo fields in Plan nodes. These were doing nothing useful in the absence of 'expensive functions' optimization, and they took a considerable amount of processing to fill in.
1999-07-26 23:51:11 -04:00
extern List *make_ands_implicit(Expr *clause);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
aggregate(DISTINCT ...) works, per SQL spec. Note this forces initdb because of change of Aggref node in stored rules.
1999-12-12 20:27:21 -05:00
extern bool contain_agg_clause(Node *clause);
Phase 2 of hashed-aggregation project. nodeAgg.c now knows how to do hashed aggregation, but there's not yet planner support for it.
2002-11-06 17:31:24 -05:00
extern bool contain_distinct_agg_clause(Node *clause);
Minor code cleanup: remove no-longer-useful pull_subplans() function, and convert pull_agg_clause() into count_agg_clause(), which is a more efficient way of doing what it's really being used for.
2003-02-03 19:50:01 -05:00
extern int count_agg_clause(Node *clause);
Fix extremely nasty little bug observed when a sub-SELECT appears in WHERE in a place where it can be part of a nestloop inner indexqual. As the code stood, it put the same physical sub-Plan node into both indxqual and indxqualorig of the IndexScan plan node. That confused later processing in the optimizer (which expected that tracing the subPlan list would visit each subplan node exactly once), and would probably have blown up in the executor if the planner hadn't choked first. Fix by making the 'fixed' indexqual be a complete deep copy of the original indexqual, rather than trying to share nodes below the topmost operator node. This had further ramifications though, because we were making the aforesaid list of sub-Plan nodes during SS_process_sublinks which is run before construction of the 'fixed' indexqual, meaning that the copy of the sub-Plan didn't show up in that list. Fix by rearranging logic so that the sub-Plan list is built by the final set_plan_references pass, not in SS_process_sublinks. This may sound like a mess, but it's actually a good deal cleaner now than it was before, because we are no longer dependent on the assumption that planning will never make a copy of a sub-Plan node.
2000-04-03 21:21:48 -04:00
Get rid of long-since-vestigial Iter node type, in favor of adding a returns-set boolean field in Func and Oper nodes. This allows cleaner, more reliable tests for expressions returning sets in the planner and parser. For example, a WHERE clause returning a set is now detected and complained of in the parser, not only at runtime.
2002-05-12 19:43:04 -04:00
extern bool expression_returns_set(Node *clause);
Suppress subquery pullup and pushdown when the subquery has any set-returning functions in its target list. This ensures that we won't rewrite the query in a way that places set-returning functions into quals (WHERE clauses). Cf. bug reports from Joe Conway.
2001-12-10 17:54:12 -05:00
Fix extremely nasty little bug observed when a sub-SELECT appears in WHERE in a place where it can be part of a nestloop inner indexqual. As the code stood, it put the same physical sub-Plan node into both indxqual and indxqualorig of the IndexScan plan node. That confused later processing in the optimizer (which expected that tracing the subPlan list would visit each subplan node exactly once), and would probably have blown up in the executor if the planner hadn't choked first. Fix by making the 'fixed' indexqual be a complete deep copy of the original indexqual, rather than trying to share nodes below the topmost operator node. This had further ramifications though, because we were making the aforesaid list of sub-Plan nodes during SS_process_sublinks which is run before construction of the 'fixed' indexqual, meaning that the copy of the sub-Plan didn't show up in that list. Fix by rearranging logic so that the sub-Plan list is built by the final set_plan_references pass, not in SS_process_sublinks. This may sound like a mess, but it's actually a good deal cleaner now than it was before, because we are no longer dependent on the assumption that planning will never make a copy of a sub-Plan node.
2000-04-03 21:21:48 -04:00
extern bool contain_subplans(Node *clause);
Further planner/optimizer cleanups. Move all set_tlist_references and fix_opids processing to a single recursive pass over the plan tree executed at the very tail end of planning, rather than haphazardly here and there at different places. Now that tlist Vars do not get modified until the very end, it's possible to get rid of the klugy var_equal and match_varid partial-matching routines, and just use plain equal() throughout the optimizer. This is a step towards allowing merge and hash joins to be done on expressions instead of only Vars ...
1999-08-22 16:15:04 -04:00
Divide functions into three volatility classes (immutable, stable, and volatile), rather than the old cachable/noncachable distinction. This allows indexscan optimizations in many places where we formerly didn't. Also, add a pronamespace column to pg_proc (it doesn't do anything yet, however).
2002-04-04 19:31:36 -05:00
extern bool contain_mutable_functions(Node *clause);
extern bool contain_volatile_functions(Node *clause);
Teach planner to expand sufficiently simple SQL-language functions ('SELECT expression') inline, like macros, during the constant-folding phase of planning. The actual expansion is not difficult, but checking that we're not changing the semantics of the call turns out to be more subtle than one might think; in particular must pay attention to permissions issues, strictness, and volatility.
2002-12-01 16:05:14 -05:00
extern bool contain_nonstrict_functions(Node *clause);
Clean up handling of variable-free qual clauses. System now does the right thing with variable-free clauses that contain noncachable functions, such as 'WHERE random() < 0.5' --- these are evaluated once per potential output tuple. Expressions that contain only Params are now candidates to be indexscan quals --- for example, 'var = ($1 + 1)' can now be indexed. Cope with RelabelType nodes atop potential indexscan variables --- this oversight prevents 7.0.* from recognizing some potentially indexscanable situations.
2000-08-12 22:50:35 -04:00
extern bool is_pseudo_constant_clause(Node *clause);
Adjust the definition of RestrictInfo's left_relids and right_relids fields: now they are valid whenever the clause is a binary opclause, not only when it is a potential join clause (there is a new boolean field canjoin to signal the latter condition). This lets us avoid recomputing the relid sets over and over while examining indexes. Still more work to do to make this as useful as it could be, because there are places that could use the info but don't have access to the RestrictInfo node.
2003-12-30 18:53:15 -05:00
extern bool is_pseudo_constant_clause_relids(Node *clause, Relids relids);
Subselects in FROM clause, per ISO syntax: FROM (SELECT ...) [AS] alias. (Don't forget that an alias is required.) Views reimplemented as expanding to subselect-in-FROM. Grouping, aggregates, DISTINCT in views actually work now (he says optimistically). No UNION support in subselects/views yet, but I have some ideas about that. Rule-related permissions checking moved out of rewriter and into executor. INITDB REQUIRED!
2000-09-29 14:21:41 -04:00
extern List *pull_constant_clauses(List *quals, List **constantQual);
Fix extremely nasty little bug observed when a sub-SELECT appears in WHERE in a place where it can be part of a nestloop inner indexqual. As the code stood, it put the same physical sub-Plan node into both indxqual and indxqualorig of the IndexScan plan node. That confused later processing in the optimizer (which expected that tracing the subPlan list would visit each subplan node exactly once), and would probably have blown up in the executor if the planner hadn't choked first. Fix by making the 'fixed' indexqual be a complete deep copy of the original indexqual, rather than trying to share nodes below the topmost operator node. This had further ramifications though, because we were making the aforesaid list of sub-Plan nodes during SS_process_sublinks which is run before construction of the 'fixed' indexqual, meaning that the copy of the sub-Plan didn't show up in that list. Fix by rearranging logic so that the sub-Plan list is built by the final set_plan_references pass, not in SS_process_sublinks. This may sound like a mess, but it's actually a good deal cleaner now than it was before, because we are no longer dependent on the assumption that planning will never make a copy of a sub-Plan node.
2000-04-03 21:21:48 -04:00
Fix optimizer to not try to push WHERE clauses down into a sub-SELECT that has a DISTINCT ON clause, per bug report from Anthony Wood. While at it, improve the DISTINCT-ON-clause recognizer routine to not be fooled by out- of-order DISTINCT lists.
2001-07-31 13:56:31 -04:00
extern bool has_distinct_on_clause(Query *query);
Another pgindent run. Sorry folks.
1999-05-25 18:43:53 -04:00
extern void clause_get_relids_vars(Node *clause, Relids *relids, List **vars);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern int NumRelids(Node *clause);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void CommuteClause(OpExpr *clause);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 01:04:48 -04:00
Implement constant-expression simplification per Bernard Frankpitt, plus some improvements from yours truly. The simplifier depends on the proiscachable field of pg_proc to tell it whether a function is safe to pre-evaluate --- things like nextval() are not, for example. Update pg_proc.h to contain reasonable cacheability information; as of 6.5.* hardly any functions were marked cacheable. I may have erred too far in the other direction; see recent mail to pghackers for more info. This update does not force an initdb, exactly, but you won't see much benefit from the simplifier until you do one.
1999-09-25 22:28:44 -04:00
extern Node *eval_const_expressions(Node *node);
Create a generic expression-tree-walker subroutine, which will gradually replace all of the boilerplate tree-walk-recursion code that currently exists in O(N) slightly different forms in N subroutines. I've had it with adding missing cases to these subroutines...
1999-06-18 23:41:45 -04:00
extern bool expression_tree_walker(Node *node, bool (*walker) (),
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
void *context);
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 13:17:23 -04:00
extern Node *expression_tree_mutator(Node *node, Node *(*mutator) (),
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
void *context);
Tweak querytree-dependency-extraction code so that columns of tables that are explicitly JOINed are not considered dependencies unless they are actually used in the query: mere presence in the joinaliasvars list of a JOIN RTE doesn't count as being used. The patch touches a number of files because I needed to generalize the API of query_tree_walker to support an additional flag bit, but the changes are otherwise quite small.
2002-09-11 10:48:55 -04:00
/* flags bits for query_tree_walker and query_tree_mutator */
pgindent run.
2003-08-03 20:43:34 -04:00
#define QTW_IGNORE_RT_SUBQUERIES 0x01 /* subqueries in rtable */
#define QTW_IGNORE_JOINALIASES 0x02 /* JOIN alias var lists */
#define QTW_DONT_COPY_QUERY 0x04 /* do not copy top Query */
Tweak querytree-dependency-extraction code so that columns of tables that are explicitly JOINed are not considered dependencies unless they are actually used in the query: mere presence in the joinaliasvars list of a JOIN RTE doesn't count as being used. The patch touches a number of files because I needed to generalize the API of query_tree_walker to support an additional flag bit, but the changes are otherwise quite small.
2002-09-11 10:48:55 -04:00
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 17:07:18 -04:00
extern bool query_tree_walker(Query *query, bool (*walker) (),
pgindent run.
2003-08-03 20:43:34 -04:00
void *context, int flags);
Adjust API of expression_tree_mutator and query_tree_mutator to simplify callers. It turns out the common case is that the caller does want to recurse into sub-queries, so push support for that into these subroutines.
2003-01-16 21:01:21 -05:00
extern Query *query_tree_mutator(Query *query, Node *(*mutator) (),
pgindent run.
2003-08-03 20:43:34 -04:00
void *context, int flags);
Adjust API of expression_tree_mutator and query_tree_mutator to simplify callers. It turns out the common case is that the caller does want to recurse into sub-queries, so push support for that into these subroutines.
2003-01-16 21:01:21 -05:00
extern bool query_or_expression_tree_walker(Node *node, bool (*walker) (),
pgindent run.
2003-08-03 20:43:34 -04:00
void *context, int flags);
Adjust API of expression_tree_mutator and query_tree_mutator to simplify callers. It turns out the common case is that the caller does want to recurse into sub-queries, so push support for that into these subroutines.
2003-01-16 21:01:21 -05:00
extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
pgindent run.
2003-08-03 20:43:34 -04:00
void *context, int flags);
Create a generic expression-tree-walker subroutine, which will gradually replace all of the boilerplate tree-walk-recursion code that currently exists in O(N) slightly different forms in N subroutines. I've had it with adding missing cases to these subroutines...
1999-06-18 23:41:45 -04: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 /* CLAUSES_H */
Reference in a new issue Copy permalink