X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=src%2Finclude%2Futils%2Ftuplesort.h;h=5c48e0e10f593de6ef51b42c75f150eae2be9cbc;hb=c6e3ac11b60ac4a8942ab964252d51c1c0bd8845;hp=c736896a9a984c78bb552e5319568e0dbb84f2a9;hpb=d26559dbf356736923b26704ce76ca820ff3a2b0;p=postgresql diff --git a/src/include/utils/tuplesort.h b/src/include/utils/tuplesort.h index c736896a9a..5c48e0e10f 100644 --- a/src/include/utils/tuplesort.h +++ b/src/include/utils/tuplesort.h @@ -10,10 +10,10 @@ * amounts are sorted using temporary files and a standard external sort * algorithm. * - * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group + * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $PostgreSQL: pgsql/src/include/utils/tuplesort.h,v 1.26 2007/05/04 01:13:45 tgl Exp $ + * src/include/utils/tuplesort.h * *------------------------------------------------------------------------- */ @@ -22,6 +22,8 @@ #include "access/itup.h" #include "executor/tuptable.h" +#include "fmgr.h" +#include "utils/relcache.h" /* Tuplesortstate is an opaque type whose details are not known outside @@ -30,35 +32,56 @@ typedef struct Tuplesortstate Tuplesortstate; /* - * We provide two different interfaces to what is essentially the same - * code: one for sorting HeapTuples and one for sorting IndexTuples. - * They differ primarily in the way that the sort key information is - * supplied. Also, the HeapTuple case actually stores MinimalTuples, - * which means it doesn't preserve the "system columns" (tuple identity and - * transaction visibility info). The IndexTuple case does preserve all - * the header fields of an index entry. In the HeapTuple case we can - * save some cycles by passing and returning the tuples in TupleTableSlots, - * rather than forming actual HeapTuples (which'd have to be converted to - * MinimalTuples). + * We provide multiple interfaces to what is essentially the same code, + * since different callers have different data to be sorted and want to + * specify the sort key information differently. There are two APIs for + * sorting HeapTuples and two more for sorting IndexTuples. Yet another + * API supports sorting bare Datums. * - * Yet a third slightly different interface supports sorting bare Datums. + * The "heap" API actually stores/sorts MinimalTuples, which means it doesn't + * preserve the system columns (tuple identity and transaction visibility + * info). The sort keys are specified by column numbers within the tuples + * and sort operator OIDs. We save some cycles by passing and returning the + * tuples in TupleTableSlots, rather than forming actual HeapTuples (which'd + * have to be converted to MinimalTuples). This API works well for sorts + * executed as parts of plan trees. + * + * The "cluster" API stores/sorts full HeapTuples including all visibility + * info. The sort keys are specified by reference to a btree index that is + * defined on the relation to be sorted. Note that putheaptuple/getheaptuple + * go with this API, not the "begin_heap" one! + * + * The "index_btree" API stores/sorts IndexTuples (preserving all their + * header fields). The sort keys are specified by a btree index definition. + * + * The "index_hash" API is similar to index_btree, but the tuples are + * actually sorted by their hash codes not the raw data. */ extern Tuplesortstate *tuplesort_begin_heap(TupleDesc tupDesc, int nkeys, AttrNumber *attNums, - Oid *sortOperators, bool *nullsFirstFlags, + Oid *sortOperators, Oid *sortCollations, + bool *nullsFirstFlags, int workMem, bool randomAccess); -extern Tuplesortstate *tuplesort_begin_index(Relation indexRel, - bool enforceUnique, - int workMem, bool randomAccess); +extern Tuplesortstate *tuplesort_begin_cluster(TupleDesc tupDesc, + Relation indexRel, + int workMem, bool randomAccess); +extern Tuplesortstate *tuplesort_begin_index_btree(Relation indexRel, + bool enforceUnique, + int workMem, bool randomAccess); +extern Tuplesortstate *tuplesort_begin_index_hash(Relation indexRel, + uint32 hash_mask, + int workMem, bool randomAccess); extern Tuplesortstate *tuplesort_begin_datum(Oid datumType, - Oid sortOperator, bool nullsFirstFlag, + Oid sortOperator, Oid sortCollation, + bool nullsFirstFlag, int workMem, bool randomAccess); extern void tuplesort_set_bound(Tuplesortstate *state, int64 bound); extern void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot); +extern void tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup); extern void tuplesort_putindextuple(Tuplesortstate *state, IndexTuple tuple); extern void tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull); @@ -67,6 +90,8 @@ extern void tuplesort_performsort(Tuplesortstate *state); extern bool tuplesort_gettupleslot(Tuplesortstate *state, bool forward, TupleTableSlot *slot); +extern HeapTuple tuplesort_getheaptuple(Tuplesortstate *state, bool forward, + bool *should_free); extern IndexTuple tuplesort_getindextuple(Tuplesortstate *state, bool forward, bool *should_free); extern bool tuplesort_getdatum(Tuplesortstate *state, bool forward, @@ -74,6 +99,11 @@ extern bool tuplesort_getdatum(Tuplesortstate *state, bool forward, extern void tuplesort_end(Tuplesortstate *state); +extern void tuplesort_get_stats(Tuplesortstate *state, + const char **sortMethod, + const char **spaceType, + long *spaceUsed); + extern int tuplesort_merge_order(long allowedMem); /* @@ -86,18 +116,4 @@ extern void tuplesort_rescan(Tuplesortstate *state); extern void tuplesort_markpos(Tuplesortstate *state); extern void tuplesort_restorepos(Tuplesortstate *state); -/* Setup for ApplySortFunction */ -extern void SelectSortFunction(Oid sortOperator, bool nulls_first, - Oid *sortFunction, - int *sortFlags); - -/* - * Apply a sort function (by now converted to fmgr lookup form) - * and return a 3-way comparison result. This takes care of handling - * reverse-sort and NULLs-ordering properly. - */ -extern int32 ApplySortFunction(FmgrInfo *sortFunction, int sortFlags, - Datum datum1, bool isNull1, - Datum datum2, bool isNull2); - #endif /* TUPLESORT_H */