1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* cost.h
|
1997-09-07 07:04:48 +02:00
|
|
|
* prototypes for costsize.c and clausesel.c.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
2016-01-02 19:33:40 +01:00
|
|
|
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/include/optimizer/cost.h
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef COST_H
|
|
|
|
#define COST_H
|
|
|
|
|
2002-11-21 01:42:20 +01:00
|
|
|
#include "nodes/plannodes.h"
|
1997-11-26 02:14:33 +01:00
|
|
|
#include "nodes/relation.h"
|
|
|
|
|
2002-11-21 01:42:20 +01:00
|
|
|
|
2000-01-23 03:07:00 +01:00
|
|
|
/* defaults for costsize.c's Cost parameters */
|
2000-02-15 21:49:31 +01:00
|
|
|
/* NB: cost-estimation code should use the variables, not these constants! */
|
2001-01-24 19:37:31 +01:00
|
|
|
/* If you change these, update backend/utils/misc/postgresql.sample.conf */
|
2006-06-05 04:49:58 +02:00
|
|
|
#define DEFAULT_SEQ_PAGE_COST 1.0
|
2000-02-15 21:49:31 +01:00
|
|
|
#define DEFAULT_RANDOM_PAGE_COST 4.0
|
2000-04-12 19:17:23 +02:00
|
|
|
#define DEFAULT_CPU_TUPLE_COST 0.01
|
2006-06-05 05:03:42 +02:00
|
|
|
#define DEFAULT_CPU_INDEX_TUPLE_COST 0.005
|
2000-02-15 21:49:31 +01:00
|
|
|
#define DEFAULT_CPU_OPERATOR_COST 0.0025
|
Add a Gather executor node.
A Gather executor node runs any number of copies of a plan in an equal
number of workers and merges all of the results into a single tuple
stream. It can also run the plan itself, if the workers are
unavailable or haven't started up yet. It is intended to work with
the Partial Seq Scan node which will be added in future commits.
It could also be used to implement parallel query of a different sort
by itself, without help from Partial Seq Scan, if the single_copy mode
is used. In that mode, a worker executes the plan, and the parallel
leader does not, merely collecting the worker's results. So, a Gather
node could be inserted into a plan to split the execution of that plan
across two processes. Nested Gather nodes aren't currently supported,
but we might want to add support for that in the future.
There's nothing in the planner to actually generate Gather nodes yet,
so it's not quite time to break out the champagne. But we're getting
close.
Amit Kapila. Some designs suggestions were provided by me, and I also
reviewed the patch. Single-copy mode, documentation, and other minor
changes also by me.
2015-10-01 01:23:36 +02:00
|
|
|
#define DEFAULT_PARALLEL_TUPLE_COST 0.1
|
|
|
|
#define DEFAULT_PARALLEL_SETUP_COST 1000.0
|
2000-01-23 03:07:00 +01:00
|
|
|
|
2014-05-09 03:11:47 +02:00
|
|
|
#define DEFAULT_EFFECTIVE_CACHE_SIZE 524288 /* measured in pages */
|
2014-05-09 02:49:38 +02:00
|
|
|
|
2009-01-07 23:40:49 +01:00
|
|
|
typedef enum
|
|
|
|
{
|
2009-06-11 16:49:15 +02:00
|
|
|
CONSTRAINT_EXCLUSION_OFF, /* do not use c_e */
|
|
|
|
CONSTRAINT_EXCLUSION_ON, /* apply c_e to all rels */
|
2009-01-07 23:40:49 +01:00
|
|
|
CONSTRAINT_EXCLUSION_PARTITION /* apply c_e to otherrels only */
|
2011-04-10 17:42:00 +02:00
|
|
|
} ConstraintExclusionType;
|
2009-01-07 23:40:49 +01:00
|
|
|
|
1999-07-15 17:21:54 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1999-02-14 00:22:53 +01:00
|
|
|
* prototypes for costsize.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* routines to compute costs and sizes
|
|
|
|
*/
|
2000-01-23 00:50:30 +01:00
|
|
|
|
2000-02-15 21:49:31 +01:00
|
|
|
/* parameter variables and flags */
|
2007-07-25 14:22:54 +02:00
|
|
|
extern PGDLLIMPORT double seq_page_cost;
|
|
|
|
extern PGDLLIMPORT double random_page_cost;
|
|
|
|
extern PGDLLIMPORT double cpu_tuple_cost;
|
|
|
|
extern PGDLLIMPORT double cpu_index_tuple_cost;
|
|
|
|
extern PGDLLIMPORT double cpu_operator_cost;
|
Add a Gather executor node.
A Gather executor node runs any number of copies of a plan in an equal
number of workers and merges all of the results into a single tuple
stream. It can also run the plan itself, if the workers are
unavailable or haven't started up yet. It is intended to work with
the Partial Seq Scan node which will be added in future commits.
It could also be used to implement parallel query of a different sort
by itself, without help from Partial Seq Scan, if the single_copy mode
is used. In that mode, a worker executes the plan, and the parallel
leader does not, merely collecting the worker's results. So, a Gather
node could be inserted into a plan to split the execution of that plan
across two processes. Nested Gather nodes aren't currently supported,
but we might want to add support for that in the future.
There's nothing in the planner to actually generate Gather nodes yet,
so it's not quite time to break out the champagne. But we're getting
close.
Amit Kapila. Some designs suggestions were provided by me, and I also
reviewed the patch. Single-copy mode, documentation, and other minor
changes also by me.
2015-10-01 01:23:36 +02:00
|
|
|
extern PGDLLIMPORT double parallel_tuple_cost;
|
|
|
|
extern PGDLLIMPORT double parallel_setup_cost;
|
2007-07-25 14:22:54 +02:00
|
|
|
extern PGDLLIMPORT int effective_cache_size;
|
2000-01-23 00:50:30 +01:00
|
|
|
extern Cost disable_cost;
|
Add a Gather executor node.
A Gather executor node runs any number of copies of a plan in an equal
number of workers and merges all of the results into a single tuple
stream. It can also run the plan itself, if the workers are
unavailable or haven't started up yet. It is intended to work with
the Partial Seq Scan node which will be added in future commits.
It could also be used to implement parallel query of a different sort
by itself, without help from Partial Seq Scan, if the single_copy mode
is used. In that mode, a worker executes the plan, and the parallel
leader does not, merely collecting the worker's results. So, a Gather
node could be inserted into a plan to split the execution of that plan
across two processes. Nested Gather nodes aren't currently supported,
but we might want to add support for that in the future.
There's nothing in the planner to actually generate Gather nodes yet,
so it's not quite time to break out the champagne. But we're getting
close.
Amit Kapila. Some designs suggestions were provided by me, and I also
reviewed the patch. Single-copy mode, documentation, and other minor
changes also by me.
2015-10-01 01:23:36 +02:00
|
|
|
extern int max_parallel_degree;
|
2000-01-23 00:50:30 +01:00
|
|
|
extern bool enable_seqscan;
|
|
|
|
extern bool enable_indexscan;
|
2011-10-08 02:13:02 +02:00
|
|
|
extern bool enable_indexonlyscan;
|
2005-04-21 21:18:13 +02:00
|
|
|
extern bool enable_bitmapscan;
|
2000-01-23 00:50:30 +01:00
|
|
|
extern bool enable_tidscan;
|
|
|
|
extern bool enable_sort;
|
2002-11-21 01:42:20 +01:00
|
|
|
extern bool enable_hashagg;
|
2000-01-23 00:50:30 +01:00
|
|
|
extern bool enable_nestloop;
|
2010-04-19 02:55:26 +02:00
|
|
|
extern bool enable_material;
|
2000-01-23 00:50:30 +01:00
|
|
|
extern bool enable_mergejoin;
|
|
|
|
extern bool enable_hashjoin;
|
2009-01-07 23:40:49 +01:00
|
|
|
extern int constraint_exclusion;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2004-01-05 06:07:36 +01:00
|
|
|
extern double clamp_row_est(double nrows);
|
2006-06-06 19:59:58 +02:00
|
|
|
extern double index_pages_fetched(double tuples_fetched, BlockNumber pages,
|
2006-10-04 02:30:14 +02:00
|
|
|
double index_pages, PlannerInfo *root);
|
Revise parameterized-path mechanism to fix assorted issues.
This patch adjusts the treatment of parameterized paths so that all paths
with the same parameterization (same set of required outer rels) for the
same relation will have the same rowcount estimate. We cache the rowcount
estimates to ensure that property, and hopefully save a few cycles too.
Doing this makes it practical for add_path_precheck to operate without
a rowcount estimate: it need only assume that paths with different
parameterizations never dominate each other, which is close enough to
true anyway for coarse filtering, because normally a more-parameterized
path should yield fewer rows thanks to having more join clauses to apply.
In add_path, we do the full nine yards of comparing rowcount estimates
along with everything else, so that we can discard parameterized paths that
don't actually have an advantage. This fixes some issues I'd found with
add_path rejecting parameterized paths on the grounds that they were more
expensive than not-parameterized ones, even though they yielded many fewer
rows and hence would be cheaper once subsequent joining was considered.
To make the same-rowcounts assumption valid, we have to require that any
parameterized path enforce *all* join clauses that could be obtained from
the particular set of outer rels, even if not all of them are useful for
indexing. This is required at both base scans and joins. It's a good
thing anyway since the net impact is that join quals are checked at the
lowest practical level in the join tree. Hence, discard the original
rather ad-hoc mechanism for choosing parameterization joinquals, and build
a better one that has a more principled rule for when clauses can be moved.
The original rule was actually buggy anyway for lack of knowledge about
which relations are part of an outer join's outer side; getting this right
requires adding an outer_relids field to RestrictInfo.
2012-04-19 21:52:46 +02:00
|
|
|
extern void cost_seqscan(Path *path, PlannerInfo *root, RelOptInfo *baserel,
|
2016-01-20 20:29:22 +01:00
|
|
|
ParamPathInfo *param_info);
|
Redesign tablesample method API, and do extensive code review.
The original implementation of TABLESAMPLE modeled the tablesample method
API on index access methods, which wasn't a good choice because, without
specialized DDL commands, there's no way to build an extension that can
implement a TSM. (Raw inserts into system catalogs are not an acceptable
thing to do, because we can't undo them during DROP EXTENSION, nor will
pg_upgrade behave sanely.) Instead adopt an API more like procedural
language handlers or foreign data wrappers, wherein the only SQL-level
support object needed is a single handler function identified by having
a special return type. This lets us get rid of the supporting catalog
altogether, so that no custom DDL support is needed for the feature.
Adjust the API so that it can support non-constant tablesample arguments
(the original coding assumed we could evaluate the argument expressions at
ExecInitSampleScan time, which is undesirable even if it weren't outright
unsafe), and discourage sampling methods from looking at invisible tuples.
Make sure that the BERNOULLI and SYSTEM methods are genuinely repeatable
within and across queries, as required by the SQL standard, and deal more
honestly with methods that can't support that requirement.
Make a full code-review pass over the tablesample additions, and fix
assorted bugs, omissions, infelicities, and cosmetic issues (such as
failure to put the added code stanzas in a consistent ordering).
Improve EXPLAIN's output of tablesample plans, too.
Back-patch to 9.5 so that we don't have to support the original API
in production.
2015-07-25 20:39:00 +02:00
|
|
|
extern void cost_samplescan(Path *path, PlannerInfo *root, RelOptInfo *baserel,
|
|
|
|
ParamPathInfo *param_info);
|
2011-12-25 01:03:21 +01:00
|
|
|
extern void cost_index(IndexPath *path, PlannerInfo *root,
|
2012-06-10 21:20:04 +02:00
|
|
|
double loop_count);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_bitmap_heap_scan(Path *path, PlannerInfo *root, RelOptInfo *baserel,
|
Revise parameterized-path mechanism to fix assorted issues.
This patch adjusts the treatment of parameterized paths so that all paths
with the same parameterization (same set of required outer rels) for the
same relation will have the same rowcount estimate. We cache the rowcount
estimates to ensure that property, and hopefully save a few cycles too.
Doing this makes it practical for add_path_precheck to operate without
a rowcount estimate: it need only assume that paths with different
parameterizations never dominate each other, which is close enough to
true anyway for coarse filtering, because normally a more-parameterized
path should yield fewer rows thanks to having more join clauses to apply.
In add_path, we do the full nine yards of comparing rowcount estimates
along with everything else, so that we can discard parameterized paths that
don't actually have an advantage. This fixes some issues I'd found with
add_path rejecting parameterized paths on the grounds that they were more
expensive than not-parameterized ones, even though they yielded many fewer
rows and hence would be cheaper once subsequent joining was considered.
To make the same-rowcounts assumption valid, we have to require that any
parameterized path enforce *all* join clauses that could be obtained from
the particular set of outer rels, even if not all of them are useful for
indexing. This is required at both base scans and joins. It's a good
thing anyway since the net impact is that join quals are checked at the
lowest practical level in the join tree. Hence, discard the original
rather ad-hoc mechanism for choosing parameterization joinquals, and build
a better one that has a more principled rule for when clauses can be moved.
The original rule was actually buggy anyway for lack of knowledge about
which relations are part of an outer join's outer side; getting this right
requires adding an outer_relids field to RestrictInfo.
2012-04-19 21:52:46 +02:00
|
|
|
ParamPathInfo *param_info,
|
2012-01-28 01:26:38 +01:00
|
|
|
Path *bitmapqual, double loop_count);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_bitmap_and_node(BitmapAndPath *path, PlannerInfo *root);
|
|
|
|
extern void cost_bitmap_or_node(BitmapOrPath *path, PlannerInfo *root);
|
2005-04-22 23:58:32 +02:00
|
|
|
extern void cost_bitmap_tree_node(Path *path, Cost *cost, Selectivity *selec);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_tidscan(Path *path, PlannerInfo *root,
|
2012-08-27 04:48:55 +02:00
|
|
|
RelOptInfo *baserel, List *tidquals, ParamPathInfo *param_info);
|
Make the upper part of the planner work by generating and comparing Paths.
I've been saying we needed to do this for more than five years, and here it
finally is. This patch removes the ever-growing tangle of spaghetti logic
that grouping_planner() used to use to try to identify the best plan for
post-scan/join query steps. Now, there is (nearly) independent
consideration of each execution step, and entirely separate construction of
Paths to represent each of the possible ways to do that step. We choose
the best Path or set of Paths using the same add_path() logic that's been
used inside query_planner() for years.
In addition, this patch removes the old restriction that subquery_planner()
could return only a single Plan. It now returns a RelOptInfo containing a
set of Paths, just as query_planner() does, and the parent query level can
use each of those Paths as the basis of a SubqueryScanPath at its level.
This allows finding some optimizations that we missed before, wherein a
subquery was capable of returning presorted data and thereby avoiding a
sort in the parent level, making the overall cost cheaper even though
delivering sorted output was not the cheapest plan for the subquery in
isolation. (A couple of regression test outputs change in consequence of
that. However, there is very little change in visible planner behavior
overall, because the point of this patch is not to get immediate planning
benefits but to create the infrastructure for future improvements.)
There is a great deal left to do here. This patch unblocks a lot of
planner work that was basically impractical in the old code structure,
such as allowing FDWs to implement remote aggregation, or rewriting
plan_set_operations() to allow consideration of multiple implementation
orders for set operations. (The latter will likely require a full
rewrite of plan_set_operations(); what I've done here is only to fix it
to return Paths not Plans.) I have also left unfinished some localized
refactoring in createplan.c and planner.c, because it was not necessary
to get this patch to a working state.
Thanks to Robert Haas, David Rowley, and Amit Kapila for review.
2016-03-07 21:58:22 +01:00
|
|
|
extern void cost_subqueryscan(SubqueryScanPath *path, PlannerInfo *root,
|
2012-06-10 21:20:04 +02:00
|
|
|
RelOptInfo *baserel, ParamPathInfo *param_info);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_functionscan(Path *path, PlannerInfo *root,
|
2012-08-08 01:02:54 +02:00
|
|
|
RelOptInfo *baserel, ParamPathInfo *param_info);
|
2006-08-02 03:59:48 +02:00
|
|
|
extern void cost_valuesscan(Path *path, PlannerInfo *root,
|
2012-08-12 22:01:26 +02:00
|
|
|
RelOptInfo *baserel, ParamPathInfo *param_info);
|
2012-08-27 04:48:55 +02:00
|
|
|
extern void cost_ctescan(Path *path, PlannerInfo *root,
|
|
|
|
RelOptInfo *baserel, ParamPathInfo *param_info);
|
Make the upper part of the planner work by generating and comparing Paths.
I've been saying we needed to do this for more than five years, and here it
finally is. This patch removes the ever-growing tangle of spaghetti logic
that grouping_planner() used to use to try to identify the best plan for
post-scan/join query steps. Now, there is (nearly) independent
consideration of each execution step, and entirely separate construction of
Paths to represent each of the possible ways to do that step. We choose
the best Path or set of Paths using the same add_path() logic that's been
used inside query_planner() for years.
In addition, this patch removes the old restriction that subquery_planner()
could return only a single Plan. It now returns a RelOptInfo containing a
set of Paths, just as query_planner() does, and the parent query level can
use each of those Paths as the basis of a SubqueryScanPath at its level.
This allows finding some optimizations that we missed before, wherein a
subquery was capable of returning presorted data and thereby avoiding a
sort in the parent level, making the overall cost cheaper even though
delivering sorted output was not the cheapest plan for the subquery in
isolation. (A couple of regression test outputs change in consequence of
that. However, there is very little change in visible planner behavior
overall, because the point of this patch is not to get immediate planning
benefits but to create the infrastructure for future improvements.)
There is a great deal left to do here. This patch unblocks a lot of
planner work that was basically impractical in the old code structure,
such as allowing FDWs to implement remote aggregation, or rewriting
plan_set_operations() to allow consideration of multiple implementation
orders for set operations. (The latter will likely require a full
rewrite of plan_set_operations(); what I've done here is only to fix it
to return Paths not Plans.) I have also left unfinished some localized
refactoring in createplan.c and planner.c, because it was not necessary
to get this patch to a working state.
Thanks to Robert Haas, David Rowley, and Amit Kapila for review.
2016-03-07 21:58:22 +01:00
|
|
|
extern void cost_recursive_union(Path *runion, Path *nrterm, Path *rterm);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_sort(Path *path, PlannerInfo *root,
|
2007-05-04 03:13:45 +02:00
|
|
|
List *pathkeys, Cost input_cost, double tuples, int width,
|
2010-10-08 02:00:28 +02:00
|
|
|
Cost comparison_cost, int sort_mem,
|
2007-05-04 03:13:45 +02:00
|
|
|
double limit_tuples);
|
2010-10-14 22:56:39 +02:00
|
|
|
extern void cost_merge_append(Path *path, PlannerInfo *root,
|
|
|
|
List *pathkeys, int n_streams,
|
|
|
|
Cost input_startup_cost, Cost input_total_cost,
|
|
|
|
double tuples);
|
2002-11-30 06:21:03 +01:00
|
|
|
extern void cost_material(Path *path,
|
2009-09-13 00:12:09 +02:00
|
|
|
Cost input_startup_cost, Cost input_total_cost,
|
|
|
|
double tuples, int width);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_agg(Path *path, PlannerInfo *root,
|
2011-04-24 22:55:20 +02:00
|
|
|
AggStrategy aggstrategy, const AggClauseCosts *aggcosts,
|
2003-08-04 02:43:34 +02:00
|
|
|
int numGroupCols, double numGroups,
|
|
|
|
Cost input_startup_cost, Cost input_total_cost,
|
|
|
|
double input_tuples);
|
2008-12-28 19:54:01 +01:00
|
|
|
extern void cost_windowagg(Path *path, PlannerInfo *root,
|
2011-04-24 22:55:20 +02:00
|
|
|
List *windowFuncs, int numPartCols, int numOrderCols,
|
2008-12-28 19:54:01 +01:00
|
|
|
Cost input_startup_cost, Cost input_total_cost,
|
|
|
|
double input_tuples);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void cost_group(Path *path, PlannerInfo *root,
|
2003-08-04 02:43:34 +02:00
|
|
|
int numGroupCols, double numGroups,
|
|
|
|
Cost input_startup_cost, Cost input_total_cost,
|
|
|
|
double input_tuples);
|
2012-01-28 01:26:38 +01:00
|
|
|
extern void initial_cost_nestloop(PlannerInfo *root,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
JoinType jointype,
|
|
|
|
Path *outer_path, Path *inner_path,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
SemiAntiJoinFactors *semifactors);
|
|
|
|
extern void final_cost_nestloop(PlannerInfo *root, NestPath *path,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
SemiAntiJoinFactors *semifactors);
|
|
|
|
extern void initial_cost_mergejoin(PlannerInfo *root,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
JoinType jointype,
|
|
|
|
List *mergeclauses,
|
|
|
|
Path *outer_path, Path *inner_path,
|
|
|
|
List *outersortkeys, List *innersortkeys,
|
|
|
|
SpecialJoinInfo *sjinfo);
|
|
|
|
extern void final_cost_mergejoin(PlannerInfo *root, MergePath *path,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
SpecialJoinInfo *sjinfo);
|
|
|
|
extern void initial_cost_hashjoin(PlannerInfo *root,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
JoinType jointype,
|
|
|
|
List *hashclauses,
|
|
|
|
Path *outer_path, Path *inner_path,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
SemiAntiJoinFactors *semifactors);
|
|
|
|
extern void final_cost_hashjoin(PlannerInfo *root, HashPath *path,
|
|
|
|
JoinCostWorkspace *workspace,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
SemiAntiJoinFactors *semifactors);
|
Add a Gather executor node.
A Gather executor node runs any number of copies of a plan in an equal
number of workers and merges all of the results into a single tuple
stream. It can also run the plan itself, if the workers are
unavailable or haven't started up yet. It is intended to work with
the Partial Seq Scan node which will be added in future commits.
It could also be used to implement parallel query of a different sort
by itself, without help from Partial Seq Scan, if the single_copy mode
is used. In that mode, a worker executes the plan, and the parallel
leader does not, merely collecting the worker's results. So, a Gather
node could be inserted into a plan to split the execution of that plan
across two processes. Nested Gather nodes aren't currently supported,
but we might want to add support for that in the future.
There's nothing in the planner to actually generate Gather nodes yet,
so it's not quite time to break out the champagne. But we're getting
close.
Amit Kapila. Some designs suggestions were provided by me, and I also
reviewed the patch. Single-copy mode, documentation, and other minor
changes also by me.
2015-10-01 01:23:36 +02:00
|
|
|
extern void cost_gather(GatherPath *path, PlannerInfo *root,
|
|
|
|
RelOptInfo *baserel, ParamPathInfo *param_info);
|
2008-08-22 02:16:04 +02:00
|
|
|
extern void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan);
|
2007-02-22 23:00:26 +01:00
|
|
|
extern void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root);
|
|
|
|
extern void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root);
|
2012-01-28 01:26:38 +01:00
|
|
|
extern void compute_semi_anti_join_factors(PlannerInfo *root,
|
|
|
|
RelOptInfo *outerrel,
|
|
|
|
RelOptInfo *innerrel,
|
|
|
|
JoinType jointype,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
List *restrictlist,
|
|
|
|
SemiAntiJoinFactors *semifactors);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel);
|
Revise parameterized-path mechanism to fix assorted issues.
This patch adjusts the treatment of parameterized paths so that all paths
with the same parameterization (same set of required outer rels) for the
same relation will have the same rowcount estimate. We cache the rowcount
estimates to ensure that property, and hopefully save a few cycles too.
Doing this makes it practical for add_path_precheck to operate without
a rowcount estimate: it need only assume that paths with different
parameterizations never dominate each other, which is close enough to
true anyway for coarse filtering, because normally a more-parameterized
path should yield fewer rows thanks to having more join clauses to apply.
In add_path, we do the full nine yards of comparing rowcount estimates
along with everything else, so that we can discard parameterized paths that
don't actually have an advantage. This fixes some issues I'd found with
add_path rejecting parameterized paths on the grounds that they were more
expensive than not-parameterized ones, even though they yielded many fewer
rows and hence would be cheaper once subsequent joining was considered.
To make the same-rowcounts assumption valid, we have to require that any
parameterized path enforce *all* join clauses that could be obtained from
the particular set of outer rels, even if not all of them are useful for
indexing. This is required at both base scans and joins. It's a good
thing anyway since the net impact is that join quals are checked at the
lowest practical level in the join tree. Hence, discard the original
rather ad-hoc mechanism for choosing parameterization joinquals, and build
a better one that has a more principled rule for when clauses can be moved.
The original rule was actually buggy anyway for lack of knowledge about
which relations are part of an outer join's outer side; getting this right
requires adding an outer_relids field to RestrictInfo.
2012-04-19 21:52:46 +02:00
|
|
|
extern double get_parameterized_baserel_size(PlannerInfo *root,
|
2012-06-10 21:20:04 +02:00
|
|
|
RelOptInfo *rel,
|
|
|
|
List *param_clauses);
|
Revise parameterized-path mechanism to fix assorted issues.
This patch adjusts the treatment of parameterized paths so that all paths
with the same parameterization (same set of required outer rels) for the
same relation will have the same rowcount estimate. We cache the rowcount
estimates to ensure that property, and hopefully save a few cycles too.
Doing this makes it practical for add_path_precheck to operate without
a rowcount estimate: it need only assume that paths with different
parameterizations never dominate each other, which is close enough to
true anyway for coarse filtering, because normally a more-parameterized
path should yield fewer rows thanks to having more join clauses to apply.
In add_path, we do the full nine yards of comparing rowcount estimates
along with everything else, so that we can discard parameterized paths that
don't actually have an advantage. This fixes some issues I'd found with
add_path rejecting parameterized paths on the grounds that they were more
expensive than not-parameterized ones, even though they yielded many fewer
rows and hence would be cheaper once subsequent joining was considered.
To make the same-rowcounts assumption valid, we have to require that any
parameterized path enforce *all* join clauses that could be obtained from
the particular set of outer rels, even if not all of them are useful for
indexing. This is required at both base scans and joins. It's a good
thing anyway since the net impact is that join quals are checked at the
lowest practical level in the join tree. Hence, discard the original
rather ad-hoc mechanism for choosing parameterization joinquals, and build
a better one that has a more principled rule for when clauses can be moved.
The original rule was actually buggy anyway for lack of knowledge about
which relations are part of an outer join's outer side; getting this right
requires adding an outer_relids field to RestrictInfo.
2012-04-19 21:52:46 +02:00
|
|
|
extern double get_parameterized_joinrel_size(PlannerInfo *root,
|
2012-06-10 21:20:04 +02:00
|
|
|
RelOptInfo *rel,
|
|
|
|
double outer_rows,
|
|
|
|
double inner_rows,
|
|
|
|
SpecialJoinInfo *sjinfo,
|
|
|
|
List *restrict_clauses);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void set_joinrel_size_estimates(PlannerInfo *root, RelOptInfo *rel,
|
2000-04-12 19:17:23 +02:00
|
|
|
RelOptInfo *outer_rel,
|
|
|
|
RelOptInfo *inner_rel,
|
2008-08-14 20:48:00 +02:00
|
|
|
SpecialJoinInfo *sjinfo,
|
2000-04-12 19:17:23 +02:00
|
|
|
List *restrictlist);
|
2011-09-03 21:35:12 +02:00
|
|
|
extern void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel);
|
2006-08-02 03:59:48 +02:00
|
|
|
extern void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel);
|
2008-10-04 23:56:55 +02:00
|
|
|
extern void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel,
|
Make the upper part of the planner work by generating and comparing Paths.
I've been saying we needed to do this for more than five years, and here it
finally is. This patch removes the ever-growing tangle of spaghetti logic
that grouping_planner() used to use to try to identify the best plan for
post-scan/join query steps. Now, there is (nearly) independent
consideration of each execution step, and entirely separate construction of
Paths to represent each of the possible ways to do that step. We choose
the best Path or set of Paths using the same add_path() logic that's been
used inside query_planner() for years.
In addition, this patch removes the old restriction that subquery_planner()
could return only a single Plan. It now returns a RelOptInfo containing a
set of Paths, just as query_planner() does, and the parent query level can
use each of those Paths as the basis of a SubqueryScanPath at its level.
This allows finding some optimizations that we missed before, wherein a
subquery was capable of returning presorted data and thereby avoiding a
sort in the parent level, making the overall cost cheaper even though
delivering sorted output was not the cheapest plan for the subquery in
isolation. (A couple of regression test outputs change in consequence of
that. However, there is very little change in visible planner behavior
overall, because the point of this patch is not to get immediate planning
benefits but to create the infrastructure for future improvements.)
There is a great deal left to do here. This patch unblocks a lot of
planner work that was basically impractical in the old code structure,
such as allowing FDWs to implement remote aggregation, or rewriting
plan_set_operations() to allow consideration of multiple implementation
orders for set operations. (The latter will likely require a full
rewrite of plan_set_operations(); what I've done here is only to fix it
to return Paths not Plans.) I have also left unfinished some localized
refactoring in createplan.c and planner.c, because it was not necessary
to get this patch to a working state.
Thanks to Robert Haas, David Rowley, and Amit Kapila for review.
2016-03-07 21:58:22 +01:00
|
|
|
double cte_rows);
|
2011-02-20 06:17:18 +01:00
|
|
|
extern void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel);
|
Make the upper part of the planner work by generating and comparing Paths.
I've been saying we needed to do this for more than five years, and here it
finally is. This patch removes the ever-growing tangle of spaghetti logic
that grouping_planner() used to use to try to identify the best plan for
post-scan/join query steps. Now, there is (nearly) independent
consideration of each execution step, and entirely separate construction of
Paths to represent each of the possible ways to do that step. We choose
the best Path or set of Paths using the same add_path() logic that's been
used inside query_planner() for years.
In addition, this patch removes the old restriction that subquery_planner()
could return only a single Plan. It now returns a RelOptInfo containing a
set of Paths, just as query_planner() does, and the parent query level can
use each of those Paths as the basis of a SubqueryScanPath at its level.
This allows finding some optimizations that we missed before, wherein a
subquery was capable of returning presorted data and thereby avoiding a
sort in the parent level, making the overall cost cheaper even though
delivering sorted output was not the cheapest plan for the subquery in
isolation. (A couple of regression test outputs change in consequence of
that. However, there is very little change in visible planner behavior
overall, because the point of this patch is not to get immediate planning
benefits but to create the infrastructure for future improvements.)
There is a great deal left to do here. This patch unblocks a lot of
planner work that was basically impractical in the old code structure,
such as allowing FDWs to implement remote aggregation, or rewriting
plan_set_operations() to allow consideration of multiple implementation
orders for set operations. (The latter will likely require a full
rewrite of plan_set_operations(); what I've done here is only to fix it
to return Paths not Plans.) I have also left unfinished some localized
refactoring in createplan.c and planner.c, because it was not necessary
to get this patch to a working state.
Thanks to Robert Haas, David Rowley, and Amit Kapila for review.
2016-03-07 21:58:22 +01:00
|
|
|
extern PathTarget *set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
2000-01-09 01:26:47 +01:00
|
|
|
* prototypes for clausesel.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* routines to compute clause selectivities
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2005-06-06 00:32:58 +02:00
|
|
|
extern Selectivity clauselist_selectivity(PlannerInfo *root,
|
2003-08-04 02:43:34 +02:00
|
|
|
List *clauses,
|
|
|
|
int varRelid,
|
2008-08-14 20:48:00 +02:00
|
|
|
JoinType jointype,
|
|
|
|
SpecialJoinInfo *sjinfo);
|
2005-06-06 00:32:58 +02:00
|
|
|
extern Selectivity clause_selectivity(PlannerInfo *root,
|
2003-08-04 02:43:34 +02:00
|
|
|
Node *clause,
|
|
|
|
int varRelid,
|
2008-08-14 20:48:00 +02:00
|
|
|
JoinType jointype,
|
|
|
|
SpecialJoinInfo *sjinfo);
|
2001-10-28 07:26:15 +01:00
|
|
|
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* COST_H */
|