tuplesort.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "access/nbtree.h"
#include "access/hash.h"
#include "catalog/index.h"
#include "catalog/pg_am.h"
#include "commands/tablespace.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "utils/datum.h"
#include "utils/logtape.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_rusage.h"
#include "utils/rel.h"
#include "utils/sortsupport.h"
#include "utils/tuplesort.h"
#include "qsort_tuple.c"

Include dependency graph for tuplesort.c:

Go to the source code of this file.

Data Structures
struct	SortTuple
union	SlabSlot
struct	Tuplesortstate

Macros
#define	HEAP_SORT   0
#define	INDEX_SORT   1
#define	DATUM_SORT   2
#define	CLUSTER_SORT   3
#define	SLAB_SLOT_SIZE   1024
#define	MINORDER   6 /* minimum merge order */
#define	MAXORDER   500 /* maximum merge order */
#define	TAPE_BUFFER_OVERHEAD   BLCKSZ
#define	MERGE_BUFFER_SIZE   (BLCKSZ * 32)
#define	RUN_FIRST   0
#define	HEAP_RUN_NEXT   INT_MAX
#define	RUN_SECOND   1
#define	IS_SLAB_SLOT(state, tuple)
#define	RELEASE_SLAB_SLOT(state, tuple)
#define	COMPARETUP(state, a, b)   ((*(state)->comparetup) (a, b, state))
#define	COPYTUP(state, stup, tup)   ((*(state)->copytup) (state, stup, tup))
#define	WRITETUP(state, tape, stup)   ((*(state)->writetup) (state, tape, stup))
#define	READTUP(state, stup, tape, len)   ((*(state)->readtup) (state, stup, tape, len))
#define	LACKMEM(state)   ((state)->availMem < 0 && !(state)->slabAllocatorUsed)
#define	USEMEM(state, amt)   ((state)->availMem -= (amt))
#define	FREEMEM(state, amt)   ((state)->availMem += (amt))
#define	LogicalTapeReadExact(tapeset, tapenum, ptr, len)
#define	HEAPCOMPARE(tup1, tup2)

Typedefs
typedef union SlabSlot	SlabSlot
typedef int(*	SortTupleComparator )(const SortTuple *a, const SortTuple *b, Tuplesortstate *state)

Enumerations
enum	TupSortStatus {   TSS_INITIAL, TSS_BOUNDED, TSS_BUILDRUNS, TSS_SORTEDINMEM,   TSS_SORTEDONTAPE, TSS_FINALMERGE }

Functions
static Tuplesortstate *	tuplesort_begin_common (int workMem, bool randomAccess)
static void	puttuple_common (Tuplesortstate *state, SortTuple *tuple)
static bool	consider_abort_common (Tuplesortstate *state)
static bool	useselection (Tuplesortstate *state)
static void	inittapes (Tuplesortstate *state)
static void	selectnewtape (Tuplesortstate *state)
static void	init_slab_allocator (Tuplesortstate *state, int numSlots)
static void	mergeruns (Tuplesortstate *state)
static void	mergeonerun (Tuplesortstate *state)
static void	beginmerge (Tuplesortstate *state)
static bool	mergereadnext (Tuplesortstate *state, int srcTape, SortTuple *stup)
static void	dumptuples (Tuplesortstate *state, bool alltuples)
static void	dumpbatch (Tuplesortstate *state, bool alltuples)
static void	make_bounded_heap (Tuplesortstate *state)
static void	sort_bounded_heap (Tuplesortstate *state)
static void	tuplesort_sort_memtuples (Tuplesortstate *state)
static void	tuplesort_heap_insert (Tuplesortstate *state, SortTuple *tuple, bool checkIndex)
static void	tuplesort_heap_replace_top (Tuplesortstate *state, SortTuple *tuple, bool checkIndex)
static void	tuplesort_heap_delete_top (Tuplesortstate *state, bool checkIndex)
static void	reversedirection (Tuplesortstate *state)
static unsigned int	getlen (Tuplesortstate *state, int tapenum, bool eofOK)
static void	markrunend (Tuplesortstate *state, int tapenum)
static void *	readtup_alloc (Tuplesortstate *state, Size tuplen)
static int	comparetup_heap (const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
static void	copytup_heap (Tuplesortstate *state, SortTuple *stup, void *tup)
static void	writetup_heap (Tuplesortstate *state, int tapenum, SortTuple *stup)
static void	readtup_heap (Tuplesortstate *state, SortTuple *stup, int tapenum, unsigned int len)
static int	comparetup_cluster (const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
static void	copytup_cluster (Tuplesortstate *state, SortTuple *stup, void *tup)
static void	writetup_cluster (Tuplesortstate *state, int tapenum, SortTuple *stup)
static void	readtup_cluster (Tuplesortstate *state, SortTuple *stup, int tapenum, unsigned int len)
static int	comparetup_index_btree (const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
static int	comparetup_index_hash (const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
static void	copytup_index (Tuplesortstate *state, SortTuple *stup, void *tup)
static void	writetup_index (Tuplesortstate *state, int tapenum, SortTuple *stup)
static void	readtup_index (Tuplesortstate *state, SortTuple *stup, int tapenum, unsigned int len)
static int	comparetup_datum (const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
static void	copytup_datum (Tuplesortstate *state, SortTuple *stup, void *tup)
static void	writetup_datum (Tuplesortstate *state, int tapenum, SortTuple *stup)
static void	readtup_datum (Tuplesortstate *state, SortTuple *stup, int tapenum, unsigned int len)
static void	free_sort_tuple (Tuplesortstate *state, SortTuple *stup)
Tuplesortstate *	tuplesort_begin_heap (TupleDesc tupDesc, int nkeys, AttrNumber *attNums, Oid *sortOperators, Oid *sortCollations, bool *nullsFirstFlags, int workMem, bool randomAccess)
Tuplesortstate *	tuplesort_begin_cluster (TupleDesc tupDesc, Relation indexRel, int workMem, bool randomAccess)
Tuplesortstate *	tuplesort_begin_index_btree (Relation heapRel, Relation indexRel, bool enforceUnique, int workMem, bool randomAccess)
Tuplesortstate *	tuplesort_begin_index_hash (Relation heapRel, Relation indexRel, uint32 high_mask, uint32 low_mask, uint32 max_buckets, int workMem, bool randomAccess)
Tuplesortstate *	tuplesort_begin_datum (Oid datumType, Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, int workMem, bool randomAccess)
void	tuplesort_set_bound (Tuplesortstate *state, int64 bound)
void	tuplesort_end (Tuplesortstate *state)
static bool	grow_memtuples (Tuplesortstate *state)
void	tuplesort_puttupleslot (Tuplesortstate *state, TupleTableSlot *slot)
void	tuplesort_putheaptuple (Tuplesortstate *state, HeapTuple tup)
void	tuplesort_putindextuplevalues (Tuplesortstate *state, Relation rel, ItemPointer self, Datum *values, bool *isnull)
void	tuplesort_putdatum (Tuplesortstate *state, Datum val, bool isNull)
void	tuplesort_performsort (Tuplesortstate *state)
static bool	tuplesort_gettuple_common (Tuplesortstate *state, bool forward, SortTuple *stup)
bool	tuplesort_gettupleslot (Tuplesortstate *state, bool forward, bool copy, TupleTableSlot *slot, Datum *abbrev)
HeapTuple	tuplesort_getheaptuple (Tuplesortstate *state, bool forward)
IndexTuple	tuplesort_getindextuple (Tuplesortstate *state, bool forward)
bool	tuplesort_getdatum (Tuplesortstate *state, bool forward, Datum *val, bool *isNull, Datum *abbrev)
bool	tuplesort_skiptuples (Tuplesortstate *state, int64 ntuples, bool forward)
int	tuplesort_merge_order (int64 allowedMem)
void	tuplesort_rescan (Tuplesortstate *state)
void	tuplesort_markpos (Tuplesortstate *state)
void	tuplesort_restorepos (Tuplesortstate *state)
void	tuplesort_get_stats (Tuplesortstate *state, TuplesortInstrumentation *stats)
const char *	tuplesort_method_name (TuplesortMethod m)
const char *	tuplesort_space_type_name (TuplesortSpaceType t)

Variables
bool	trace_sort = false

Macro Definition Documentation

#define CLUSTER_SORT   3

Definition at line 151 of file tuplesort.c.

Referenced by tuplesort_begin_cluster().

#define COMPARETUP	(		state,
			a,
			b
	)		((*(state)->comparetup) (a, b, state))

Definition at line 520 of file tuplesort.c.

Referenced by make_bounded_heap(), and puttuple_common().

#define COPYTUP	(		state,
			stup,
			tup
	)		((*(state)->copytup) (state, stup, tup))

Definition at line 521 of file tuplesort.c.

Referenced by tuplesort_putheaptuple(), and tuplesort_puttupleslot().

#define DATUM_SORT   2

Definition at line 150 of file tuplesort.c.

Referenced by tuplesort_begin_datum().

#define FREEMEM	(		state,
			amt
	)		((state)->availMem += (amt))

Definition at line 526 of file tuplesort.c.

Referenced by free_sort_tuple(), grow_memtuples(), mergeruns(), writetup_cluster(), writetup_datum(), writetup_heap(), and writetup_index().

#define HEAP_RUN_NEXT   INT_MAX

Definition at line 262 of file tuplesort.c.

Referenced by dumptuples(), and puttuple_common().

#define HEAP_SORT   0

Definition at line 148 of file tuplesort.c.

Referenced by tuplesort_begin_heap().

#define HEAPCOMPARE	(		tup1,
			tup2
	)

Value:

(checkIndex && ((tup1)->tupindex != (tup2)->tupindex || \
                    (tup1)->tupindex == HEAP_RUN_NEXT) ? \
     ((tup1)->tupindex) - ((tup2)->tupindex) : \
	 COMPARETUP(state, tup1, tup2))

Definition at line 3320 of file tuplesort.c.

Referenced by tuplesort_heap_insert(), and tuplesort_heap_replace_top().

#define INDEX_SORT   1

Definition at line 149 of file tuplesort.c.

Referenced by tuplesort_begin_index_btree().

#define IS_SLAB_SLOT	(		state,
			tuple
	)

Value:

((char *) (tuple) >= (state)->slabMemoryBegin && \
     (char *) (tuple) < (state)->slabMemoryEnd)

Definition at line 500 of file tuplesort.c.

#define LACKMEM

(

state

)

((state)->availMem < 0 && !(state)->slabAllocatorUsed)

Definition at line 524 of file tuplesort.c.

Referenced by dumptuples(), grow_memtuples(), puttuple_common(), and tuplesort_begin_common().

#define LogicalTapeReadExact	(		tapeset,
			tapenum,
			ptr,
			len
	)

Value:

do { \
        if (LogicalTapeRead(tapeset, tapenum, ptr, len) != (size_t) (len)) \
			elog(ERROR, "unexpected end of data"); \
    } while(0)

Definition at line 576 of file tuplesort.c.

Referenced by readtup_cluster(), readtup_datum(), readtup_heap(), and readtup_index().

#define MAXORDER   500 /* maximum merge order */

Definition at line 252 of file tuplesort.c.

Referenced by tuplesort_merge_order().

#define MERGE_BUFFER_SIZE   (BLCKSZ * 32)

Definition at line 254 of file tuplesort.c.

Referenced by tuplesort_merge_order().

#define MINORDER   6 /* minimum merge order */

Definition at line 251 of file tuplesort.c.

Referenced by tuplesort_merge_order().

#define READTUP	(		state,
			stup,
			tape,
			len
	)		((*(state)->readtup) (state, stup, tape, len))

Definition at line 523 of file tuplesort.c.

Referenced by mergereadnext(), and tuplesort_gettuple_common().

#define RELEASE_SLAB_SLOT	(		state,
			tuple
	)

Value:

do { \
		SlabSlot *buf = (SlabSlot *) tuple; \
        \
        if (IS_SLAB_SLOT((state), buf)) \
        { \
			buf->nextfree = (state)->slabFreeHead; \
            (state)->slabFreeHead = buf; \
        } else \
			pfree(buf); \
    } while(0)

Definition at line 508 of file tuplesort.c.

Referenced by mergeonerun(), and tuplesort_gettuple_common().

#define RUN_FIRST   0

Definition at line 261 of file tuplesort.c.

Referenced by dumptuples(), inittapes(), puttuple_common(), tuplesort_begin_common(), tuplesort_heap_delete_top(), tuplesort_heap_insert(), and tuplesort_heap_replace_top().

#define RUN_SECOND   1

Definition at line 263 of file tuplesort.c.

Referenced by dumptuples(), and mergeruns().

#define SLAB_SLOT_SIZE   1024

Definition at line 218 of file tuplesort.c.

Referenced by init_slab_allocator(), and readtup_alloc().

#define TAPE_BUFFER_OVERHEAD   BLCKSZ

Definition at line 253 of file tuplesort.c.

Referenced by inittapes(), mergeruns(), and tuplesort_merge_order().

#define USEMEM	(		state,
			amt
	)		((state)->availMem -= (amt))

Definition at line 525 of file tuplesort.c.

Referenced by copytup_cluster(), copytup_heap(), copytup_index(), grow_memtuples(), init_slab_allocator(), inittapes(), mergeruns(), tuplesort_begin_common(), tuplesort_putdatum(), and tuplesort_putindextuplevalues().

#define WRITETUP	(		state,
			tape,
			stup
	)		((*(state)->writetup) (state, tape, stup))

Definition at line 522 of file tuplesort.c.

Referenced by dumpbatch(), dumptuples(), and mergeonerun().

Typedef Documentation

typedef union SlabSlot SlabSlot

typedef int(* SortTupleComparator)(const SortTuple *a, const SortTuple *b, Tuplesortstate *state)

Definition at line 265 of file tuplesort.c.

Enumeration Type Documentation

enum TupSortStatus

Enumerator
TSS_INITIAL
TSS_BOUNDED
TSS_BUILDRUNS
TSS_SORTEDINMEM
TSS_SORTEDONTAPE
TSS_FINALMERGE

Definition at line 230 of file tuplesort.c.

{
    TSS_INITIAL,                /* Loading tuples; still within memory limit */
    TSS_BOUNDED,                /* Loading tuples into bounded-size heap */
    TSS_BUILDRUNS,              /* Loading tuples; writing to tape */
    TSS_SORTEDINMEM,            /* Sort completed entirely in memory */
    TSS_SORTEDONTAPE,           /* Sort completed, final run is on tape */
    TSS_FINALMERGE              /* Performing final merge on-the-fly */
} TupSortStatus;

Function Documentation

static void beginmerge ( Tuplesortstate *  state )

static

Definition at line 2858 of file tuplesort.c.

References Tuplesortstate::activeTapes, Assert, Tuplesortstate::maxTapes, Tuplesortstate::memtupcount, Tuplesortstate::mergeactive, mergereadnext(), Tuplesortstate::tapeRange, Tuplesortstate::tp_dummy, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, SortTuple::tupindex, and tuplesort_heap_insert().

Referenced by mergeonerun(), and mergeruns().

{
    int         activeTapes;
    int         tapenum;
    int         srcTape;

    /* Heap should be empty here */
    Assert(state->memtupcount == 0);

    /* Adjust run counts and mark the active tapes */
    memset(state->mergeactive, 0,
           state->maxTapes * sizeof(*state->mergeactive));
    activeTapes = 0;
    for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
    {
        if (state->tp_dummy[tapenum] > 0)
            state->tp_dummy[tapenum]--;
        else
        {
            Assert(state->tp_runs[tapenum] > 0);
            state->tp_runs[tapenum]--;
            srcTape = state->tp_tapenum[tapenum];
            state->mergeactive[srcTape] = true;
            activeTapes++;
        }
    }
    Assert(activeTapes > 0);
    state->activeTapes = activeTapes;

    /* Load the merge heap with the first tuple from each input tape */
    for (srcTape = 0; srcTape < state->maxTapes; srcTape++)
    {
        SortTuple   tup;

        if (mergereadnext(state, srcTape, &tup))
        {
            tup.tupindex = srcTape;
            tuplesort_heap_insert(state, &tup, false);
        }
    }
}

static int comparetup_cluster ( const SortTuple *  a, const SortTuple *  b, Tuplesortstate *  state  )

static

Definition at line 3833 of file tuplesort.c.

References SortSupportData::abbrev_converter, ApplySortAbbrevFullComparator(), ApplySortComparator(), compare(), SortTuple::datum1, Tuplesortstate::estate, ExecStoreTuple(), FormIndexDatum(), GetPerTupleExprContext, heap_getattr, IndexInfo::ii_Expressions, IndexInfo::ii_KeyAttrNumbers, INDEX_MAX_KEYS, Tuplesortstate::indexInfo, InvalidBuffer, SortTuple::isnull1, Tuplesortstate::nKeys, ResetPerTupleExprContext, Tuplesortstate::sortKeys, Tuplesortstate::tupDesc, and SortTuple::tuple.

Referenced by tuplesort_begin_cluster().

{
    SortSupport sortKey = state->sortKeys;
    HeapTuple   ltup;
    HeapTuple   rtup;
    TupleDesc   tupDesc;
    int         nkey;
    int32       compare;
    Datum       datum1,
                datum2;
    bool        isnull1,
                isnull2;
    AttrNumber  leading = state->indexInfo->ii_KeyAttrNumbers[0];

    /* Be prepared to compare additional sort keys */
    ltup = (HeapTuple) a->tuple;
    rtup = (HeapTuple) b->tuple;
    tupDesc = state->tupDesc;

    /* Compare the leading sort key, if it's simple */
    if (leading != 0)
    {
        compare = ApplySortComparator(a->datum1, a->isnull1,
                                      b->datum1, b->isnull1,
                                      sortKey);
        if (compare != 0)
            return compare;

        if (sortKey->abbrev_converter)
        {
            datum1 = heap_getattr(ltup, leading, tupDesc, &isnull1);
            datum2 = heap_getattr(rtup, leading, tupDesc, &isnull2);

            compare = ApplySortAbbrevFullComparator(datum1, isnull1,
                                                    datum2, isnull2,
                                                    sortKey);
        }
        if (compare != 0 || state->nKeys == 1)
            return compare;
        /* Compare additional columns the hard way */
        sortKey++;
        nkey = 1;
    }
    else
    {
        /* Must compare all keys the hard way */
        nkey = 0;
    }

    if (state->indexInfo->ii_Expressions == NULL)
    {
        /* If not expression index, just compare the proper heap attrs */

        for (; nkey < state->nKeys; nkey++, sortKey++)
        {
            AttrNumber  attno = state->indexInfo->ii_KeyAttrNumbers[nkey];

            datum1 = heap_getattr(ltup, attno, tupDesc, &isnull1);
            datum2 = heap_getattr(rtup, attno, tupDesc, &isnull2);

            compare = ApplySortComparator(datum1, isnull1,
                                          datum2, isnull2,
                                          sortKey);
            if (compare != 0)
                return compare;
        }
    }
    else
    {
        /*
         * In the expression index case, compute the whole index tuple and
         * then compare values.  It would perhaps be faster to compute only as
         * many columns as we need to compare, but that would require
         * duplicating all the logic in FormIndexDatum.
         */
        Datum       l_index_values[INDEX_MAX_KEYS];
        bool        l_index_isnull[INDEX_MAX_KEYS];
        Datum       r_index_values[INDEX_MAX_KEYS];
        bool        r_index_isnull[INDEX_MAX_KEYS];
        TupleTableSlot *ecxt_scantuple;

        /* Reset context each time to prevent memory leakage */
        ResetPerTupleExprContext(state->estate);

        ecxt_scantuple = GetPerTupleExprContext(state->estate)->ecxt_scantuple;

        ExecStoreTuple(ltup, ecxt_scantuple, InvalidBuffer, false);
        FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
                       l_index_values, l_index_isnull);

        ExecStoreTuple(rtup, ecxt_scantuple, InvalidBuffer, false);
        FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
                       r_index_values, r_index_isnull);

        for (; nkey < state->nKeys; nkey++, sortKey++)
        {
            compare = ApplySortComparator(l_index_values[nkey],
                                          l_index_isnull[nkey],
                                          r_index_values[nkey],
                                          r_index_isnull[nkey],
                                          sortKey);
            if (compare != 0)
                return compare;
        }
    }

    return 0;
}

static int comparetup_datum ( const SortTuple *  a, const SortTuple *  b, Tuplesortstate *  state  )

static

Definition at line 4372 of file tuplesort.c.

References SortSupportData::abbrev_converter, ApplySortAbbrevFullComparator(), ApplySortComparator(), compare(), SortTuple::datum1, SortTuple::isnull1, PointerGetDatum, Tuplesortstate::sortKeys, and SortTuple::tuple.

Referenced by tuplesort_begin_datum().

{
    int         compare;

    compare = ApplySortComparator(a->datum1, a->isnull1,
                                  b->datum1, b->isnull1,
                                  state->sortKeys);
    if (compare != 0)
        return compare;

    /* if we have abbreviations, then "tuple" has the original value */

    if (state->sortKeys->abbrev_converter)
        compare = ApplySortAbbrevFullComparator(PointerGetDatum(a->tuple), a->isnull1,
                                                PointerGetDatum(b->tuple), b->isnull1,
                                                state->sortKeys);

    return compare;
}

static int comparetup_heap ( const SortTuple *  a, const SortTuple *  b, Tuplesortstate *  state  )

static

Definition at line 3634 of file tuplesort.c.

References SortSupportData::abbrev_converter, ApplySortAbbrevFullComparator(), ApplySortComparator(), compare(), SortTuple::datum1, heap_getattr, SortTuple::isnull1, MINIMAL_TUPLE_OFFSET, Tuplesortstate::nKeys, Tuplesortstate::sortKeys, SortSupportData::ssup_attno, HeapTupleData::t_data, HeapTupleData::t_len, Tuplesortstate::tupDesc, and SortTuple::tuple.

Referenced by tuplesort_begin_heap().

{
    SortSupport sortKey = state->sortKeys;
    HeapTupleData ltup;
    HeapTupleData rtup;
    TupleDesc   tupDesc;
    int         nkey;
    int32       compare;
    AttrNumber  attno;
    Datum       datum1,
                datum2;
    bool        isnull1,
                isnull2;


    /* Compare the leading sort key */
    compare = ApplySortComparator(a->datum1, a->isnull1,
                                  b->datum1, b->isnull1,
                                  sortKey);
    if (compare != 0)
        return compare;

    /* Compare additional sort keys */
    ltup.t_len = ((MinimalTuple) a->tuple)->t_len + MINIMAL_TUPLE_OFFSET;
    ltup.t_data = (HeapTupleHeader) ((char *) a->tuple - MINIMAL_TUPLE_OFFSET);
    rtup.t_len = ((MinimalTuple) b->tuple)->t_len + MINIMAL_TUPLE_OFFSET;
    rtup.t_data = (HeapTupleHeader) ((char *) b->tuple - MINIMAL_TUPLE_OFFSET);
    tupDesc = state->tupDesc;

    if (sortKey->abbrev_converter)
    {
        attno = sortKey->ssup_attno;

        datum1 = heap_getattr(&ltup, attno, tupDesc, &isnull1);
        datum2 = heap_getattr(&rtup, attno, tupDesc, &isnull2);

        compare = ApplySortAbbrevFullComparator(datum1, isnull1,
                                                datum2, isnull2,
                                                sortKey);
        if (compare != 0)
            return compare;
    }

    sortKey++;
    for (nkey = 1; nkey < state->nKeys; nkey++, sortKey++)
    {
        attno = sortKey->ssup_attno;

        datum1 = heap_getattr(&ltup, attno, tupDesc, &isnull1);
        datum2 = heap_getattr(&rtup, attno, tupDesc, &isnull2);

        compare = ApplySortComparator(datum1, isnull1,
                                      datum2, isnull2,
                                      sortKey);
        if (compare != 0)
            return compare;
    }

    return 0;
}

static int comparetup_index_btree ( const SortTuple *  a, const SortTuple *  b, Tuplesortstate *  state  )

static

Definition at line 4079 of file tuplesort.c.

References SortSupportData::abbrev_converter, ApplySortAbbrevFullComparator(), ApplySortComparator(), Assert, BuildIndexValueDescription(), compare(), SortTuple::datum1, Tuplesortstate::enforceUnique, ereport, errcode(), errdetail(), errmsg(), ERROR, errtableconstraint(), Tuplesortstate::heapRel, index_deform_tuple(), index_getattr, INDEX_MAX_KEYS, Tuplesortstate::indexRel, SortTuple::isnull1, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, Tuplesortstate::nKeys, RelationGetDescr, RelationGetRelationName, Tuplesortstate::sortKeys, IndexTupleData::t_tid, SortTuple::tuple, and values.

Referenced by tuplesort_begin_index_btree().

{
    /*
     * This is similar to comparetup_heap(), but expects index tuples.  There
     * is also special handling for enforcing uniqueness, and special
     * treatment for equal keys at the end.
     */
    SortSupport sortKey = state->sortKeys;
    IndexTuple  tuple1;
    IndexTuple  tuple2;
    int         keysz;
    TupleDesc   tupDes;
    bool        equal_hasnull = false;
    int         nkey;
    int32       compare;
    Datum       datum1,
                datum2;
    bool        isnull1,
                isnull2;


    /* Compare the leading sort key */
    compare = ApplySortComparator(a->datum1, a->isnull1,
                                  b->datum1, b->isnull1,
                                  sortKey);
    if (compare != 0)
        return compare;

    /* Compare additional sort keys */
    tuple1 = (IndexTuple) a->tuple;
    tuple2 = (IndexTuple) b->tuple;
    keysz = state->nKeys;
    tupDes = RelationGetDescr(state->indexRel);

    if (sortKey->abbrev_converter)
    {
        datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
        datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);

        compare = ApplySortAbbrevFullComparator(datum1, isnull1,
                                                datum2, isnull2,
                                                sortKey);
        if (compare != 0)
            return compare;
    }

    /* they are equal, so we only need to examine one null flag */
    if (a->isnull1)
        equal_hasnull = true;

    sortKey++;
    for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
    {
        datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
        datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);

        compare = ApplySortComparator(datum1, isnull1,
                                      datum2, isnull2,
                                      sortKey);
        if (compare != 0)
            return compare;     /* done when we find unequal attributes */

        /* they are equal, so we only need to examine one null flag */
        if (isnull1)
            equal_hasnull = true;
    }

    /*
     * If btree has asked us to enforce uniqueness, complain if two equal
     * tuples are detected (unless there was at least one NULL field).
     *
     * It is sufficient to make the test here, because if two tuples are equal
     * they *must* get compared at some stage of the sort --- otherwise the
     * sort algorithm wouldn't have checked whether one must appear before the
     * other.
     */
    if (state->enforceUnique && !equal_hasnull)
    {
        Datum       values[INDEX_MAX_KEYS];
        bool        isnull[INDEX_MAX_KEYS];
        char       *key_desc;

        /*
         * Some rather brain-dead implementations of qsort (such as the one in
         * QNX 4) will sometimes call the comparison routine to compare a
         * value to itself, but we always use our own implementation, which
         * does not.
         */
        Assert(tuple1 != tuple2);

        index_deform_tuple(tuple1, tupDes, values, isnull);

        key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);

        ereport(ERROR,
                (errcode(ERRCODE_UNIQUE_VIOLATION),
                 errmsg("could not create unique index \"%s\"",
                        RelationGetRelationName(state->indexRel)),
                 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
                 errdetail("Duplicate keys exist."),
                 errtableconstraint(state->heapRel,
                                    RelationGetRelationName(state->indexRel))));
    }

    /*
     * If key values are equal, we sort on ItemPointer.  This does not affect
     * validity of the finished index, but it may be useful to have index
     * scans in physical order.
     */
    {
        BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
        BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);

        if (blk1 != blk2)
            return (blk1 < blk2) ? -1 : 1;
    }
    {
        OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
        OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);

        if (pos1 != pos2)
            return (pos1 < pos2) ? -1 : 1;
    }

    return 0;
}

static int comparetup_index_hash ( const SortTuple *  a, const SortTuple *  b, Tuplesortstate *  state  )

static

Definition at line 4208 of file tuplesort.c.

References _hash_hashkey2bucket(), Assert, SortTuple::datum1, DatumGetUInt32, Tuplesortstate::high_mask, SortTuple::isnull1, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, Tuplesortstate::low_mask, Tuplesortstate::max_buckets, IndexTupleData::t_tid, and SortTuple::tuple.

Referenced by tuplesort_begin_index_hash().

{
    Bucket      bucket1;
    Bucket      bucket2;
    IndexTuple  tuple1;
    IndexTuple  tuple2;

    /*
     * Fetch hash keys and mask off bits we don't want to sort by. We know
     * that the first column of the index tuple is the hash key.
     */
    Assert(!a->isnull1);
    bucket1 = _hash_hashkey2bucket(DatumGetUInt32(a->datum1),
                                   state->max_buckets, state->high_mask,
                                   state->low_mask);
    Assert(!b->isnull1);
    bucket2 = _hash_hashkey2bucket(DatumGetUInt32(b->datum1),
                                   state->max_buckets, state->high_mask,
                                   state->low_mask);
    if (bucket1 > bucket2)
        return 1;
    else if (bucket1 < bucket2)
        return -1;

    /*
     * If hash values are equal, we sort on ItemPointer.  This does not affect
     * validity of the finished index, but it may be useful to have index
     * scans in physical order.
     */
    tuple1 = (IndexTuple) a->tuple;
    tuple2 = (IndexTuple) b->tuple;

    {
        BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
        BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);

        if (blk1 != blk2)
            return (blk1 < blk2) ? -1 : 1;
    }
    {
        OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
        OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);

        if (pos1 != pos2)
            return (pos1 < pos2) ? -1 : 1;
    }

    return 0;
}

static bool consider_abort_common ( Tuplesortstate *  state )

static

Definition at line 1729 of file tuplesort.c.

References SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, Tuplesortstate::abbrevNext, Assert, SortSupportData::comparator, Tuplesortstate::memtupcount, Tuplesortstate::sortKeys, Tuplesortstate::status, and TSS_INITIAL.

Referenced by copytup_cluster(), copytup_heap(), copytup_index(), tuplesort_putdatum(), and tuplesort_putindextuplevalues().

{
    Assert(state->sortKeys[0].abbrev_converter != NULL);
    Assert(state->sortKeys[0].abbrev_abort != NULL);
    Assert(state->sortKeys[0].abbrev_full_comparator != NULL);

    /*
     * Check effectiveness of abbreviation optimization.  Consider aborting
     * when still within memory limit.
     */
    if (state->status == TSS_INITIAL &&
        state->memtupcount >= state->abbrevNext)
    {
        state->abbrevNext *= 2;

        /*
         * Check opclass-supplied abbreviation abort routine.  It may indicate
         * that abbreviation should not proceed.
         */
        if (!state->sortKeys->abbrev_abort(state->memtupcount,
                                           state->sortKeys))
            return false;

        /*
         * Finally, restore authoritative comparator, and indicate that
         * abbreviation is not in play by setting abbrev_converter to NULL
         */
        state->sortKeys[0].comparator = state->sortKeys[0].abbrev_full_comparator;
        state->sortKeys[0].abbrev_converter = NULL;
        /* Not strictly necessary, but be tidy */
        state->sortKeys[0].abbrev_abort = NULL;
        state->sortKeys[0].abbrev_full_comparator = NULL;

        /* Give up - expect original pass-by-value representation */
        return true;
    }

    return false;
}

static void copytup_cluster ( Tuplesortstate *  state, SortTuple *  stup, void *  tup  )

static

Definition at line 3944 of file tuplesort.c.

References SortSupportData::abbrev_converter, consider_abort_common(), SortTuple::datum1, GetMemoryChunkSpace(), heap_copytuple(), heap_getattr, i, IndexInfo::ii_KeyAttrNumbers, Tuplesortstate::indexInfo, SortTuple::isnull1, MemoryContextSwitchTo(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::sortKeys, Tuplesortstate::tupDesc, SortTuple::tuple, Tuplesortstate::tuplecontext, and USEMEM.

Referenced by tuplesort_begin_cluster().

{
    HeapTuple   tuple = (HeapTuple) tup;
    Datum       original;
    MemoryContext oldcontext = MemoryContextSwitchTo(state->tuplecontext);

    /* copy the tuple into sort storage */
    tuple = heap_copytuple(tuple);
    stup->tuple = (void *) tuple;
    USEMEM(state, GetMemoryChunkSpace(tuple));

    MemoryContextSwitchTo(oldcontext);

    /*
     * set up first-column key value, and potentially abbreviate, if it's a
     * simple column
     */
    if (state->indexInfo->ii_KeyAttrNumbers[0] == 0)
        return;

    original = heap_getattr(tuple,
                            state->indexInfo->ii_KeyAttrNumbers[0],
                            state->tupDesc,
                            &stup->isnull1);

    if (!state->sortKeys->abbrev_converter || stup->isnull1)
    {
        /*
         * Store ordinary Datum representation, or NULL value.  If there is a
         * converter it won't expect NULL values, and cost model is not
         * required to account for NULL, so in that case we avoid calling
         * converter and just set datum1 to zeroed representation (to be
         * consistent, and to support cheap inequality tests for NULL
         * abbreviated keys).
         */
        stup->datum1 = original;
    }
    else if (!consider_abort_common(state))
    {
        /* Store abbreviated key representation */
        stup->datum1 = state->sortKeys->abbrev_converter(original,
                                                         state->sortKeys);
    }
    else
    {
        /* Abort abbreviation */
        int         i;

        stup->datum1 = original;

        /*
         * Set state to be consistent with never trying abbreviation.
         *
         * Alter datum1 representation in already-copied tuples, so as to
         * ensure a consistent representation (current tuple was just
         * handled).  It does not matter if some dumped tuples are already
         * sorted on tape, since serialized tuples lack abbreviated keys
         * (TSS_BUILDRUNS state prevents control reaching here in any case).
         */
        for (i = 0; i < state->memtupcount; i++)
        {
            SortTuple  *mtup = &state->memtuples[i];

            tuple = (HeapTuple) mtup->tuple;
            mtup->datum1 = heap_getattr(tuple,
                                        state->indexInfo->ii_KeyAttrNumbers[0],
                                        state->tupDesc,
                                        &mtup->isnull1);
        }
    }
}

static void copytup_datum ( Tuplesortstate *  state, SortTuple *  stup, void *  tup  )

static

Definition at line 4393 of file tuplesort.c.

References elog, and ERROR.

Referenced by tuplesort_begin_datum().

{
    /* Not currently needed */
    elog(ERROR, "copytup_datum() should not be called");
}

static void copytup_heap ( Tuplesortstate *  state, SortTuple *  stup, void *  tup  )

static

Definition at line 3696 of file tuplesort.c.

References SortSupportData::abbrev_converter, consider_abort_common(), SortTuple::datum1, ExecCopySlotMinimalTuple(), GetMemoryChunkSpace(), heap_getattr, i, SortTuple::isnull1, MemoryContextSwitchTo(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, MINIMAL_TUPLE_OFFSET, Tuplesortstate::sortKeys, SortSupportData::ssup_attno, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, Tuplesortstate::tupDesc, SortTuple::tuple, Tuplesortstate::tuplecontext, and USEMEM.

Referenced by tuplesort_begin_heap().

{
    /*
     * We expect the passed "tup" to be a TupleTableSlot, and form a
     * MinimalTuple using the exported interface for that.
     */
    TupleTableSlot *slot = (TupleTableSlot *) tup;
    Datum       original;
    MinimalTuple tuple;
    HeapTupleData htup;
    MemoryContext oldcontext = MemoryContextSwitchTo(state->tuplecontext);

    /* copy the tuple into sort storage */
    tuple = ExecCopySlotMinimalTuple(slot);
    stup->tuple = (void *) tuple;
    USEMEM(state, GetMemoryChunkSpace(tuple));
    /* set up first-column key value */
    htup.t_len = tuple->t_len + MINIMAL_TUPLE_OFFSET;
    htup.t_data = (HeapTupleHeader) ((char *) tuple - MINIMAL_TUPLE_OFFSET);
    original = heap_getattr(&htup,
                            state->sortKeys[0].ssup_attno,
                            state->tupDesc,
                            &stup->isnull1);

    MemoryContextSwitchTo(oldcontext);

    if (!state->sortKeys->abbrev_converter || stup->isnull1)
    {
        /*
         * Store ordinary Datum representation, or NULL value.  If there is a
         * converter it won't expect NULL values, and cost model is not
         * required to account for NULL, so in that case we avoid calling
         * converter and just set datum1 to zeroed representation (to be
         * consistent, and to support cheap inequality tests for NULL
         * abbreviated keys).
         */
        stup->datum1 = original;
    }
    else if (!consider_abort_common(state))
    {
        /* Store abbreviated key representation */
        stup->datum1 = state->sortKeys->abbrev_converter(original,
                                                         state->sortKeys);
    }
    else
    {
        /* Abort abbreviation */
        int         i;

        stup->datum1 = original;

        /*
         * Set state to be consistent with never trying abbreviation.
         *
         * Alter datum1 representation in already-copied tuples, so as to
         * ensure a consistent representation (current tuple was just
         * handled).  It does not matter if some dumped tuples are already
         * sorted on tape, since serialized tuples lack abbreviated keys
         * (TSS_BUILDRUNS state prevents control reaching here in any case).
         */
        for (i = 0; i < state->memtupcount; i++)
        {
            SortTuple  *mtup = &state->memtuples[i];

            htup.t_len = ((MinimalTuple) mtup->tuple)->t_len +
                MINIMAL_TUPLE_OFFSET;
            htup.t_data = (HeapTupleHeader) ((char *) mtup->tuple -
                                             MINIMAL_TUPLE_OFFSET);

            mtup->datum1 = heap_getattr(&htup,
                                        state->sortKeys[0].ssup_attno,
                                        state->tupDesc,
                                        &mtup->isnull1);
        }
    }
}

static void copytup_index ( Tuplesortstate *  state, SortTuple *  stup, void *  tup  )

static

Definition at line 4260 of file tuplesort.c.

References SortSupportData::abbrev_converter, consider_abort_common(), SortTuple::datum1, GetMemoryChunkSpace(), i, index_getattr, Tuplesortstate::indexRel, IndexTupleSize, SortTuple::isnull1, MemoryContextAlloc(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, RelationGetDescr, Tuplesortstate::sortKeys, SortTuple::tuple, Tuplesortstate::tuplecontext, and USEMEM.

Referenced by tuplesort_begin_index_btree(), and tuplesort_begin_index_hash().

{
    IndexTuple  tuple = (IndexTuple) tup;
    unsigned int tuplen = IndexTupleSize(tuple);
    IndexTuple  newtuple;
    Datum       original;

    /* copy the tuple into sort storage */
    newtuple = (IndexTuple) MemoryContextAlloc(state->tuplecontext, tuplen);
    memcpy(newtuple, tuple, tuplen);
    USEMEM(state, GetMemoryChunkSpace(newtuple));
    stup->tuple = (void *) newtuple;
    /* set up first-column key value */
    original = index_getattr(newtuple,
                             1,
                             RelationGetDescr(state->indexRel),
                             &stup->isnull1);

    if (!state->sortKeys->abbrev_converter || stup->isnull1)
    {
        /*
         * Store ordinary Datum representation, or NULL value.  If there is a
         * converter it won't expect NULL values, and cost model is not
         * required to account for NULL, so in that case we avoid calling
         * converter and just set datum1 to zeroed representation (to be
         * consistent, and to support cheap inequality tests for NULL
         * abbreviated keys).
         */
        stup->datum1 = original;
    }
    else if (!consider_abort_common(state))
    {
        /* Store abbreviated key representation */
        stup->datum1 = state->sortKeys->abbrev_converter(original,
                                                         state->sortKeys);
    }
    else
    {
        /* Abort abbreviation */
        int         i;

        stup->datum1 = original;

        /*
         * Set state to be consistent with never trying abbreviation.
         *
         * Alter datum1 representation in already-copied tuples, so as to
         * ensure a consistent representation (current tuple was just
         * handled).  It does not matter if some dumped tuples are already
         * sorted on tape, since serialized tuples lack abbreviated keys
         * (TSS_BUILDRUNS state prevents control reaching here in any case).
         */
        for (i = 0; i < state->memtupcount; i++)
        {
            SortTuple  *mtup = &state->memtuples[i];

            tuple = (IndexTuple) mtup->tuple;
            mtup->datum1 = index_getattr(tuple,
                                         1,
                                         RelationGetDescr(state->indexRel),
                                         &mtup->isnull1);
        }
    }
}

static void dumpbatch ( Tuplesortstate *  state, bool  alltuples  )

static

Definition at line 3038 of file tuplesort.c.

References Assert, Tuplesortstate::currentRun, Tuplesortstate::destTape, elog, ereport, errcode(), errmsg(), ERROR, i, LOG, markrunend(), MemoryContextReset(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, pg_rusage_show(), Tuplesortstate::ru_start, selectnewtape(), Tuplesortstate::status, Tuplesortstate::tp_dummy, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, trace_sort, TSS_BUILDRUNS, Tuplesortstate::tuplecontext, tuplesort_sort_memtuples(), and WRITETUP.

Referenced by dumptuples().

{
    int         memtupwrite;
    int         i;

    /*
     * Final call might require no sorting, in rare cases where we just so
     * happen to have previously LACKMEM()'d at the point where exactly all
     * remaining tuples are loaded into memory, just before input was
     * exhausted.
     *
     * In general, short final runs are quite possible.  Rather than allowing
     * a special case where there was a superfluous selectnewtape() call (i.e.
     * a call with no subsequent run actually written to destTape), we prefer
     * to write out a 0 tuple run.
     *
     * mergereadnext() is prepared for 0 tuple runs, and will reliably mark
     * the tape inactive for the merge when called from beginmerge().  This
     * case is therefore similar to the case where mergeonerun() finds a dummy
     * run for the tape, and so doesn't need to merge a run from the tape (or
     * conceptually "merges" the dummy run, if you prefer).  According to
     * Knuth, Algorithm D "isn't strictly optimal" in its method of
     * distribution and dummy run assignment; this edge case seems very
     * unlikely to make that appreciably worse.
     */
    Assert(state->status == TSS_BUILDRUNS);

    /*
     * It seems unlikely that this limit will ever be exceeded, but take no
     * chances
     */
    if (state->currentRun == INT_MAX)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("cannot have more than %d runs for an external sort",
                        INT_MAX)));

    state->currentRun++;

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "starting quicksort of run %d: %s",
             state->currentRun, pg_rusage_show(&state->ru_start));
#endif

    /*
     * Sort all tuples accumulated within the allowed amount of memory for
     * this run using quicksort
     */
    tuplesort_sort_memtuples(state);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "finished quicksort of run %d: %s",
             state->currentRun, pg_rusage_show(&state->ru_start));
#endif

    memtupwrite = state->memtupcount;
    for (i = 0; i < memtupwrite; i++)
    {
        WRITETUP(state, state->tp_tapenum[state->destTape],
                 &state->memtuples[i]);
        state->memtupcount--;
    }

    /*
     * Reset tuple memory.  We've freed all of the tuples that we previously
     * allocated.  It's important to avoid fragmentation when there is a stark
     * change in the sizes of incoming tuples.  Fragmentation due to
     * AllocSetFree's bucketing by size class might be particularly bad if
     * this step wasn't taken.
     */
    MemoryContextReset(state->tuplecontext);

    markrunend(state, state->tp_tapenum[state->destTape]);
    state->tp_runs[state->destTape]++;
    state->tp_dummy[state->destTape]--; /* per Alg D step D2 */

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "finished writing run %d to tape %d: %s",
             state->currentRun, state->destTape,
             pg_rusage_show(&state->ru_start));
#endif

    if (!alltuples)
        selectnewtape(state);
}

static void dumptuples ( Tuplesortstate *  state, bool  alltuples  )

static

Definition at line 2946 of file tuplesort.c.

References Assert, Tuplesortstate::currentRun, Tuplesortstate::destTape, dumpbatch(), elog, HEAP_RUN_NEXT, LACKMEM, LOG, markrunend(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, pg_rusage_show(), Tuplesortstate::replaceActive, Tuplesortstate::ru_start, RUN_FIRST, RUN_SECOND, selectnewtape(), Tuplesortstate::tp_dummy, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, trace_sort, SortTuple::tupindex, tuplesort_heap_delete_top(), and WRITETUP.

Referenced by puttuple_common(), and tuplesort_performsort().

{
    while (alltuples ||
           (LACKMEM(state) && state->memtupcount > 1) ||
           state->memtupcount >= state->memtupsize)
    {
        if (state->replaceActive)
        {
            /*
             * Still holding out for a case favorable to replacement
             * selection. Still incrementally spilling using heap.
             *
             * Dump the heap's frontmost entry, and remove it from the heap.
             */
            Assert(state->memtupcount > 0);
            WRITETUP(state, state->tp_tapenum[state->destTape],
                     &state->memtuples[0]);
            tuplesort_heap_delete_top(state, true);
        }
        else
        {
            /*
             * Once committed to quicksorting runs, never incrementally spill
             */
            dumpbatch(state, alltuples);
            break;
        }

        /*
         * If top run number has changed, we've finished the current run (this
         * can only be the first run), and will no longer spill incrementally.
         */
        if (state->memtupcount == 0 ||
            state->memtuples[0].tupindex == HEAP_RUN_NEXT)
        {
            markrunend(state, state->tp_tapenum[state->destTape]);
            Assert(state->currentRun == RUN_FIRST);
            state->currentRun++;
            state->tp_runs[state->destTape]++;
            state->tp_dummy[state->destTape]--; /* per Alg D step D2 */

#ifdef TRACE_SORT
            if (trace_sort)
                elog(LOG, "finished incrementally writing %s run %d to tape %d: %s",
                     (state->memtupcount == 0) ? "only" : "first",
                     state->currentRun, state->destTape,
                     pg_rusage_show(&state->ru_start));
#endif

            /*
             * Done if heap is empty, which is possible when there is only one
             * long run.
             */
            Assert(state->currentRun == RUN_SECOND);
            if (state->memtupcount == 0)
            {
                /*
                 * Replacement selection best case; no final merge required,
                 * because there was only one initial run (second run has no
                 * tuples).  See RUN_SECOND case in mergeruns().
                 */
                break;
            }

            /*
             * Abandon replacement selection for second run (as well as any
             * subsequent runs).
             */
            state->replaceActive = false;

            /*
             * First tuple of next run should not be heapified, and so will
             * bear placeholder run number.  In practice this must actually be
             * the second run, which just became the currentRun, so we're
             * clear to quicksort and dump the tuples in batch next time
             * memtuples becomes full.
             */
            Assert(state->memtuples[0].tupindex == HEAP_RUN_NEXT);
            selectnewtape(state);
        }
    }
}

static void free_sort_tuple ( Tuplesortstate *  state, SortTuple *  stup  )

static

Definition at line 4481 of file tuplesort.c.

References FREEMEM, GetMemoryChunkSpace(), pfree(), and SortTuple::tuple.

Referenced by make_bounded_heap(), and puttuple_common().

{
    FREEMEM(state, GetMemoryChunkSpace(stup->tuple));
    pfree(stup->tuple);
}

static unsigned int getlen ( Tuplesortstate *  state, int  tapenum, bool  eofOK  )

static

Definition at line 3579 of file tuplesort.c.

References elog, ERROR, LogicalTapeRead(), and Tuplesortstate::tapeset.

Referenced by mergereadnext(), and tuplesort_gettuple_common().

{
    unsigned int len;

    if (LogicalTapeRead(state->tapeset, tapenum,
                        &len, sizeof(len)) != sizeof(len))
        elog(ERROR, "unexpected end of tape");
    if (len == 0 && !eofOK)
        elog(ERROR, "unexpected end of data");
    return len;
}

static bool grow_memtuples ( Tuplesortstate *  state )

static

Definition at line 1245 of file tuplesort.c.

References Tuplesortstate::allowedMem, Tuplesortstate::availMem, elog, ERROR, FREEMEM, GetMemoryChunkSpace(), Tuplesortstate::growmemtuples, LACKMEM, MaxAllocHugeSize, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, repalloc_huge(), and USEMEM.

Referenced by puttuple_common().

{
    int         newmemtupsize;
    int         memtupsize = state->memtupsize;
    int64       memNowUsed = state->allowedMem - state->availMem;

    /* Forget it if we've already maxed out memtuples, per comment above */
    if (!state->growmemtuples)
        return false;

    /* Select new value of memtupsize */
    if (memNowUsed <= state->availMem)
    {
        /*
         * We've used no more than half of allowedMem; double our usage,
         * clamping at INT_MAX tuples.
         */
        if (memtupsize < INT_MAX / 2)
            newmemtupsize = memtupsize * 2;
        else
        {
            newmemtupsize = INT_MAX;
            state->growmemtuples = false;
        }
    }
    else
    {
        /*
         * This will be the last increment of memtupsize.  Abandon doubling
         * strategy and instead increase as much as we safely can.
         *
         * To stay within allowedMem, we can't increase memtupsize by more
         * than availMem / sizeof(SortTuple) elements.  In practice, we want
         * to increase it by considerably less, because we need to leave some
         * space for the tuples to which the new array slots will refer.  We
         * assume the new tuples will be about the same size as the tuples
         * we've already seen, and thus we can extrapolate from the space
         * consumption so far to estimate an appropriate new size for the
         * memtuples array.  The optimal value might be higher or lower than
         * this estimate, but it's hard to know that in advance.  We again
         * clamp at INT_MAX tuples.
         *
         * This calculation is safe against enlarging the array so much that
         * LACKMEM becomes true, because the memory currently used includes
         * the present array; thus, there would be enough allowedMem for the
         * new array elements even if no other memory were currently used.
         *
         * We do the arithmetic in float8, because otherwise the product of
         * memtupsize and allowedMem could overflow.  Any inaccuracy in the
         * result should be insignificant; but even if we computed a
         * completely insane result, the checks below will prevent anything
         * really bad from happening.
         */
        double      grow_ratio;

        grow_ratio = (double) state->allowedMem / (double) memNowUsed;
        if (memtupsize * grow_ratio < INT_MAX)
            newmemtupsize = (int) (memtupsize * grow_ratio);
        else
            newmemtupsize = INT_MAX;

        /* We won't make any further enlargement attempts */
        state->growmemtuples = false;
    }

    /* Must enlarge array by at least one element, else report failure */
    if (newmemtupsize <= memtupsize)
        goto noalloc;

    /*
     * On a 32-bit machine, allowedMem could exceed MaxAllocHugeSize.  Clamp
     * to ensure our request won't be rejected.  Note that we can easily
     * exhaust address space before facing this outcome.  (This is presently
     * impossible due to guc.c's MAX_KILOBYTES limitation on work_mem, but
     * don't rely on that at this distance.)
     */
    if ((Size) newmemtupsize >= MaxAllocHugeSize / sizeof(SortTuple))
    {
        newmemtupsize = (int) (MaxAllocHugeSize / sizeof(SortTuple));
        state->growmemtuples = false;   /* can't grow any more */
    }

    /*
     * We need to be sure that we do not cause LACKMEM to become true, else
     * the space management algorithm will go nuts.  The code above should
     * never generate a dangerous request, but to be safe, check explicitly
     * that the array growth fits within availMem.  (We could still cause
     * LACKMEM if the memory chunk overhead associated with the memtuples
     * array were to increase.  That shouldn't happen because we chose the
     * initial array size large enough to ensure that palloc will be treating
     * both old and new arrays as separate chunks.  But we'll check LACKMEM
     * explicitly below just in case.)
     */
    if (state->availMem < (int64) ((newmemtupsize - memtupsize) * sizeof(SortTuple)))
        goto noalloc;

    /* OK, do it */
    FREEMEM(state, GetMemoryChunkSpace(state->memtuples));
    state->memtupsize = newmemtupsize;
    state->memtuples = (SortTuple *)
        repalloc_huge(state->memtuples,
                      state->memtupsize * sizeof(SortTuple));
    USEMEM(state, GetMemoryChunkSpace(state->memtuples));
    if (LACKMEM(state))
        elog(ERROR, "unexpected out-of-memory situation in tuplesort");
    return true;

noalloc:
    /* If for any reason we didn't realloc, shut off future attempts */
    state->growmemtuples = false;
    return false;
}

static void init_slab_allocator ( Tuplesortstate *  state, int  numSlots  )

static

Definition at line 2513 of file tuplesort.c.

References i, palloc(), SLAB_SLOT_SIZE, Tuplesortstate::slabAllocatorUsed, Tuplesortstate::slabFreeHead, Tuplesortstate::slabMemoryBegin, Tuplesortstate::slabMemoryEnd, and USEMEM.

Referenced by mergeruns().

{
    if (numSlots > 0)
    {
        char       *p;
        int         i;

        state->slabMemoryBegin = palloc(numSlots * SLAB_SLOT_SIZE);
        state->slabMemoryEnd = state->slabMemoryBegin +
            numSlots * SLAB_SLOT_SIZE;
        state->slabFreeHead = (SlabSlot *) state->slabMemoryBegin;
        USEMEM(state, numSlots * SLAB_SLOT_SIZE);

        p = state->slabMemoryBegin;
        for (i = 0; i < numSlots - 1; i++)
        {
            ((SlabSlot *) p)->nextfree = (SlabSlot *) (p + SLAB_SLOT_SIZE);
            p += SLAB_SLOT_SIZE;
        }
        ((SlabSlot *) p)->nextfree = NULL;
    }
    else
    {
        state->slabMemoryBegin = state->slabMemoryEnd = NULL;
        state->slabFreeHead = NULL;
    }
    state->slabAllocatorUsed = true;
}

static void inittapes ( Tuplesortstate *  state )

static

Definition at line 2367 of file tuplesort.c.

References Tuplesortstate::allowedMem, Assert, Tuplesortstate::currentRun, Tuplesortstate::destTape, elog, GetMemoryChunkSpace(), Tuplesortstate::Level, LOG, LogicalTapeSetCreate(), Tuplesortstate::maxTapes, Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::mergeactive, palloc0(), pg_rusage_show(), PrepareTempTablespaces(), Tuplesortstate::replaceActive, Tuplesortstate::ru_start, RUN_FIRST, Tuplesortstate::status, TAPE_BUFFER_OVERHEAD, Tuplesortstate::tapeRange, Tuplesortstate::tapeset, Tuplesortstate::tp_dummy, Tuplesortstate::tp_fib, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, trace_sort, TSS_BUILDRUNS, SortTuple::tupindex, tuplesort_heap_insert(), tuplesort_merge_order(), USEMEM, and useselection().

Referenced by puttuple_common().

{
    int         maxTapes,
                j;
    int64       tapeSpace;

    /* Compute number of tapes to use: merge order plus 1 */
    maxTapes = tuplesort_merge_order(state->allowedMem) + 1;

    state->maxTapes = maxTapes;
    state->tapeRange = maxTapes - 1;

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "switching to external sort with %d tapes: %s",
             maxTapes, pg_rusage_show(&state->ru_start));
#endif

    /*
     * Decrease availMem to reflect the space needed for tape buffers, when
     * writing the initial runs; but don't decrease it to the point that we
     * have no room for tuples.  (That case is only likely to occur if sorting
     * pass-by-value Datums; in all other scenarios the memtuples[] array is
     * unlikely to occupy more than half of allowedMem.  In the pass-by-value
     * case it's not important to account for tuple space, so we don't care if
     * LACKMEM becomes inaccurate.)
     */
    tapeSpace = (int64) maxTapes * TAPE_BUFFER_OVERHEAD;

    if (tapeSpace + GetMemoryChunkSpace(state->memtuples) < state->allowedMem)
        USEMEM(state, tapeSpace);

    /*
     * Make sure that the temp file(s) underlying the tape set are created in
     * suitable temp tablespaces.
     */
    PrepareTempTablespaces();

    /*
     * Create the tape set and allocate the per-tape data arrays.
     */
    state->tapeset = LogicalTapeSetCreate(maxTapes);

    state->mergeactive = (bool *) palloc0(maxTapes * sizeof(bool));
    state->tp_fib = (int *) palloc0(maxTapes * sizeof(int));
    state->tp_runs = (int *) palloc0(maxTapes * sizeof(int));
    state->tp_dummy = (int *) palloc0(maxTapes * sizeof(int));
    state->tp_tapenum = (int *) palloc0(maxTapes * sizeof(int));

    /*
     * Give replacement selection a try based on user setting.  There will be
     * a switch to a simple hybrid sort-merge strategy after the first run
     * (iff we could not output one long run).
     */
    state->replaceActive = useselection(state);

    if (state->replaceActive)
    {
        /*
         * Convert the unsorted contents of memtuples[] into a heap. Each
         * tuple is marked as belonging to run number zero.
         *
         * NOTE: we pass false for checkIndex since there's no point in
         * comparing indexes in this step, even though we do intend the
         * indexes to be part of the sort key...
         */
        int         ntuples = state->memtupcount;

#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG, "replacement selection will sort %d first run tuples",
                 state->memtupcount);
#endif
        state->memtupcount = 0; /* make the heap empty */

        for (j = 0; j < ntuples; j++)
        {
            /* Must copy source tuple to avoid possible overwrite */
            SortTuple   stup = state->memtuples[j];

            stup.tupindex = RUN_FIRST;
            tuplesort_heap_insert(state, &stup, false);
        }
        Assert(state->memtupcount == ntuples);
    }

    state->currentRun = RUN_FIRST;

    /*
     * Initialize variables of Algorithm D (step D1).
     */
    for (j = 0; j < maxTapes; j++)
    {
        state->tp_fib[j] = 1;
        state->tp_runs[j] = 0;
        state->tp_dummy[j] = 1;
        state->tp_tapenum[j] = j;
    }
    state->tp_fib[state->tapeRange] = 0;
    state->tp_dummy[state->tapeRange] = 0;

    state->Level = 1;
    state->destTape = 0;

    state->status = TSS_BUILDRUNS;
}

static void make_bounded_heap ( Tuplesortstate *  state )

static

Definition at line 3340 of file tuplesort.c.

References Assert, Tuplesortstate::bound, Tuplesortstate::bounded, CHECK_FOR_INTERRUPTS, COMPARETUP, free_sort_tuple(), i, Tuplesortstate::memtupcount, Tuplesortstate::memtuples, reversedirection(), Tuplesortstate::status, TSS_BOUNDED, TSS_INITIAL, SortTuple::tupindex, tuplesort_heap_insert(), and tuplesort_heap_replace_top().

Referenced by puttuple_common().

{
    int         tupcount = state->memtupcount;
    int         i;

    Assert(state->status == TSS_INITIAL);
    Assert(state->bounded);
    Assert(tupcount >= state->bound);

    /* Reverse sort direction so largest entry will be at root */
    reversedirection(state);

    state->memtupcount = 0;     /* make the heap empty */
    for (i = 0; i < tupcount; i++)
    {
        if (state->memtupcount < state->bound)
        {
            /* Insert next tuple into heap */
            /* Must copy source tuple to avoid possible overwrite */
            SortTuple   stup = state->memtuples[i];

            stup.tupindex = 0;  /* not used */
            tuplesort_heap_insert(state, &stup, false);
        }
        else
        {
            /*
             * The heap is full.  Replace the largest entry with the new
             * tuple, or just discard it, if it's larger than anything already
             * in the heap.
             */
            if (COMPARETUP(state, &state->memtuples[i], &state->memtuples[0]) <= 0)
            {
                free_sort_tuple(state, &state->memtuples[i]);
                CHECK_FOR_INTERRUPTS();
            }
            else
                tuplesort_heap_replace_top(state, &state->memtuples[i], false);
        }
    }

    Assert(state->memtupcount == state->bound);
    state->status = TSS_BOUNDED;
}

static void markrunend ( Tuplesortstate *  state, int  tapenum  )

static

Definition at line 3592 of file tuplesort.c.

References LogicalTapeWrite(), and Tuplesortstate::tapeset.

Referenced by dumpbatch(), dumptuples(), and mergeonerun().

{
    unsigned int len = 0;

    LogicalTapeWrite(state->tapeset, tapenum, (void *) &len, sizeof(len));
}

static void mergeonerun ( Tuplesortstate *  state )

static

Definition at line 2794 of file tuplesort.c.

References Tuplesortstate::activeTapes, beginmerge(), elog, LOG, markrunend(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, mergereadnext(), pg_rusage_show(), RELEASE_SLAB_SLOT, Tuplesortstate::ru_start, Tuplesortstate::tapeRange, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, trace_sort, SortTuple::tupindex, SortTuple::tuple, tuplesort_heap_delete_top(), tuplesort_heap_replace_top(), and WRITETUP.

Referenced by mergeruns().

{
    int         destTape = state->tp_tapenum[state->tapeRange];
    int         srcTape;

    /*
     * Start the merge by loading one tuple from each active source tape into
     * the heap.  We can also decrease the input run/dummy run counts.
     */
    beginmerge(state);

    /*
     * Execute merge by repeatedly extracting lowest tuple in heap, writing it
     * out, and replacing it with next tuple from same tape (if there is
     * another one).
     */
    while (state->memtupcount > 0)
    {
        SortTuple   stup;

        /* write the tuple to destTape */
        srcTape = state->memtuples[0].tupindex;
        WRITETUP(state, destTape, &state->memtuples[0]);

        /* recycle the slot of the tuple we just wrote out, for the next read */
        if (state->memtuples[0].tuple)
            RELEASE_SLAB_SLOT(state, state->memtuples[0].tuple);

        /*
         * pull next tuple from the tape, and replace the written-out tuple in
         * the heap with it.
         */
        if (mergereadnext(state, srcTape, &stup))
        {
            stup.tupindex = srcTape;
            tuplesort_heap_replace_top(state, &stup, false);

        }
        else
            tuplesort_heap_delete_top(state, false);
    }

    /*
     * When the heap empties, we're done.  Write an end-of-run marker on the
     * output tape, and increment its count of real runs.
     */
    markrunend(state, destTape);
    state->tp_runs[state->tapeRange]++;

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "finished %d-way merge step: %s", state->activeTapes,
             pg_rusage_show(&state->ru_start));
#endif
}

static bool mergereadnext ( Tuplesortstate *  state, int  srcTape, SortTuple *  stup  )

static

Definition at line 2906 of file tuplesort.c.

References getlen(), Tuplesortstate::mergeactive, and READTUP.

Referenced by beginmerge(), mergeonerun(), and tuplesort_gettuple_common().

{
    unsigned int tuplen;

    if (!state->mergeactive[srcTape])
        return false;           /* tape's run is already exhausted */

    /* read next tuple, if any */
    if ((tuplen = getlen(state, srcTape, true)) == 0)
    {
        state->mergeactive[srcTape] = false;
        return false;
    }
    READTUP(state, stup, srcTape, tuplen);

    return true;
}

static void mergeruns ( Tuplesortstate *  state )

static

Definition at line 2549 of file tuplesort.c.

References SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, Assert, Tuplesortstate::availMem, beginmerge(), SortSupportData::comparator, Tuplesortstate::currentRun, Tuplesortstate::destTape, elog, FREEMEM, GetMemoryChunkSpace(), init_slab_allocator(), INT64_FORMAT, Tuplesortstate::Level, LOG, LogicalTapeFreeze(), LogicalTapeRewindForRead(), LogicalTapeRewindForWrite(), LogicalTapeSetForgetFreeSpace(), Max, Tuplesortstate::maxTapes, MemoryContextDelete(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, mergeonerun(), palloc(), pfree(), Tuplesortstate::randomAccess, Tuplesortstate::read_buffer_size, Tuplesortstate::result_tape, RUN_SECOND, Tuplesortstate::sortKeys, Tuplesortstate::status, TAPE_BUFFER_OVERHEAD, Tuplesortstate::tapeRange, Tuplesortstate::tapeset, Tuplesortstate::tp_dummy, Tuplesortstate::tp_runs, Tuplesortstate::tp_tapenum, trace_sort, TSS_BUILDRUNS, TSS_FINALMERGE, TSS_SORTEDONTAPE, Tuplesortstate::tuplecontext, Tuplesortstate::tuples, and USEMEM.

Referenced by tuplesort_performsort().

{
    int         tapenum,
                svTape,
                svRuns,
                svDummy;
    int         numTapes;
    int         numInputTapes;

    Assert(state->status == TSS_BUILDRUNS);
    Assert(state->memtupcount == 0);

    if (state->sortKeys != NULL && state->sortKeys->abbrev_converter != NULL)
    {
        /*
         * If there are multiple runs to be merged, when we go to read back
         * tuples from disk, abbreviated keys will not have been stored, and
         * we don't care to regenerate them.  Disable abbreviation from this
         * point on.
         */
        state->sortKeys->abbrev_converter = NULL;
        state->sortKeys->comparator = state->sortKeys->abbrev_full_comparator;

        /* Not strictly necessary, but be tidy */
        state->sortKeys->abbrev_abort = NULL;
        state->sortKeys->abbrev_full_comparator = NULL;
    }

    /*
     * Reset tuple memory.  We've freed all the tuples that we previously
     * allocated.  We will use the slab allocator from now on.
     */
    MemoryContextDelete(state->tuplecontext);
    state->tuplecontext = NULL;

    /*
     * We no longer need a large memtuples array.  (We will allocate a smaller
     * one for the heap later.)
     */
    FREEMEM(state, GetMemoryChunkSpace(state->memtuples));
    pfree(state->memtuples);
    state->memtuples = NULL;

    /*
     * If we had fewer runs than tapes, refund the memory that we imagined we
     * would need for the tape buffers of the unused tapes.
     *
     * numTapes and numInputTapes reflect the actual number of tapes we will
     * use.  Note that the output tape's tape number is maxTapes - 1, so the
     * tape numbers of the used tapes are not consecutive, and you cannot just
     * loop from 0 to numTapes to visit all used tapes!
     */
    if (state->Level == 1)
    {
        numInputTapes = state->currentRun;
        numTapes = numInputTapes + 1;
        FREEMEM(state, (state->maxTapes - numTapes) * TAPE_BUFFER_OVERHEAD);
    }
    else
    {
        numInputTapes = state->tapeRange;
        numTapes = state->maxTapes;
    }

    /*
     * Initialize the slab allocator.  We need one slab slot per input tape,
     * for the tuples in the heap, plus one to hold the tuple last returned
     * from tuplesort_gettuple.  (If we're sorting pass-by-val Datums,
     * however, we don't need to do allocate anything.)
     *
     * From this point on, we no longer use the USEMEM()/LACKMEM() mechanism
     * to track memory usage of individual tuples.
     */
    if (state->tuples)
        init_slab_allocator(state, numInputTapes + 1);
    else
        init_slab_allocator(state, 0);

    /*
     * If we produced only one initial run (quite likely if the total data
     * volume is between 1X and 2X workMem when replacement selection is used,
     * but something we particularly count on when input is presorted), we can
     * just use that tape as the finished output, rather than doing a useless
     * merge.  (This obvious optimization is not in Knuth's algorithm.)
     */
    if (state->currentRun == RUN_SECOND)
    {
        state->result_tape = state->tp_tapenum[state->destTape];
        /* must freeze and rewind the finished output tape */
        LogicalTapeFreeze(state->tapeset, state->result_tape);
        state->status = TSS_SORTEDONTAPE;
        return;
    }

    /*
     * Allocate a new 'memtuples' array, for the heap.  It will hold one tuple
     * from each input tape.
     */
    state->memtupsize = numInputTapes;
    state->memtuples = (SortTuple *) palloc(numInputTapes * sizeof(SortTuple));
    USEMEM(state, GetMemoryChunkSpace(state->memtuples));

    /*
     * Use all the remaining memory we have available for read buffers among
     * the input tapes.
     *
     * We do this only after checking for the case that we produced only one
     * initial run, because there is no need to use a large read buffer when
     * we're reading from a single tape.  With one tape, the I/O pattern will
     * be the same regardless of the buffer size.
     *
     * We don't try to "rebalance" the memory among tapes, when we start a new
     * merge phase, even if some tapes are inactive in the new phase.  That
     * would be hard, because logtape.c doesn't know where one run ends and
     * another begins.  When a new merge phase begins, and a tape doesn't
     * participate in it, its buffer nevertheless already contains tuples from
     * the next run on same tape, so we cannot release the buffer.  That's OK
     * in practice, merge performance isn't that sensitive to the amount of
     * buffers used, and most merge phases use all or almost all tapes,
     * anyway.
     */
#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG, "using " INT64_FORMAT " KB of memory for read buffers among %d input tapes",
             (state->availMem) / 1024, numInputTapes);
#endif

    state->read_buffer_size = Max(state->availMem / numInputTapes, 0);
    USEMEM(state, state->read_buffer_size * numInputTapes);

    /* End of step D2: rewind all output tapes to prepare for merging */
    for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
        LogicalTapeRewindForRead(state->tapeset, tapenum, state->read_buffer_size);

    for (;;)
    {
        /*
         * At this point we know that tape[T] is empty.  If there's just one
         * (real or dummy) run left on each input tape, then only one merge
         * pass remains.  If we don't have to produce a materialized sorted
         * tape, we can stop at this point and do the final merge on-the-fly.
         */
        if (!state->randomAccess)
        {
            bool        allOneRun = true;

            Assert(state->tp_runs[state->tapeRange] == 0);
            for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
            {
                if (state->tp_runs[tapenum] + state->tp_dummy[tapenum] != 1)
                {
                    allOneRun = false;
                    break;
                }
            }
            if (allOneRun)
            {
                /* Tell logtape.c we won't be writing anymore */
                LogicalTapeSetForgetFreeSpace(state->tapeset);
                /* Initialize for the final merge pass */
                beginmerge(state);
                state->status = TSS_FINALMERGE;
                return;
            }
        }

        /* Step D5: merge runs onto tape[T] until tape[P] is empty */
        while (state->tp_runs[state->tapeRange - 1] ||
               state->tp_dummy[state->tapeRange - 1])
        {
            bool        allDummy = true;

            for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
            {
                if (state->tp_dummy[tapenum] == 0)
                {
                    allDummy = false;
                    break;
                }
            }

            if (allDummy)
            {
                state->tp_dummy[state->tapeRange]++;
                for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
                    state->tp_dummy[tapenum]--;
            }
            else
                mergeonerun(state);
        }

        /* Step D6: decrease level */
        if (--state->Level == 0)
            break;
        /* rewind output tape T to use as new input */
        LogicalTapeRewindForRead(state->tapeset, state->tp_tapenum[state->tapeRange],
                                 state->read_buffer_size);
        /* rewind used-up input tape P, and prepare it for write pass */
        LogicalTapeRewindForWrite(state->tapeset, state->tp_tapenum[state->tapeRange - 1]);
        state->tp_runs[state->tapeRange - 1] = 0;

        /*
         * reassign tape units per step D6; note we no longer care about A[]
         */
        svTape = state->tp_tapenum[state->tapeRange];
        svDummy = state->tp_dummy[state->tapeRange];
        svRuns = state->tp_runs[state->tapeRange];
        for (tapenum = state->tapeRange; tapenum > 0; tapenum--)
        {
            state->tp_tapenum[tapenum] = state->tp_tapenum[tapenum - 1];
            state->tp_dummy[tapenum] = state->tp_dummy[tapenum - 1];
            state->tp_runs[tapenum] = state->tp_runs[tapenum - 1];
        }
        state->tp_tapenum[0] = svTape;
        state->tp_dummy[0] = svDummy;
        state->tp_runs[0] = svRuns;
    }

    /*
     * Done.  Knuth says that the result is on TAPE[1], but since we exited
     * the loop without performing the last iteration of step D6, we have not
     * rearranged the tape unit assignment, and therefore the result is on
     * TAPE[T].  We need to do it this way so that we can freeze the final
     * output tape while rewinding it.  The last iteration of step D6 would be
     * a waste of cycles anyway...
     */
    state->result_tape = state->tp_tapenum[state->tapeRange];
    LogicalTapeFreeze(state->tapeset, state->result_tape);
    state->status = TSS_SORTEDONTAPE;

    /* Release the read buffers of all the other tapes, by rewinding them. */
    for (tapenum = 0; tapenum < state->maxTapes; tapenum++)
    {
        if (tapenum != state->result_tape)
            LogicalTapeRewindForWrite(state->tapeset, tapenum);
    }
}

static void puttuple_common ( Tuplesortstate *  state, SortTuple *  tuple  )

static

Definition at line 1567 of file tuplesort.c.

References Assert, Tuplesortstate::bound, Tuplesortstate::bounded, CHECK_FOR_INTERRUPTS, COMPARETUP, Tuplesortstate::currentRun, dumptuples(), elog, ERROR, free_sort_tuple(), grow_memtuples(), HEAP_RUN_NEXT, inittapes(), LACKMEM, LOG, make_bounded_heap(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, pg_rusage_show(), Tuplesortstate::replaceActive, Tuplesortstate::ru_start, RUN_FIRST, Tuplesortstate::status, trace_sort, TSS_BOUNDED, TSS_BUILDRUNS, TSS_INITIAL, SortTuple::tupindex, tuplesort_heap_insert(), and tuplesort_heap_replace_top().

Referenced by tuplesort_putdatum(), tuplesort_putheaptuple(), tuplesort_putindextuplevalues(), and tuplesort_puttupleslot().

{
    switch (state->status)
    {
        case TSS_INITIAL:

            /*
             * Save the tuple into the unsorted array.  First, grow the array
             * as needed.  Note that we try to grow the array when there is
             * still one free slot remaining --- if we fail, there'll still be
             * room to store the incoming tuple, and then we'll switch to
             * tape-based operation.
             */
            if (state->memtupcount >= state->memtupsize - 1)
            {
                (void) grow_memtuples(state);
                Assert(state->memtupcount < state->memtupsize);
            }
            state->memtuples[state->memtupcount++] = *tuple;

            /*
             * Check if it's time to switch over to a bounded heapsort. We do
             * so if the input tuple count exceeds twice the desired tuple
             * count (this is a heuristic for where heapsort becomes cheaper
             * than a quicksort), or if we've just filled workMem and have
             * enough tuples to meet the bound.
             *
             * Note that once we enter TSS_BOUNDED state we will always try to
             * complete the sort that way.  In the worst case, if later input
             * tuples are larger than earlier ones, this might cause us to
             * exceed workMem significantly.
             */
            if (state->bounded &&
                (state->memtupcount > state->bound * 2 ||
                 (state->memtupcount > state->bound && LACKMEM(state))))
            {
#ifdef TRACE_SORT
                if (trace_sort)
                    elog(LOG, "switching to bounded heapsort at %d tuples: %s",
                         state->memtupcount,
                         pg_rusage_show(&state->ru_start));
#endif
                make_bounded_heap(state);
                return;
            }

            /*
             * Done if we still fit in available memory and have array slots.
             */
            if (state->memtupcount < state->memtupsize && !LACKMEM(state))
                return;

            /*
             * Nope; time to switch to tape-based operation.
             */
            inittapes(state);

            /*
             * Dump tuples until we are back under the limit.
             */
            dumptuples(state, false);
            break;

        case TSS_BOUNDED:

            /*
             * We don't want to grow the array here, so check whether the new
             * tuple can be discarded before putting it in.  This should be a
             * good speed optimization, too, since when there are many more
             * input tuples than the bound, most input tuples can be discarded
             * with just this one comparison.  Note that because we currently
             * have the sort direction reversed, we must check for <= not >=.
             */
            if (COMPARETUP(state, tuple, &state->memtuples[0]) <= 0)
            {
                /* new tuple <= top of the heap, so we can discard it */
                free_sort_tuple(state, tuple);
                CHECK_FOR_INTERRUPTS();
            }
            else
            {
                /* discard top of heap, replacing it with the new tuple */
                free_sort_tuple(state, &state->memtuples[0]);
                tuple->tupindex = 0;    /* not used */
                tuplesort_heap_replace_top(state, tuple, false);
            }
            break;

        case TSS_BUILDRUNS:

            /*
             * Insert the tuple into the heap, with run number currentRun if
             * it can go into the current run, else HEAP_RUN_NEXT.  The tuple
             * can go into the current run if it is >= the first
             * not-yet-output tuple.  (Actually, it could go into the current
             * run if it is >= the most recently output tuple ... but that
             * would require keeping around the tuple we last output, and it's
             * simplest to let writetup free each tuple as soon as it's
             * written.)
             *
             * Note that this only applies when:
             *
             * - currentRun is RUN_FIRST
             *
             * - Replacement selection is in use (typically it is never used).
             *
             * When these two conditions are not both true, all tuples are
             * appended indifferently, much like the TSS_INITIAL case.
             *
             * There should always be room to store the incoming tuple.
             */
            Assert(!state->replaceActive || state->memtupcount > 0);
            if (state->replaceActive &&
                COMPARETUP(state, tuple, &state->memtuples[0]) >= 0)
            {
                Assert(state->currentRun == RUN_FIRST);

                /*
                 * Insert tuple into first, fully heapified run.
                 *
                 * Unlike classic replacement selection, which this module was
                 * previously based on, only RUN_FIRST tuples are fully
                 * heapified.  Any second/next run tuples are appended
                 * indifferently.  While HEAP_RUN_NEXT tuples may be sifted
                 * out of the way of first run tuples, COMPARETUP() will never
                 * be called for the run's tuples during sifting (only our
                 * initial COMPARETUP() call is required for the tuple, to
                 * determine that the tuple does not belong in RUN_FIRST).
                 */
                tuple->tupindex = state->currentRun;
                tuplesort_heap_insert(state, tuple, true);
            }
            else
            {
                /*
                 * Tuple was determined to not belong to heapified RUN_FIRST,
                 * or replacement selection not in play.  Append the tuple to
                 * memtuples indifferently.
                 *
                 * dumptuples() does not trust that the next run's tuples are
                 * heapified.  Anything past the first run will always be
                 * quicksorted even when replacement selection is initially
                 * used.  (When it's never used, every tuple still takes this
                 * path.)
                 */
                tuple->tupindex = HEAP_RUN_NEXT;
                state->memtuples[state->memtupcount++] = *tuple;
            }

            /*
             * If we are over the memory limit, dump tuples till we're under.
             */
            dumptuples(state, false);
            break;

        default:
            elog(ERROR, "invalid tuplesort state");
            break;
    }
}

static void * readtup_alloc ( Tuplesortstate *  state, Size  tuplen  )

static

Definition at line 3606 of file tuplesort.c.

References Assert, buf, MemoryContextAlloc(), SlabSlot::nextfree, SLAB_SLOT_SIZE, Tuplesortstate::slabFreeHead, and Tuplesortstate::sortcontext.

Referenced by readtup_cluster(), readtup_datum(), readtup_heap(), and readtup_index().

{
    SlabSlot   *buf;

    /*
     * We pre-allocate enough slots in the slab arena that we should never run
     * out.
     */
    Assert(state->slabFreeHead);

    if (tuplen > SLAB_SLOT_SIZE || !state->slabFreeHead)
        return MemoryContextAlloc(state->sortcontext, tuplen);
    else
    {
        buf = state->slabFreeHead;
        /* Reuse this slot */
        state->slabFreeHead = buf->nextfree;

        return buf;
    }
}

static void readtup_cluster ( Tuplesortstate *  state, SortTuple *  stup, int  tapenum, unsigned int  len  )

static

Definition at line 4041 of file tuplesort.c.

References SortTuple::datum1, heap_getattr, HEAPTUPLESIZE, IndexInfo::ii_KeyAttrNumbers, Tuplesortstate::indexInfo, InvalidOid, SortTuple::isnull1, LogicalTapeReadExact, Tuplesortstate::randomAccess, readtup_alloc(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, Tuplesortstate::tapeset, Tuplesortstate::tupDesc, and SortTuple::tuple.

Referenced by tuplesort_begin_cluster().

{
    unsigned int t_len = tuplen - sizeof(ItemPointerData) - sizeof(int);
    HeapTuple   tuple = (HeapTuple) readtup_alloc(state,
                                                  t_len + HEAPTUPLESIZE);

    /* Reconstruct the HeapTupleData header */
    tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
    tuple->t_len = t_len;
    LogicalTapeReadExact(state->tapeset, tapenum,
                         &tuple->t_self, sizeof(ItemPointerData));
    /* We don't currently bother to reconstruct t_tableOid */
    tuple->t_tableOid = InvalidOid;
    /* Read in the tuple body */
    LogicalTapeReadExact(state->tapeset, tapenum,
                         tuple->t_data, tuple->t_len);
    if (state->randomAccess)    /* need trailing length word? */
        LogicalTapeReadExact(state->tapeset, tapenum,
                             &tuplen, sizeof(tuplen));
    stup->tuple = (void *) tuple;
    /* set up first-column key value, if it's a simple column */
    if (state->indexInfo->ii_KeyAttrNumbers[0] != 0)
        stup->datum1 = heap_getattr(tuple,
                                    state->indexInfo->ii_KeyAttrNumbers[0],
                                    state->tupDesc,
                                    &stup->isnull1);
}

static void readtup_datum ( Tuplesortstate *  state, SortTuple *  stup, int  tapenum, unsigned int  len  )

static

Definition at line 4441 of file tuplesort.c.

References Assert, SortTuple::datum1, SortTuple::isnull1, LogicalTapeReadExact, PointerGetDatum, Tuplesortstate::randomAccess, readtup_alloc(), Tuplesortstate::tapeset, SortTuple::tuple, and Tuplesortstate::tuples.

Referenced by tuplesort_begin_datum().

{
    unsigned int tuplen = len - sizeof(unsigned int);

    if (tuplen == 0)
    {
        /* it's NULL */
        stup->datum1 = (Datum) 0;
        stup->isnull1 = true;
        stup->tuple = NULL;
    }
    else if (!state->tuples)
    {
        Assert(tuplen == sizeof(Datum));
        LogicalTapeReadExact(state->tapeset, tapenum,
                             &stup->datum1, tuplen);
        stup->isnull1 = false;
        stup->tuple = NULL;
    }
    else
    {
        void       *raddr = readtup_alloc(state, tuplen);

        LogicalTapeReadExact(state->tapeset, tapenum,
                             raddr, tuplen);
        stup->datum1 = PointerGetDatum(raddr);
        stup->isnull1 = false;
        stup->tuple = raddr;
    }

    if (state->randomAccess)    /* need trailing length word? */
        LogicalTapeReadExact(state->tapeset, tapenum,
                             &tuplen, sizeof(tuplen));
}

static void readtup_heap ( Tuplesortstate *  state, SortTuple *  stup, int  tapenum, unsigned int  len  )

static

Definition at line 3801 of file tuplesort.c.

References SortTuple::datum1, heap_getattr, SortTuple::isnull1, LogicalTapeReadExact, MINIMAL_TUPLE_DATA_OFFSET, MINIMAL_TUPLE_OFFSET, Tuplesortstate::randomAccess, readtup_alloc(), Tuplesortstate::sortKeys, SortSupportData::ssup_attno, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, Tuplesortstate::tapeset, Tuplesortstate::tupDesc, and SortTuple::tuple.

Referenced by tuplesort_begin_heap().

{
    unsigned int tupbodylen = len - sizeof(int);
    unsigned int tuplen = tupbodylen + MINIMAL_TUPLE_DATA_OFFSET;
    MinimalTuple tuple = (MinimalTuple) readtup_alloc(state, tuplen);
    char       *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
    HeapTupleData htup;

    /* read in the tuple proper */
    tuple->t_len = tuplen;
    LogicalTapeReadExact(state->tapeset, tapenum,
                         tupbody, tupbodylen);
    if (state->randomAccess)    /* need trailing length word? */
        LogicalTapeReadExact(state->tapeset, tapenum,
                             &tuplen, sizeof(tuplen));
    stup->tuple = (void *) tuple;
    /* set up first-column key value */
    htup.t_len = tuple->t_len + MINIMAL_TUPLE_OFFSET;
    htup.t_data = (HeapTupleHeader) ((char *) tuple - MINIMAL_TUPLE_OFFSET);
    stup->datum1 = heap_getattr(&htup,
                                state->sortKeys[0].ssup_attno,
                                state->tupDesc,
                                &stup->isnull1);
}

static void readtup_index ( Tuplesortstate *  state, SortTuple *  stup, int  tapenum, unsigned int  len  )

static

Definition at line 4348 of file tuplesort.c.

References SortTuple::datum1, index_getattr, Tuplesortstate::indexRel, SortTuple::isnull1, LogicalTapeReadExact, Tuplesortstate::randomAccess, readtup_alloc(), RelationGetDescr, Tuplesortstate::tapeset, and SortTuple::tuple.

Referenced by tuplesort_begin_index_btree(), and tuplesort_begin_index_hash().

{
    unsigned int tuplen = len - sizeof(unsigned int);
    IndexTuple  tuple = (IndexTuple) readtup_alloc(state, tuplen);

    LogicalTapeReadExact(state->tapeset, tapenum,
                         tuple, tuplen);
    if (state->randomAccess)    /* need trailing length word? */
        LogicalTapeReadExact(state->tapeset, tapenum,
                             &tuplen, sizeof(tuplen));
    stup->tuple = (void *) tuple;
    /* set up first-column key value */
    stup->datum1 = index_getattr(tuple,
                                 1,
                                 RelationGetDescr(state->indexRel),
                                 &stup->isnull1);
}

static void reversedirection ( Tuplesortstate *  state )

static

Definition at line 3561 of file tuplesort.c.

References Tuplesortstate::nKeys, Tuplesortstate::sortKeys, SortSupportData::ssup_nulls_first, and SortSupportData::ssup_reverse.

Referenced by make_bounded_heap(), and sort_bounded_heap().

{
    SortSupport sortKey = state->sortKeys;
    int         nkey;

    for (nkey = 0; nkey < state->nKeys; nkey++, sortKey++)
    {
        sortKey->ssup_reverse = !sortKey->ssup_reverse;
        sortKey->ssup_nulls_first = !sortKey->ssup_nulls_first;
    }
}

static void selectnewtape ( Tuplesortstate *  state )

static

Definition at line 2481 of file tuplesort.c.

References Tuplesortstate::destTape, Tuplesortstate::Level, Tuplesortstate::tapeRange, Tuplesortstate::tp_dummy, and Tuplesortstate::tp_fib.

Referenced by dumpbatch(), and dumptuples().

{
    int         j;
    int         a;

    /* Step D3: advance j (destTape) */
    if (state->tp_dummy[state->destTape] < state->tp_dummy[state->destTape + 1])
    {
        state->destTape++;
        return;
    }
    if (state->tp_dummy[state->destTape] != 0)
    {
        state->destTape = 0;
        return;
    }

    /* Step D4: increase level */
    state->Level++;
    a = state->tp_fib[0];
    for (j = 0; j < state->tapeRange; j++)
    {
        state->tp_dummy[j] = a + state->tp_fib[j + 1] - state->tp_fib[j];
        state->tp_fib[j] = a + state->tp_fib[j + 1];
    }
    state->destTape = 0;
}

static void sort_bounded_heap ( Tuplesortstate *  state )

static

Definition at line 3389 of file tuplesort.c.

References Assert, Tuplesortstate::bound, Tuplesortstate::bounded, Tuplesortstate::boundUsed, Tuplesortstate::memtupcount, Tuplesortstate::memtuples, reversedirection(), Tuplesortstate::status, TSS_BOUNDED, TSS_SORTEDINMEM, and tuplesort_heap_delete_top().

Referenced by tuplesort_performsort().

{
    int         tupcount = state->memtupcount;

    Assert(state->status == TSS_BOUNDED);
    Assert(state->bounded);
    Assert(tupcount == state->bound);

    /*
     * We can unheapify in place because each delete-top call will remove the
     * largest entry, which we can promptly store in the newly freed slot at
     * the end.  Once we're down to a single-entry heap, we're done.
     */
    while (state->memtupcount > 1)
    {
        SortTuple   stup = state->memtuples[0];

        /* this sifts-up the next-largest entry and decreases memtupcount */
        tuplesort_heap_delete_top(state, false);
        state->memtuples[state->memtupcount] = stup;
    }
    state->memtupcount = tupcount;

    /*
     * Reverse sort direction back to the original state.  This is not
     * actually necessary but seems like a good idea for tidiness.
     */
    reversedirection(state);

    state->status = TSS_SORTEDINMEM;
    state->boundUsed = true;
}

Tuplesortstate* tuplesort_begin_cluster	(	TupleDesc	tupDesc,
		Relation	indexRel,
		int	workMem,
		bool	randomAccess
	)

Definition at line 828 of file tuplesort.c.

References _bt_freeskey(), _bt_mkscankey_nodata(), SortSupportData::abbreviate, Tuplesortstate::abbrevNext, Assert, AssertState, BTGreaterStrategyNumber, BTLessStrategyNumber, BTREE_AM_OID, BuildIndexInfo(), CLUSTER_SORT, Tuplesortstate::comparetup, comparetup_cluster(), Tuplesortstate::copytup, copytup_cluster(), CreateExecutorState(), CurrentMemoryContext, ExprContext::ecxt_scantuple, elog, Tuplesortstate::estate, GetPerTupleExprContext, i, IndexInfo::ii_Expressions, Tuplesortstate::indexInfo, LOG, MakeSingleTupleTableSlot(), MemoryContextSwitchTo(), Tuplesortstate::nKeys, palloc0(), PrepareSortSupportFromIndexRel(), RelationData::rd_rel, Tuplesortstate::readtup, readtup_cluster(), RelationGetNumberOfAttributes, ScanKeyData::sk_attno, SK_BT_DESC, SK_BT_NULLS_FIRST, ScanKeyData::sk_collation, ScanKeyData::sk_flags, Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, trace_sort, Tuplesortstate::tupDesc, tuplesort_begin_common(), Tuplesortstate::writetup, and writetup_cluster().

Referenced by copy_heap_data().

{
    Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess);
    ScanKey     indexScanKey;
    MemoryContext oldcontext;
    int         i;

    Assert(indexRel->rd_rel->relam == BTREE_AM_OID);

    oldcontext = MemoryContextSwitchTo(state->sortcontext);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "begin tuple sort: nkeys = %d, workMem = %d, randomAccess = %c",
             RelationGetNumberOfAttributes(indexRel),
             workMem, randomAccess ? 't' : 'f');
#endif

    state->nKeys = RelationGetNumberOfAttributes(indexRel);

    TRACE_POSTGRESQL_SORT_START(CLUSTER_SORT,
                                false,  /* no unique check */
                                state->nKeys,
                                workMem,
                                randomAccess);

    state->comparetup = comparetup_cluster;
    state->copytup = copytup_cluster;
    state->writetup = writetup_cluster;
    state->readtup = readtup_cluster;
    state->abbrevNext = 10;

    state->indexInfo = BuildIndexInfo(indexRel);

    state->tupDesc = tupDesc;   /* assume we need not copy tupDesc */

    indexScanKey = _bt_mkscankey_nodata(indexRel);

    if (state->indexInfo->ii_Expressions != NULL)
    {
        TupleTableSlot *slot;
        ExprContext *econtext;

        /*
         * We will need to use FormIndexDatum to evaluate the index
         * expressions.  To do that, we need an EState, as well as a
         * TupleTableSlot to put the table tuples into.  The econtext's
         * scantuple has to point to that slot, too.
         */
        state->estate = CreateExecutorState();
        slot = MakeSingleTupleTableSlot(tupDesc);
        econtext = GetPerTupleExprContext(state->estate);
        econtext->ecxt_scantuple = slot;
    }

    /* Prepare SortSupport data for each column */
    state->sortKeys = (SortSupport) palloc0(state->nKeys *
                                            sizeof(SortSupportData));

    for (i = 0; i < state->nKeys; i++)
    {
        SortSupport sortKey = state->sortKeys + i;
        ScanKey     scanKey = indexScanKey + i;
        int16       strategy;

        sortKey->ssup_cxt = CurrentMemoryContext;
        sortKey->ssup_collation = scanKey->sk_collation;
        sortKey->ssup_nulls_first =
            (scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
        sortKey->ssup_attno = scanKey->sk_attno;
        /* Convey if abbreviation optimization is applicable in principle */
        sortKey->abbreviate = (i == 0);

        AssertState(sortKey->ssup_attno != 0);

        strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
            BTGreaterStrategyNumber : BTLessStrategyNumber;

        PrepareSortSupportFromIndexRel(indexRel, strategy, sortKey);
    }

    _bt_freeskey(indexScanKey);

    MemoryContextSwitchTo(oldcontext);

    return state;
}

static Tuplesortstate * tuplesort_begin_common ( int  workMem, bool  randomAccess  )

static

Definition at line 670 of file tuplesort.c.

References ALLOCSET_DEFAULT_SIZES, ALLOCSET_SEPARATE_THRESHOLD, AllocSetContextCreate(), Tuplesortstate::allowedMem, Tuplesortstate::availMem, Tuplesortstate::bounded, Tuplesortstate::boundUsed, CurrentMemoryContext, Tuplesortstate::currentRun, elog, ERROR, GetMemoryChunkSpace(), Tuplesortstate::growmemtuples, LACKMEM, Max, MemoryContextSwitchTo(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, palloc(), palloc0(), pg_rusage_init(), Tuplesortstate::randomAccess, Tuplesortstate::result_tape, Tuplesortstate::ru_start, RUN_FIRST, Tuplesortstate::slabAllocatorUsed, Tuplesortstate::sortcontext, Tuplesortstate::status, Tuplesortstate::tapeset, trace_sort, TSS_INITIAL, Tuplesortstate::tuplecontext, Tuplesortstate::tuples, and USEMEM.

Referenced by tuplesort_begin_cluster(), tuplesort_begin_datum(), tuplesort_begin_heap(), tuplesort_begin_index_btree(), and tuplesort_begin_index_hash().

{
    Tuplesortstate *state;
    MemoryContext sortcontext;
    MemoryContext tuplecontext;
    MemoryContext oldcontext;

    /*
     * Create a working memory context for this sort operation. All data
     * needed by the sort will live inside this context.
     */
    sortcontext = AllocSetContextCreate(CurrentMemoryContext,
                                        "TupleSort main",
                                        ALLOCSET_DEFAULT_SIZES);

    /*
     * Caller tuple (e.g. IndexTuple) memory context.
     *
     * A dedicated child context used exclusively for caller passed tuples
     * eases memory management.  Resetting at key points reduces
     * fragmentation. Note that the memtuples array of SortTuples is allocated
     * in the parent context, not this context, because there is no need to
     * free memtuples early.
     */
    tuplecontext = AllocSetContextCreate(sortcontext,
                                         "Caller tuples",
                                         ALLOCSET_DEFAULT_SIZES);

    /*
     * Make the Tuplesortstate within the per-sort context.  This way, we
     * don't need a separate pfree() operation for it at shutdown.
     */
    oldcontext = MemoryContextSwitchTo(sortcontext);

    state = (Tuplesortstate *) palloc0(sizeof(Tuplesortstate));

#ifdef TRACE_SORT
    if (trace_sort)
        pg_rusage_init(&state->ru_start);
#endif

    state->status = TSS_INITIAL;
    state->randomAccess = randomAccess;
    state->bounded = false;
    state->tuples = true;
    state->boundUsed = false;
    state->allowedMem = workMem * (int64) 1024;
    state->availMem = state->allowedMem;
    state->sortcontext = sortcontext;
    state->tuplecontext = tuplecontext;
    state->tapeset = NULL;

    state->memtupcount = 0;

    /*
     * Initial size of array must be more than ALLOCSET_SEPARATE_THRESHOLD;
     * see comments in grow_memtuples().
     */
    state->memtupsize = Max(1024,
                            ALLOCSET_SEPARATE_THRESHOLD / sizeof(SortTuple) + 1);

    state->growmemtuples = true;
    state->slabAllocatorUsed = false;
    state->memtuples = (SortTuple *) palloc(state->memtupsize * sizeof(SortTuple));

    USEMEM(state, GetMemoryChunkSpace(state->memtuples));

    /* workMem must be large enough for the minimal memtuples array */
    if (LACKMEM(state))
        elog(ERROR, "insufficient memory allowed for sort");

    state->currentRun = RUN_FIRST;

    /*
     * maxTapes, tapeRange, and Algorithm D variables will be initialized by
     * inittapes(), if needed
     */

    state->result_tape = -1;    /* flag that result tape has not been formed */

    MemoryContextSwitchTo(oldcontext);

    return state;
}

Tuplesortstate* tuplesort_begin_datum	(	Oid	datumType,
		Oid	sortOperator,
		Oid	sortCollation,
		bool	nullsFirstFlag,
		int	workMem,
		bool	randomAccess
	)

Definition at line 1038 of file tuplesort.c.

References SortSupportData::abbrev_converter, SortSupportData::abbreviate, Tuplesortstate::abbrevNext, Tuplesortstate::comparetup, comparetup_datum(), Tuplesortstate::copytup, copytup_datum(), CurrentMemoryContext, DATUM_SORT, Tuplesortstate::datumType, Tuplesortstate::datumTypeLen, elog, get_typlenbyval(), LOG, MemoryContextSwitchTo(), Tuplesortstate::nKeys, Tuplesortstate::onlyKey, palloc0(), PrepareSortSupportFromOrderingOp(), Tuplesortstate::readtup, readtup_datum(), Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, trace_sort, Tuplesortstate::tuples, tuplesort_begin_common(), Tuplesortstate::writetup, and writetup_datum().

Referenced by initialize_aggregate(), ordered_set_startup(), and validate_index().

{
    Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess);
    MemoryContext oldcontext;
    int16       typlen;
    bool        typbyval;

    oldcontext = MemoryContextSwitchTo(state->sortcontext);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "begin datum sort: workMem = %d, randomAccess = %c",
             workMem, randomAccess ? 't' : 'f');
#endif

    state->nKeys = 1;           /* always a one-column sort */

    TRACE_POSTGRESQL_SORT_START(DATUM_SORT,
                                false,  /* no unique check */
                                1,
                                workMem,
                                randomAccess);

    state->comparetup = comparetup_datum;
    state->copytup = copytup_datum;
    state->writetup = writetup_datum;
    state->readtup = readtup_datum;
    state->abbrevNext = 10;

    state->datumType = datumType;

    /* lookup necessary attributes of the datum type */
    get_typlenbyval(datumType, &typlen, &typbyval);
    state->datumTypeLen = typlen;
    state->tuples = !typbyval;

    /* Prepare SortSupport data */
    state->sortKeys = (SortSupport) palloc0(sizeof(SortSupportData));

    state->sortKeys->ssup_cxt = CurrentMemoryContext;
    state->sortKeys->ssup_collation = sortCollation;
    state->sortKeys->ssup_nulls_first = nullsFirstFlag;

    /*
     * Abbreviation is possible here only for by-reference types.  In theory,
     * a pass-by-value datatype could have an abbreviated form that is cheaper
     * to compare.  In a tuple sort, we could support that, because we can
     * always extract the original datum from the tuple is needed.  Here, we
     * can't, because a datum sort only stores a single copy of the datum; the
     * "tuple" field of each sortTuple is NULL.
     */
    state->sortKeys->abbreviate = !typbyval;

    PrepareSortSupportFromOrderingOp(sortOperator, state->sortKeys);

    /*
     * The "onlyKey" optimization cannot be used with abbreviated keys, since
     * tie-breaker comparisons may be required.  Typically, the optimization
     * is only of value to pass-by-value types anyway, whereas abbreviated
     * keys are typically only of value to pass-by-reference types.
     */
    if (!state->sortKeys->abbrev_converter)
        state->onlyKey = state->sortKeys;

    MemoryContextSwitchTo(oldcontext);

    return state;
}

Tuplesortstate* tuplesort_begin_heap	(	TupleDesc	tupDesc,
		int	nkeys,
		AttrNumber *	attNums,
		Oid *	sortOperators,
		Oid *	sortCollations,
		bool *	nullsFirstFlags,
		int	workMem,
		bool	randomAccess
	)

Definition at line 756 of file tuplesort.c.

References SortSupportData::abbrev_converter, SortSupportData::abbreviate, Tuplesortstate::abbrevNext, AssertArg, Tuplesortstate::comparetup, comparetup_heap(), Tuplesortstate::copytup, copytup_heap(), CurrentMemoryContext, elog, HEAP_SORT, i, LOG, MemoryContextSwitchTo(), Tuplesortstate::nKeys, Tuplesortstate::onlyKey, palloc0(), PrepareSortSupportFromOrderingOp(), Tuplesortstate::readtup, readtup_heap(), Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, trace_sort, Tuplesortstate::tupDesc, tuplesort_begin_common(), Tuplesortstate::writetup, and writetup_heap().

Referenced by ExecSort(), initialize_aggregate(), initialize_phase(), and ordered_set_startup().

{
    Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess);
    MemoryContext oldcontext;
    int         i;

    oldcontext = MemoryContextSwitchTo(state->sortcontext);

    AssertArg(nkeys > 0);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "begin tuple sort: nkeys = %d, workMem = %d, randomAccess = %c",
             nkeys, workMem, randomAccess ? 't' : 'f');
#endif

    state->nKeys = nkeys;

    TRACE_POSTGRESQL_SORT_START(HEAP_SORT,
                                false,  /* no unique check */
                                nkeys,
                                workMem,
                                randomAccess);

    state->comparetup = comparetup_heap;
    state->copytup = copytup_heap;
    state->writetup = writetup_heap;
    state->readtup = readtup_heap;

    state->tupDesc = tupDesc;   /* assume we need not copy tupDesc */
    state->abbrevNext = 10;

    /* Prepare SortSupport data for each column */
    state->sortKeys = (SortSupport) palloc0(nkeys * sizeof(SortSupportData));

    for (i = 0; i < nkeys; i++)
    {
        SortSupport sortKey = state->sortKeys + i;

        AssertArg(attNums[i] != 0);
        AssertArg(sortOperators[i] != 0);

        sortKey->ssup_cxt = CurrentMemoryContext;
        sortKey->ssup_collation = sortCollations[i];
        sortKey->ssup_nulls_first = nullsFirstFlags[i];
        sortKey->ssup_attno = attNums[i];
        /* Convey if abbreviation optimization is applicable in principle */
        sortKey->abbreviate = (i == 0);

        PrepareSortSupportFromOrderingOp(sortOperators[i], sortKey);
    }

    /*
     * The "onlyKey" optimization cannot be used with abbreviated keys, since
     * tie-breaker comparisons may be required.  Typically, the optimization
     * is only of value to pass-by-value types anyway, whereas abbreviated
     * keys are typically only of value to pass-by-reference types.
     */
    if (nkeys == 1 && !state->sortKeys->abbrev_converter)
        state->onlyKey = state->sortKeys;

    MemoryContextSwitchTo(oldcontext);

    return state;
}

Tuplesortstate* tuplesort_begin_index_btree	(	Relation	heapRel,
		Relation	indexRel,
		bool	enforceUnique,
		int	workMem,
		bool	randomAccess
	)

Definition at line 920 of file tuplesort.c.

References _bt_freeskey(), _bt_mkscankey_nodata(), SortSupportData::abbreviate, Tuplesortstate::abbrevNext, AssertState, BTGreaterStrategyNumber, BTLessStrategyNumber, Tuplesortstate::comparetup, comparetup_index_btree(), Tuplesortstate::copytup, copytup_index(), CurrentMemoryContext, elog, Tuplesortstate::enforceUnique, Tuplesortstate::heapRel, i, INDEX_SORT, Tuplesortstate::indexRel, LOG, MemoryContextSwitchTo(), Tuplesortstate::nKeys, palloc0(), PrepareSortSupportFromIndexRel(), Tuplesortstate::readtup, readtup_index(), RelationGetNumberOfAttributes, ScanKeyData::sk_attno, SK_BT_DESC, SK_BT_NULLS_FIRST, ScanKeyData::sk_collation, ScanKeyData::sk_flags, Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, trace_sort, tuplesort_begin_common(), Tuplesortstate::writetup, and writetup_index().

Referenced by _bt_spoolinit().

{
    Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess);
    ScanKey     indexScanKey;
    MemoryContext oldcontext;
    int         i;

    oldcontext = MemoryContextSwitchTo(state->sortcontext);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "begin index sort: unique = %c, workMem = %d, randomAccess = %c",
             enforceUnique ? 't' : 'f',
             workMem, randomAccess ? 't' : 'f');
#endif

    state->nKeys = RelationGetNumberOfAttributes(indexRel);

    TRACE_POSTGRESQL_SORT_START(INDEX_SORT,
                                enforceUnique,
                                state->nKeys,
                                workMem,
                                randomAccess);

    state->comparetup = comparetup_index_btree;
    state->copytup = copytup_index;
    state->writetup = writetup_index;
    state->readtup = readtup_index;
    state->abbrevNext = 10;

    state->heapRel = heapRel;
    state->indexRel = indexRel;
    state->enforceUnique = enforceUnique;

    indexScanKey = _bt_mkscankey_nodata(indexRel);
    state->nKeys = RelationGetNumberOfAttributes(indexRel);

    /* Prepare SortSupport data for each column */
    state->sortKeys = (SortSupport) palloc0(state->nKeys *
                                            sizeof(SortSupportData));

    for (i = 0; i < state->nKeys; i++)
    {
        SortSupport sortKey = state->sortKeys + i;
        ScanKey     scanKey = indexScanKey + i;
        int16       strategy;

        sortKey->ssup_cxt = CurrentMemoryContext;
        sortKey->ssup_collation = scanKey->sk_collation;
        sortKey->ssup_nulls_first =
            (scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
        sortKey->ssup_attno = scanKey->sk_attno;
        /* Convey if abbreviation optimization is applicable in principle */
        sortKey->abbreviate = (i == 0);

        AssertState(sortKey->ssup_attno != 0);

        strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
            BTGreaterStrategyNumber : BTLessStrategyNumber;

        PrepareSortSupportFromIndexRel(indexRel, strategy, sortKey);
    }

    _bt_freeskey(indexScanKey);

    MemoryContextSwitchTo(oldcontext);

    return state;
}

Tuplesortstate* tuplesort_begin_index_hash	(	Relation	heapRel,
		Relation	indexRel,
		uint32	high_mask,
		uint32	low_mask,
		uint32	max_buckets,
		int	workMem,
		bool	randomAccess
	)

Definition at line 995 of file tuplesort.c.

References Tuplesortstate::comparetup, comparetup_index_hash(), Tuplesortstate::copytup, copytup_index(), elog, Tuplesortstate::heapRel, Tuplesortstate::high_mask, Tuplesortstate::indexRel, LOG, Tuplesortstate::low_mask, Tuplesortstate::max_buckets, MemoryContextSwitchTo(), Tuplesortstate::nKeys, Tuplesortstate::readtup, readtup_index(), Tuplesortstate::sortcontext, trace_sort, tuplesort_begin_common(), Tuplesortstate::writetup, and writetup_index().

Referenced by _h_spoolinit().

{
    Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess);
    MemoryContext oldcontext;

    oldcontext = MemoryContextSwitchTo(state->sortcontext);

#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "begin index sort: high_mask = 0x%x, low_mask = 0x%x, "
             "max_buckets = 0x%x, workMem = %d, randomAccess = %c",
             high_mask,
             low_mask,
             max_buckets,
             workMem, randomAccess ? 't' : 'f');
#endif

    state->nKeys = 1;           /* Only one sort column, the hash code */

    state->comparetup = comparetup_index_hash;
    state->copytup = copytup_index;
    state->writetup = writetup_index;
    state->readtup = readtup_index;

    state->heapRel = heapRel;
    state->indexRel = indexRel;

    state->high_mask = high_mask;
    state->low_mask = low_mask;
    state->max_buckets = max_buckets;

    MemoryContextSwitchTo(oldcontext);

    return state;
}

void tuplesort_end

(

Tuplesortstate *

state

)

Definition at line 1167 of file tuplesort.c.

References Tuplesortstate::allowedMem, Tuplesortstate::availMem, ExprContext::ecxt_scantuple, elog, Tuplesortstate::estate, ExecDropSingleTupleTableSlot(), FreeExecutorState(), GetPerTupleExprContext, LOG, LogicalTapeSetBlocks(), LogicalTapeSetClose(), MemoryContextDelete(), MemoryContextSwitchTo(), pg_rusage_show(), Tuplesortstate::ru_start, Tuplesortstate::sortcontext, Tuplesortstate::tapeset, and trace_sort.

Referenced by _bt_spooldestroy(), _h_spooldestroy(), copy_heap_data(), ExecEndAgg(), ExecEndSort(), ExecReScanAgg(), ExecReScanSort(), hypothetical_dense_rank_final(), hypothetical_rank_common(), initialize_aggregate(), initialize_phase(), ordered_set_shutdown(), process_ordered_aggregate_multi(), process_ordered_aggregate_single(), and validate_index().

{
    /* context swap probably not needed, but let's be safe */
    MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);

#ifdef TRACE_SORT
    long        spaceUsed;

    if (state->tapeset)
        spaceUsed = LogicalTapeSetBlocks(state->tapeset);
    else
        spaceUsed = (state->allowedMem - state->availMem + 1023) / 1024;
#endif

    /*
     * Delete temporary "tape" files, if any.
     *
     * Note: want to include this in reported total cost of sort, hence need
     * for two #ifdef TRACE_SORT sections.
     */
    if (state->tapeset)
        LogicalTapeSetClose(state->tapeset);

#ifdef TRACE_SORT
    if (trace_sort)
    {
        if (state->tapeset)
            elog(LOG, "external sort ended, %ld disk blocks used: %s",
                 spaceUsed, pg_rusage_show(&state->ru_start));
        else
            elog(LOG, "internal sort ended, %ld KB used: %s",
                 spaceUsed, pg_rusage_show(&state->ru_start));
    }

    TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, spaceUsed);
#else

    /*
     * If you disabled TRACE_SORT, you can still probe sort__done, but you
     * ain't getting space-used stats.
     */
    TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, 0L);
#endif

    /* Free any execution state created for CLUSTER case */
    if (state->estate != NULL)
    {
        ExprContext *econtext = GetPerTupleExprContext(state->estate);

        ExecDropSingleTupleTableSlot(econtext->ecxt_scantuple);
        FreeExecutorState(state->estate);
    }

    MemoryContextSwitchTo(oldcontext);

    /*
     * Free the per-sort memory context, thereby releasing all working memory,
     * including the Tuplesortstate struct itself.
     */
    MemoryContextDelete(state->sortcontext);
}

void tuplesort_get_stats	(	Tuplesortstate *	state,
		TuplesortInstrumentation *	stats
	)

Definition at line 3232 of file tuplesort.c.

References Tuplesortstate::allowedMem, Tuplesortstate::availMem, Tuplesortstate::boundUsed, LogicalTapeSetBlocks(), SORT_SPACE_TYPE_DISK, SORT_SPACE_TYPE_MEMORY, SORT_TYPE_EXTERNAL_MERGE, SORT_TYPE_EXTERNAL_SORT, SORT_TYPE_QUICKSORT, SORT_TYPE_STILL_IN_PROGRESS, SORT_TYPE_TOP_N_HEAPSORT, TuplesortInstrumentation::sortMethod, TuplesortInstrumentation::spaceType, TuplesortInstrumentation::spaceUsed, Tuplesortstate::status, Tuplesortstate::tapeset, TSS_FINALMERGE, TSS_SORTEDINMEM, and TSS_SORTEDONTAPE.

Referenced by ExecSort(), and show_sort_info().

{
    /*
     * Note: it might seem we should provide both memory and disk usage for a
     * disk-based sort.  However, the current code doesn't track memory space
     * accurately once we have begun to return tuples to the caller (since we
     * don't account for pfree's the caller is expected to do), so we cannot
     * rely on availMem in a disk sort.  This does not seem worth the overhead
     * to fix.  Is it worth creating an API for the memory context code to
     * tell us how much is actually used in sortcontext?
     */
    if (state->tapeset)
    {
        stats->spaceType = SORT_SPACE_TYPE_DISK;
        stats->spaceUsed = LogicalTapeSetBlocks(state->tapeset) * (BLCKSZ / 1024);
    }
    else
    {
        stats->spaceType = SORT_SPACE_TYPE_MEMORY;
        stats->spaceUsed = (state->allowedMem - state->availMem + 1023) / 1024;
    }

    switch (state->status)
    {
        case TSS_SORTEDINMEM:
            if (state->boundUsed)
                stats->sortMethod = SORT_TYPE_TOP_N_HEAPSORT;
            else
                stats->sortMethod = SORT_TYPE_QUICKSORT;
            break;
        case TSS_SORTEDONTAPE:
            stats->sortMethod = SORT_TYPE_EXTERNAL_SORT;
            break;
        case TSS_FINALMERGE:
            stats->sortMethod = SORT_TYPE_EXTERNAL_MERGE;
            break;
        default:
            stats->sortMethod = SORT_TYPE_STILL_IN_PROGRESS;
            break;
    }
}

bool tuplesort_getdatum	(	Tuplesortstate *	state,
		bool	forward,
		Datum *	val,
		bool *	isNull,
		Datum *	abbrev
	)

Definition at line 2199 of file tuplesort.c.

References SortSupportData::abbrev_converter, SortTuple::datum1, datumCopy(), Tuplesortstate::datumTypeLen, SortTuple::isnull1, MemoryContextSwitchTo(), PointerGetDatum, Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortTuple::tuple, Tuplesortstate::tuples, and tuplesort_gettuple_common().

Referenced by mode_final(), percentile_cont_final_common(), percentile_cont_multi_final_common(), percentile_disc_final(), percentile_disc_multi_final(), process_ordered_aggregate_single(), and validate_index_heapscan().

{
    MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
    SortTuple   stup;

    if (!tuplesort_gettuple_common(state, forward, &stup))
    {
        MemoryContextSwitchTo(oldcontext);
        return false;
    }

    /* Record abbreviated key for caller */
    if (state->sortKeys->abbrev_converter && abbrev)
        *abbrev = stup.datum1;

    if (stup.isnull1 || !state->tuples)
    {
        *val = stup.datum1;
        *isNull = stup.isnull1;
    }
    else
    {
        /* use stup.tuple because stup.datum1 may be an abbreviation */
        *val = datumCopy(PointerGetDatum(stup.tuple), false, state->datumTypeLen);
        *isNull = false;
    }

    MemoryContextSwitchTo(oldcontext);

    return true;
}

HeapTuple tuplesort_getheaptuple	(	Tuplesortstate *	state,
		bool	forward
	)

Definition at line 2150 of file tuplesort.c.

References MemoryContextSwitchTo(), Tuplesortstate::sortcontext, SortTuple::tuple, and tuplesort_gettuple_common().

Referenced by copy_heap_data().

{
    MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
    SortTuple   stup;

    if (!tuplesort_gettuple_common(state, forward, &stup))
        stup.tuple = NULL;

    MemoryContextSwitchTo(oldcontext);

    return stup.tuple;
}

IndexTuple tuplesort_getindextuple	(	Tuplesortstate *	state,
		bool	forward
	)

Definition at line 2170 of file tuplesort.c.

References MemoryContextSwitchTo(), Tuplesortstate::sortcontext, SortTuple::tuple, and tuplesort_gettuple_common().

Referenced by _bt_load(), and _h_indexbuild().

{
    MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
    SortTuple   stup;

    if (!tuplesort_gettuple_common(state, forward, &stup))
        stup.tuple = NULL;

    MemoryContextSwitchTo(oldcontext);

    return (IndexTuple) stup.tuple;
}

static bool tuplesort_gettuple_common ( Tuplesortstate *  state, bool  forward, SortTuple *  stup  )

static

Definition at line 1859 of file tuplesort.c.

References Assert, Tuplesortstate::bound, Tuplesortstate::bounded, Tuplesortstate::current, elog, Tuplesortstate::eof_reached, ERROR, getlen(), Tuplesortstate::lastReturnedTuple, LogicalTapeBackspace(), LogicalTapeRewindForWrite(), Tuplesortstate::memtupcount, Tuplesortstate::memtuples, mergereadnext(), Tuplesortstate::randomAccess, READTUP, RELEASE_SLAB_SLOT, Tuplesortstate::result_tape, Tuplesortstate::slabAllocatorUsed, Tuplesortstate::status, Tuplesortstate::tapeset, TSS_FINALMERGE, TSS_SORTEDINMEM, TSS_SORTEDONTAPE, SortTuple::tupindex, SortTuple::tuple, tuplesort_heap_delete_top(), and tuplesort_heap_replace_top().

Referenced by tuplesort_getdatum(), tuplesort_getheaptuple(), tuplesort_getindextuple(), tuplesort_gettupleslot(), and tuplesort_skiptuples().

{
    unsigned int tuplen;
    size_t      nmoved;

    switch (state->status)
    {
        case TSS_SORTEDINMEM:
            Assert(forward || state->randomAccess);
            Assert(!state->slabAllocatorUsed);
            if (forward)
            {
                if (state->current < state->memtupcount)
                {
                    *stup = state->memtuples[state->current++];
                    return true;
                }
                state->eof_reached = true;

                /*
                 * Complain if caller tries to retrieve more tuples than
                 * originally asked for in a bounded sort.  This is because
                 * returning EOF here might be the wrong thing.
                 */
                if (state->bounded && state->current >= state->bound)
                    elog(ERROR, "retrieved too many tuples in a bounded sort");

                return false;
            }
            else
            {
                if (state->current <= 0)
                    return false;

                /*
                 * if all tuples are fetched already then we return last
                 * tuple, else - tuple before last returned.
                 */
                if (state->eof_reached)
                    state->eof_reached = false;
                else
                {
                    state->current--;   /* last returned tuple */
                    if (state->current <= 0)
                        return false;
                }
                *stup = state->memtuples[state->current - 1];
                return true;
            }
            break;

        case TSS_SORTEDONTAPE:
            Assert(forward || state->randomAccess);
            Assert(state->slabAllocatorUsed);

            /*
             * The slot that held the tuple that we returned in previous
             * gettuple call can now be reused.
             */
            if (state->lastReturnedTuple)
            {
                RELEASE_SLAB_SLOT(state, state->lastReturnedTuple);
                state->lastReturnedTuple = NULL;
            }

            if (forward)
            {
                if (state->eof_reached)
                    return false;

                if ((tuplen = getlen(state, state->result_tape, true)) != 0)
                {
                    READTUP(state, stup, state->result_tape, tuplen);

                    /*
                     * Remember the tuple we return, so that we can recycle
                     * its memory on next call.  (This can be NULL, in the
                     * !state->tuples case).
                     */
                    state->lastReturnedTuple = stup->tuple;

                    return true;
                }
                else
                {
                    state->eof_reached = true;
                    return false;
                }
            }

            /*
             * Backward.
             *
             * if all tuples are fetched already then we return last tuple,
             * else - tuple before last returned.
             */
            if (state->eof_reached)
            {
                /*
                 * Seek position is pointing just past the zero tuplen at the
                 * end of file; back up to fetch last tuple's ending length
                 * word.  If seek fails we must have a completely empty file.
                 */
                nmoved = LogicalTapeBackspace(state->tapeset,
                                              state->result_tape,
                                              2 * sizeof(unsigned int));
                if (nmoved == 0)
                    return false;
                else if (nmoved != 2 * sizeof(unsigned int))
                    elog(ERROR, "unexpected tape position");
                state->eof_reached = false;
            }
            else
            {
                /*
                 * Back up and fetch previously-returned tuple's ending length
                 * word.  If seek fails, assume we are at start of file.
                 */
                nmoved = LogicalTapeBackspace(state->tapeset,
                                              state->result_tape,
                                              sizeof(unsigned int));
                if (nmoved == 0)
                    return false;
                else if (nmoved != sizeof(unsigned int))
                    elog(ERROR, "unexpected tape position");
                tuplen = getlen(state, state->result_tape, false);

                /*
                 * Back up to get ending length word of tuple before it.
                 */
                nmoved = LogicalTapeBackspace(state->tapeset,
                                              state->result_tape,
                                              tuplen + 2 * sizeof(unsigned int));
                if (nmoved == tuplen + sizeof(unsigned int))
                {
                    /*
                     * We backed up over the previous tuple, but there was no
                     * ending length word before it.  That means that the prev
                     * tuple is the first tuple in the file.  It is now the
                     * next to read in forward direction (not obviously right,
                     * but that is what in-memory case does).
                     */
                    return false;
                }
                else if (nmoved != tuplen + 2 * sizeof(unsigned int))
                    elog(ERROR, "bogus tuple length in backward scan");
            }

            tuplen = getlen(state, state->result_tape, false);

            /*
             * Now we have the length of the prior tuple, back up and read it.
             * Note: READTUP expects we are positioned after the initial
             * length word of the tuple, so back up to that point.
             */
            nmoved = LogicalTapeBackspace(state->tapeset,
                                          state->result_tape,
                                          tuplen);
            if (nmoved != tuplen)
                elog(ERROR, "bogus tuple length in backward scan");
            READTUP(state, stup, state->result_tape, tuplen);

            /*
             * Remember the tuple we return, so that we can recycle its memory
             * on next call. (This can be NULL, in the Datum case).
             */
            state->lastReturnedTuple = stup->tuple;

            return true;

        case TSS_FINALMERGE:
            Assert(forward);
            /* We are managing memory ourselves, with the slab allocator. */
            Assert(state->slabAllocatorUsed);

            /*
             * The slab slot holding the tuple that we returned in previous
             * gettuple call can now be reused.
             */
            if (state->lastReturnedTuple)
            {
                RELEASE_SLAB_SLOT(state, state->lastReturnedTuple);
                state->lastReturnedTuple = NULL;
            }

            /*
             * This code should match the inner loop of mergeonerun().
             */
            if (state->memtupcount > 0)
            {
                int         srcTape = state->memtuples[0].tupindex;
                SortTuple   newtup;

                *stup = state->memtuples[0];

                /*
                 * Remember the tuple we return, so that we can recycle its
                 * memory on next call. (This can be NULL, in the Datum case).
                 */
                state->lastReturnedTuple = stup->tuple;

                /*
                 * Pull next tuple from tape, and replace the returned tuple
                 * at top of the heap with it.
                 */
                if (!mergereadnext(state, srcTape, &newtup))
                {
                    /*
                     * If no more data, we've reached end of run on this tape.
                     * Remove the top node from the heap.
                     */
                    tuplesort_heap_delete_top(state, false);

                    /*
                     * Rewind to free the read buffer.  It'd go away at the
                     * end of the sort anyway, but better to release the
                     * memory early.
                     */
                    LogicalTapeRewindForWrite(state->tapeset, srcTape);
                    return true;
                }
                newtup.tupindex = srcTape;
                tuplesort_heap_replace_top(state, &newtup, false);
                return true;
            }
            return false;

        default:
            elog(ERROR, "invalid tuplesort state");
            return false;       /* keep compiler quiet */
    }
}

bool tuplesort_gettupleslot	(	Tuplesortstate *	state,
		bool	forward,
		bool	copy,
		TupleTableSlot *	slot,
		Datum *	abbrev
	)

Definition at line 2113 of file tuplesort.c.

References SortSupportData::abbrev_converter, SortTuple::datum1, ExecClearTuple(), ExecStoreMinimalTuple(), heap_copy_minimal_tuple(), MemoryContextSwitchTo(), Tuplesortstate::sortcontext, Tuplesortstate::sortKeys, SortTuple::tuple, and tuplesort_gettuple_common().

Referenced by ExecSort(), fetch_input_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), and process_ordered_aggregate_multi().

{
    MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
    SortTuple   stup;

    if (!tuplesort_gettuple_common(state, forward, &stup))
        stup.tuple = NULL;

    MemoryContextSwitchTo(oldcontext);

    if (stup.tuple)
    {
        /* Record abbreviated key for caller */
        if (state->sortKeys->abbrev_converter && abbrev)
            *abbrev = stup.datum1;

        if (copy)
            stup.tuple = heap_copy_minimal_tuple((MinimalTuple) stup.tuple);

        ExecStoreMinimalTuple((MinimalTuple) stup.tuple, slot, copy);
        return true;
    }
    else
    {
        ExecClearTuple(slot);
        return false;
    }
}

static void tuplesort_heap_delete_top ( Tuplesortstate *  state, bool  checkIndex  )

static

Definition at line 3494 of file tuplesort.c.

References Assert, Tuplesortstate::currentRun, Tuplesortstate::memtupcount, Tuplesortstate::memtuples, RUN_FIRST, and tuplesort_heap_replace_top().

Referenced by dumptuples(), mergeonerun(), sort_bounded_heap(), and tuplesort_gettuple_common().

{
    SortTuple  *memtuples = state->memtuples;
    SortTuple  *tuple;

    Assert(!checkIndex || state->currentRun == RUN_FIRST);
    if (--state->memtupcount <= 0)
        return;

    /*
     * Remove the last tuple in the heap, and re-insert it, by replacing the
     * current top node with it.
     */
    tuple = &memtuples[state->memtupcount];
    tuplesort_heap_replace_top(state, tuple, checkIndex);
}

static void tuplesort_heap_insert ( Tuplesortstate *  state, SortTuple *  tuple, bool  checkIndex  )

static

Definition at line 3457 of file tuplesort.c.

References Assert, CHECK_FOR_INTERRUPTS, HEAPCOMPARE, i, Tuplesortstate::memtupcount, Tuplesortstate::memtuples, Tuplesortstate::memtupsize, RUN_FIRST, and SortTuple::tupindex.

Referenced by beginmerge(), inittapes(), make_bounded_heap(), and puttuple_common().

{
    SortTuple  *memtuples;
    int         j;

    memtuples = state->memtuples;
    Assert(state->memtupcount < state->memtupsize);
    Assert(!checkIndex || tuple->tupindex == RUN_FIRST);

    CHECK_FOR_INTERRUPTS();

    /*
     * Sift-up the new entry, per Knuth 5.2.3 exercise 16. Note that Knuth is
     * using 1-based array indexes, not 0-based.
     */
    j = state->memtupcount++;
    while (j > 0)
    {
        int         i = (j - 1) >> 1;

        if (HEAPCOMPARE(tuple, &memtuples[i]) >= 0)
            break;
        memtuples[j] = memtuples[i];
        j = i;
    }
    memtuples[j] = *tuple;
}

<

static void tuplesort_heap_replace_top ( Tuplesortstate *  state, SortTuple *  tuple, bool  checkIndex  )