The task of the planner/optimizer is to create an optimal execution plan. A given SQL query (and hence, a query tree) can be actually executed in a wide variety of different ways, each of which will produce the same set of results. If it is computationally feasible, the query optimizer will examine each of these possible execution plans, ultimately selecting the execution plan that is expected to run the fastest.
In some situations, examining each possible way in which a query can be executed would take an excessive amount of time and memory space. In particular, this occurs when executing queries involving large numbers of join operations. In order to determine a reasonable (not necessarily optimal) query plan in a reasonable amount of time, PostgreSQL uses a Genetic Query Optimizer (see Chapter 59) when the number of joins exceeds a threshold (see geqo_threshold).
The planner's search procedure actually works with data structures called paths, which are simply cut-down representations of plans containing only as much information as the planner needs to make its decisions. After the cheapest path is determined, a full-fledged plan tree is built to pass to the executor. This represents the desired execution plan in sufficient detail for the executor to run it. In the rest of this section we'll ignore the distinction between paths and plans.
The planner/optimizer starts by generating plans for scanning
each individual relation (table) used in the query. The possible
plans are determined by the available indexes on each relation.
There is always the possibility of performing a sequential scan on
a relation, so a sequential scan plan is always created. Assume an
index is defined on a relation (for example a B-tree index) and a
query contains the restriction
relation.attribute OPR constant. If
relation.attribute happens to match the key of the
B-tree index and
OPR is one of the
operators listed in the index's operator
class, another plan is created using the B-tree index to scan
the relation. If there are further indexes present and the
restrictions in the query happen to match a key of an index,
further plans will be considered. Index scan plans are also
generated for indexes that have a sort ordering that can match the
ORDER BY clause (if any), or a
sort ordering that might be useful for merge joining (see
If the query requires joining two or more relations, plans for joining relations are considered after all feasible plans have been found for scanning single relations. The three available join strategies are:
nested loop join: The right relation is scanned once for every row found in the left relation. This strategy is easy to implement but can be very time consuming. (However, if the right relation can be scanned with an index scan, this can be a good strategy. It is possible to use values from the current row of the left relation as keys for the index scan of the right.)
merge join: Each relation is sorted on the join attributes before the join starts. Then the two relations are scanned in parallel, and matching rows are combined to form join rows. This kind of join is more attractive because each relation has to be scanned only once. The required sorting might be achieved either by an explicit sort step, or by scanning the relation in the proper order using an index on the join key.
hash join: the right relation is first scanned and loaded into a hash table, using its join attributes as hash keys. Next the left relation is scanned and the appropriate values of every row found are used as hash keys to locate the matching rows in the table.
When the query involves more than two relations, the final result must be built up by a tree of join steps, each with two inputs. The planner examines different possible join sequences to find the cheapest one.
If the query uses fewer than geqo_threshold
relations, a near-exhaustive search is conducted to find the best
join sequence. The planner preferentially considers joins between
any two relations for which there exist a corresponding join clause
WHERE qualification (i.e., for
which a restriction like
rel1.attr1=rel2.attr2 exists). Join pairs with no join
clause are considered only when there is no other choice, that is,
a particular relation has no available join clauses to any other
relation. All possible plans are generated for every join pair
considered by the planner, and the one that is (estimated to be)
the cheapest is chosen.
geqo_threshold is exceeded,
the join sequences considered are determined by heuristics, as
described in Chapter 59.
Otherwise the process is the same.
The finished plan tree consists of sequential or index scans of
the base relations, plus nested-loop, merge, or hash join nodes as
needed, plus any auxiliary steps needed, such as sort nodes or
aggregate-function calculation nodes. Most of these plan node types
have the additional ability to do selection (discarding rows that do not meet a
specified Boolean condition) and projection (computation of a derived column set
based on given column values, that is, evaluation of scalar
expressions where needed). One of the responsibilities of the
planner is to attach selection conditions from the
WHERE clause and computation of required output
expressions to the most appropriate nodes of the plan tree.
If you see anything in the documentation that is not correct, does not match your experience with the particular feature or requires further clarification, please use this form to report a documentation issue.