The executor takes the plan handed back by the
planner/optimizer and starts processing the top node. In the case of
our example (the query given in example \ref{simple_select}) the top
node is a MergeJoin node.
Before any merge can be done two tuples have to be fetched (one from
each subplan). So the executor recursively calls itself to
process the subplans (it starts with the subplan attached to
lefttree). The new top node (the top node of the left subplan) is a
SeqScan node and again a tuple has to be fetched before the node
itself can be processed. The executor calls itself recursively
another time for the subplan attached to lefttree of the
SeqScan node.
Now the new top node is a Sort node. As a sort has to be done on
the whole relation, the executor starts fetching tuples
from the Sort node's subplan and sorts them into a temporary
relation (in memory or a file) when the Sort node is visited for
the first time. (Further examinations of the Sort node will
always return just one tuple from the sorted temporary
relation.)
Every time the processing of the Sort node needs a new tuple the
executor is recursively called for the SeqScan node
attached as subplan. The relation (internally referenced by the
value given in the scanrelid field) is scanned for the next
tuple. If the tuple satisfies the qualification given by the tree
attached to qpqual it is handed back, otherwise the next tuple
is fetched until the qualification is satisfied. If the last tuple of
the relation has been processed a NULL pointer is
returned.
After a tuple has been handed back by the lefttree of the
MergeJoin the righttree is processed in the same way. If both
tuples are present the executor processes the MergeJoin
node. Whenever a new tuple from one of the subplans is needed a
recursive call to the executor is performed to obtain it. If a
joined tuple could be created it is handed back and one complete
processing of the plan tree has finished.
Now the described steps are performed once for every tuple, until a
NULL pointer is returned for the processing of the
MergeJoin node, indicating that we are finished.
