1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* nodeSort.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Routines to handle sorting of relations.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Portions Copyright (c) 1996-2018, 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
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/backend/executor/nodeSort.c
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1996-10-31 11:12:26 +01:00
|
|
|
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "postgres.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
|
2017-08-29 19:22:49 +02:00
|
|
|
#include "access/parallel.h"
|
1996-11-08 07:02:30 +01:00
|
|
|
#include "executor/execdebug.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "executor/nodeSort.h"
|
2004-02-03 18:34:04 +01:00
|
|
|
#include "miscadmin.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
#include "utils/tuplesort.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSort
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Sorts tuples from the outer subtree of the node using tuplesort,
|
1997-09-07 07:04:48 +02:00
|
|
|
* which saves the results in a temporary file or memory. After the
|
|
|
|
* initial call, returns a tuple from the file with each call.
|
|
|
|
*
|
|
|
|
* Conditions:
|
|
|
|
* -- none.
|
|
|
|
*
|
|
|
|
* Initial States:
|
|
|
|
* -- the outer child is prepared to return the first tuple.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
2017-07-17 09:33:49 +02:00
|
|
|
static TupleTableSlot *
|
|
|
|
ExecSort(PlanState *pstate)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2017-07-17 09:33:49 +02:00
|
|
|
SortState *node = castNode(SortState, pstate);
|
1997-09-08 04:41:22 +02:00
|
|
|
EState *estate;
|
|
|
|
ScanDirection dir;
|
1999-10-18 00:15:09 +02:00
|
|
|
Tuplesortstate *tuplesortstate;
|
1997-09-07 07:04:48 +02:00
|
|
|
TupleTableSlot *slot;
|
|
|
|
|
2017-07-26 02:37:17 +02:00
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* get state info from node
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
|
|
|
"entering routine");
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
estate = node->ss.ps.state;
|
1997-09-07 07:04:48 +02:00
|
|
|
dir = estate->es_direction;
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesortstate = (Tuplesortstate *) node->tuplesortstate;
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If first time through, read all tuples from outer plan and pass them to
|
|
|
|
* tuplesort.c. Subsequent calls just fetch tuples from tuplesort.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-08-06 05:42:21 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
Sort *plannode = (Sort *) node->ss.ps.plan;
|
|
|
|
PlanState *outerNode;
|
1999-10-18 00:15:09 +02:00
|
|
|
TupleDesc tupDesc;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
1999-10-18 00:15:09 +02:00
|
|
|
"sorting subplan");
|
2001-03-22 07:16:21 +01:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Want to scan subplan in the forward direction while creating the
|
|
|
|
* sorted data.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
estate->es_direction = ForwardScanDirection;
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Initialize tuplesort module.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
1999-10-18 00:15:09 +02:00
|
|
|
SO1_printf("ExecSort: %s\n",
|
|
|
|
"calling tuplesort_begin");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
outerNode = outerPlanState(node);
|
2003-05-05 19:57:47 +02:00
|
|
|
tupDesc = ExecGetResultType(outerNode);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-05-06 02:20:33 +02:00
|
|
|
tuplesortstate = tuplesort_begin_heap(tupDesc,
|
|
|
|
plannode->numCols,
|
|
|
|
plannode->sortColIdx,
|
2007-01-09 03:14:16 +01:00
|
|
|
plannode->sortOperators,
|
2011-02-08 22:04:18 +01:00
|
|
|
plannode->collations,
|
2007-01-09 03:14:16 +01:00
|
|
|
plannode->nullsFirst,
|
2004-02-03 18:34:04 +01:00
|
|
|
work_mem,
|
Support parallel btree index builds.
To make this work, tuplesort.c and logtape.c must also support
parallelism, so this patch adds that infrastructure and then applies
it to the particular case of parallel btree index builds. Testing
to date shows that this can often be 2-3x faster than a serial
index build.
The model for deciding how many workers to use is fairly primitive
at present, but it's better than not having the feature. We can
refine it as we get more experience.
Peter Geoghegan with some help from Rushabh Lathia. While Heikki
Linnakangas is not an author of this patch, he wrote other patches
without which this feature would not have been possible, and
therefore the release notes should possibly credit him as an author
of this feature. Reviewed by Claudio Freire, Heikki Linnakangas,
Thomas Munro, Tels, Amit Kapila, me.
Discussion: http://postgr.es/m/CAM3SWZQKM=Pzc=CAHzRixKjp2eO5Q0Jg1SoFQqeXFQ647JiwqQ@mail.gmail.com
Discussion: http://postgr.es/m/CAH2-Wz=AxWqDoVvGU7dq856S4r6sJAj6DBn7VMtigkB33N5eyg@mail.gmail.com
2018-02-02 19:25:55 +01:00
|
|
|
NULL, node->randomAccess);
|
2007-05-04 03:13:45 +02:00
|
|
|
if (node->bounded)
|
|
|
|
tuplesort_set_bound(tuplesortstate, node->bound);
|
2002-12-05 16:50:39 +01:00
|
|
|
node->tuplesortstate = (void *) tuplesortstate;
|
1999-10-18 00:15:09 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Scan the subplan and feed all the tuples to tuplesort.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
for (;;)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
slot = ExecProcNode(outerNode);
|
1999-10-18 00:15:09 +02:00
|
|
|
|
|
|
|
if (TupIsNull(slot))
|
|
|
|
break;
|
|
|
|
|
2006-06-27 18:53:02 +02:00
|
|
|
tuplesort_puttupleslot(tuplesortstate, slot);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Complete the sort.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
tuplesort_performsort(tuplesortstate);
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* restore to user specified direction
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
estate->es_direction = dir;
|
1997-08-06 05:42:21 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* finally set the sorted flag to true
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
node->sort_Done = true;
|
2007-05-04 03:13:45 +02:00
|
|
|
node->bounded_Done = node->bounded;
|
|
|
|
node->bound_Done = node->bound;
|
2017-08-29 19:22:49 +02:00
|
|
|
if (node->shared_info && node->am_worker)
|
|
|
|
{
|
|
|
|
TuplesortInstrumentation *si;
|
|
|
|
|
|
|
|
Assert(IsParallelWorker());
|
|
|
|
Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
|
|
|
|
si = &node->shared_info->sinstrument[ParallelWorkerNumber];
|
|
|
|
tuplesort_get_stats(tuplesortstate, si);
|
|
|
|
}
|
2002-11-02 16:54:13 +01:00
|
|
|
SO1_printf("ExecSort: %s\n", "sorting done");
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SO1_printf("ExecSort: %s\n",
|
1999-10-18 00:15:09 +02:00
|
|
|
"retrieving tuple from tuplesort");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Get the first or next tuple from tuplesort. Returns NULL if no more
|
2017-04-06 23:48:59 +02:00
|
|
|
* tuples. Note that we only rely on slot tuple remaining valid until the
|
|
|
|
* next fetch from the tuplesort.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
slot = node->ss.ps.ps_ResultTupleSlot;
|
2006-06-27 18:53:02 +02:00
|
|
|
(void) tuplesort_gettupleslot(tuplesortstate,
|
|
|
|
ScanDirectionIsForward(dir),
|
2017-04-06 23:48:59 +02:00
|
|
|
false, slot, NULL);
|
2006-06-27 18:53:02 +02:00
|
|
|
return slot;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecInitSort
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Creates the run-time state information for the sort node
|
2006-02-28 05:10:28 +01:00
|
|
|
* produced by the planner and initializes its outer subtree.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
SortState *
|
2006-02-28 05:10:28 +01:00
|
|
|
ExecInitSort(Sort *node, EState *estate, int eflags)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
SortState *sortstate;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
SO1_printf("ExecInitSort: %s\n",
|
|
|
|
"initializing sort node");
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* create state structure
|
|
|
|
*/
|
|
|
|
sortstate = makeNode(SortState);
|
2002-12-05 16:50:39 +01:00
|
|
|
sortstate->ss.ps.plan = (Plan *) node;
|
|
|
|
sortstate->ss.ps.state = estate;
|
2017-07-17 09:33:49 +02:00
|
|
|
sortstate->ss.ps.ExecProcNode = ExecSort;
|
2002-12-05 16:50:39 +01:00
|
|
|
|
2006-02-28 06:48:44 +01:00
|
|
|
/*
|
2006-10-04 02:30:14 +02:00
|
|
|
* We must have random access to the sort output to do backward scan or
|
|
|
|
* mark/restore. We also prefer to materialize the sort output if we
|
|
|
|
* might be called on to rewind and replay it many times.
|
2006-02-28 06:48:44 +01:00
|
|
|
*/
|
|
|
|
sortstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |
|
|
|
|
EXEC_FLAG_BACKWARD |
|
|
|
|
EXEC_FLAG_MARK)) != 0;
|
|
|
|
|
2007-05-04 03:13:45 +02:00
|
|
|
sortstate->bounded = false;
|
1999-10-18 00:15:09 +02:00
|
|
|
sortstate->sort_Done = false;
|
|
|
|
sortstate->tuplesortstate = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Miscellaneous initialization
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
2001-03-22 07:16:21 +01:00
|
|
|
* Sort nodes don't initialize their ExprContexts because they never call
|
|
|
|
* ExecQual or ExecProject.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2006-02-28 05:10:28 +01:00
|
|
|
* initialize child nodes
|
|
|
|
*
|
2006-10-04 02:30:14 +02:00
|
|
|
* We shield the child node from the need to support REWIND, BACKWARD, or
|
|
|
|
* MARK/RESTORE.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2006-02-28 05:10:28 +01:00
|
|
|
eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);
|
|
|
|
|
|
|
|
outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2018-02-17 06:17:38 +01:00
|
|
|
* Initialize scan slot and type.
|
|
|
|
*/
|
|
|
|
ExecCreateScanSlotFromOuterPlan(estate, &sortstate->ss);
|
|
|
|
|
|
|
|
/*
|
2018-04-26 20:47:16 +02:00
|
|
|
* Initialize return slot and type. No need to initialize projection info
|
|
|
|
* because this node doesn't do projections.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
Don't require return slots for nodes without projection.
In a lot of nodes the return slot is not required. That can either be
because the node doesn't do any projection (say an Append node), or
because the node does perform projections but the projection is
optimized away because the projection would yield an identical row.
Slots aren't that small, especially for wide rows, so it's worthwhile
to avoid creating them. It's not possible to just skip creating the
slot - it's currently used to determine the tuple descriptor returned
by ExecGetResultType(). So separate the determination of the result
type from the slot creation. The work previously done internally
ExecInitResultTupleSlotTL() can now also be done separately with
ExecInitResultTypeTL() and ExecInitResultSlot(). That way nodes that
aren't guaranteed to need a result slot, can use
ExecInitResultTypeTL() to determine the result type of the node, and
ExecAssignScanProjectionInfo() (via
ExecConditionalAssignProjectionInfo()) determines that a result slot
is needed, it is created with ExecInitResultSlot().
Besides the advantage of avoiding to create slots that then are
unused, this is necessary preparation for later patches around tuple
table slot abstraction. In particular separating the return descriptor
and slot is a prerequisite to allow JITing of tuple deforming with
knowledge of the underlying tuple format, and to avoid unnecessarily
creating JITed tuple deforming for virtual slots.
This commit removes a redundant argument from
ExecInitResultTupleSlotTL(). While this commit touches a lot of the
relevant lines anyway, it'd normally still not worthwhile to cause
breakage, except that aforementioned later commits will touch *all*
ExecInitResultTupleSlotTL() callers anyway (but fits worse
thematically).
Author: Andres Freund
Discussion: https://postgr.es/m/20181105210039.hh4vvi4vwoq5ba2q@alap3.anarazel.de
2018-11-10 02:19:39 +01:00
|
|
|
ExecInitResultTupleSlotTL(&sortstate->ss.ps);
|
2002-12-05 16:50:39 +01:00
|
|
|
sortstate->ss.ps.ps_ProjInfo = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
SO1_printf("ExecInitSort: %s\n",
|
|
|
|
"sort node initialized");
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
return sortstate;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecEndSort(node)
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecEndSort(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecEndSort: %s\n",
|
|
|
|
"shutting down sort node");
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2002-12-05 16:50:39 +01:00
|
|
|
* clean out the tuple table
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecClearTuple(node->ss.ss_ScanTupleSlot);
|
2006-02-26 23:58:12 +01:00
|
|
|
/* must drop pointer to sort result tuple */
|
|
|
|
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* Release tuplesort resources
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (node->tuplesortstate != NULL)
|
|
|
|
tuplesort_end((Tuplesortstate *) node->tuplesortstate);
|
|
|
|
node->tuplesortstate = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-12-15 17:17:59 +01:00
|
|
|
/*
|
|
|
|
* shut down the subplan
|
|
|
|
*/
|
|
|
|
ExecEndNode(outerPlanState(node));
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
SO1_printf("ExecEndSort: %s\n",
|
|
|
|
"sort node shutdown");
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSortMarkPos
|
1997-08-06 05:42:21 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Calls tuplesort to save the current position in the sorted file.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecSortMarkPos(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* if we haven't sorted yet, just return
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_markpos((Tuplesortstate *) node->tuplesortstate);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
1997-09-07 07:04:48 +02:00
|
|
|
* ExecSortRestrPos
|
1997-08-06 05:42:21 +02:00
|
|
|
*
|
1999-10-18 00:15:09 +02:00
|
|
|
* Calls tuplesort to restore the last saved sort file position.
|
1996-07-09 08:22:35 +02:00
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecSortRestrPos(SortState *node)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* if we haven't sorted yet, just return.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* restore the scan to the previously marked position
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_restorepos((Tuplesortstate *) node->tuplesortstate);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1998-02-23 07:28:16 +01:00
|
|
|
|
|
|
|
void
|
2010-07-12 19:01:06 +02:00
|
|
|
ExecReScanSort(SortState *node)
|
1998-02-23 07:28:16 +01:00
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
PlanState *outerPlan = outerPlanState(node);
|
2015-05-04 22:13:07 +02:00
|
|
|
|
1998-02-23 07:28:16 +01:00
|
|
|
/*
|
2010-07-12 19:01:06 +02:00
|
|
|
* If we haven't sorted yet, just return. If outerplan's chgParam is not
|
|
|
|
* NULL then it will be re-scanned by ExecProcNode, else no reason to
|
2005-10-15 04:49:52 +02:00
|
|
|
* re-scan it at all.
|
1998-02-23 07:28:16 +01:00
|
|
|
*/
|
2002-12-05 16:50:39 +01:00
|
|
|
if (!node->sort_Done)
|
1998-02-23 07:28:16 +01:00
|
|
|
return;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2006-02-26 23:58:12 +01:00
|
|
|
/* must drop pointer to sort result tuple */
|
2002-12-05 16:50:39 +01:00
|
|
|
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-02-23 07:28:16 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If subnode is to be rescanned then we forget previous sort results; we
|
2007-05-04 03:13:45 +02:00
|
|
|
* have to re-read the subplan and re-sort. Also must re-sort if the
|
|
|
|
* bounded-sort parameters changed or we didn't select randomAccess.
|
1999-10-18 00:15:09 +02:00
|
|
|
*
|
|
|
|
* Otherwise we can just rewind and rescan the sorted output.
|
1998-02-23 07:28:16 +01:00
|
|
|
*/
|
2015-05-04 22:13:07 +02:00
|
|
|
if (outerPlan->chgParam != NULL ||
|
2007-05-04 03:13:45 +02:00
|
|
|
node->bounded != node->bounded_Done ||
|
|
|
|
node->bound != node->bound_Done ||
|
2006-02-28 06:48:44 +01:00
|
|
|
!node->randomAccess)
|
1999-10-18 00:15:09 +02:00
|
|
|
{
|
2002-12-05 16:50:39 +01:00
|
|
|
node->sort_Done = false;
|
|
|
|
tuplesort_end((Tuplesortstate *) node->tuplesortstate);
|
|
|
|
node->tuplesortstate = NULL;
|
2006-10-04 02:30:14 +02:00
|
|
|
|
2006-02-28 06:48:44 +01:00
|
|
|
/*
|
|
|
|
* if chgParam of subnode is not null then plan will be re-scanned by
|
|
|
|
* first ExecProcNode.
|
|
|
|
*/
|
2015-05-04 22:13:07 +02:00
|
|
|
if (outerPlan->chgParam == NULL)
|
|
|
|
ExecReScan(outerPlan);
|
1999-10-18 00:15:09 +02:00
|
|
|
}
|
|
|
|
else
|
2002-12-05 16:50:39 +01:00
|
|
|
tuplesort_rescan((Tuplesortstate *) node->tuplesortstate);
|
1998-02-23 07:28:16 +01:00
|
|
|
}
|
2017-08-29 19:22:49 +02:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* Parallel Query Support
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortEstimate
|
|
|
|
*
|
|
|
|
* Estimate space required to propagate sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortEstimate(SortState *node, ParallelContext *pcxt)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
|
|
|
|
/* don't need this if not instrumenting or no workers */
|
|
|
|
if (!node->ss.ps.instrument || pcxt->nworkers == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = mul_size(pcxt->nworkers, sizeof(TuplesortInstrumentation));
|
|
|
|
size = add_size(size, offsetof(SharedSortInfo, sinstrument));
|
|
|
|
shm_toc_estimate_chunk(&pcxt->estimator, size);
|
|
|
|
shm_toc_estimate_keys(&pcxt->estimator, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortInitializeDSM
|
|
|
|
*
|
|
|
|
* Initialize DSM space for sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
|
|
|
|
/* don't need this if not instrumenting or no workers */
|
|
|
|
if (!node->ss.ps.instrument || pcxt->nworkers == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = offsetof(SharedSortInfo, sinstrument)
|
|
|
|
+ pcxt->nworkers * sizeof(TuplesortInstrumentation);
|
|
|
|
node->shared_info = shm_toc_allocate(pcxt->toc, size);
|
|
|
|
/* ensure any unfilled slots will contain zeroes */
|
|
|
|
memset(node->shared_info, 0, size);
|
|
|
|
node->shared_info->num_workers = pcxt->nworkers;
|
|
|
|
shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
|
|
|
|
node->shared_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortInitializeWorker
|
|
|
|
*
|
|
|
|
* Attach worker to DSM space for sort statistics.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
2017-11-17 02:28:11 +01:00
|
|
|
ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt)
|
2017-08-29 19:22:49 +02:00
|
|
|
{
|
|
|
|
node->shared_info =
|
2017-11-17 02:28:11 +01:00
|
|
|
shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
|
2017-08-29 19:22:49 +02:00
|
|
|
node->am_worker = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
|
|
* ExecSortRetrieveInstrumentation
|
|
|
|
*
|
|
|
|
* Transfer sort statistics from DSM to private memory.
|
|
|
|
* ----------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ExecSortRetrieveInstrumentation(SortState *node)
|
|
|
|
{
|
|
|
|
Size size;
|
|
|
|
SharedSortInfo *si;
|
|
|
|
|
|
|
|
if (node->shared_info == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = offsetof(SharedSortInfo, sinstrument)
|
|
|
|
+ node->shared_info->num_workers * sizeof(TuplesortInstrumentation);
|
|
|
|
si = palloc(size);
|
|
|
|
memcpy(si, node->shared_info, size);
|
|
|
|
node->shared_info = si;
|
|
|
|
}
|