1999-10-18 00:15:09 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* tuplesort.h
|
|
|
|
* Generalized tuple sorting routines.
|
|
|
|
*
|
1999-12-13 02:27:21 +01:00
|
|
|
* This module handles sorting of heap tuples, index tuples, or single
|
|
|
|
* Datums (and could easily support other kinds of sortable objects,
|
1999-10-18 00:15:09 +02:00
|
|
|
* if necessary). It works efficiently for both small and large amounts
|
2000-04-12 19:17:23 +02:00
|
|
|
* of data. Small amounts are sorted in-memory using qsort(). Large
|
1999-10-18 00:15:09 +02:00
|
|
|
* amounts are sorted using temporary files and a standard external sort
|
|
|
|
* algorithm.
|
|
|
|
*
|
2011-01-01 19:18:15 +01:00
|
|
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1999-10-18 00:15:09 +02:00
|
|
|
*
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/include/utils/tuplesort.h
|
1999-10-18 00:15:09 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef TUPLESORT_H
|
|
|
|
#define TUPLESORT_H
|
|
|
|
|
|
|
|
#include "access/itup.h"
|
2006-06-27 18:53:02 +02:00
|
|
|
#include "executor/tuptable.h"
|
2008-06-19 02:46:06 +02:00
|
|
|
#include "fmgr.h"
|
|
|
|
#include "utils/relcache.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
|
|
|
|
|
2006-06-27 18:53:02 +02:00
|
|
|
/* Tuplesortstate is an opaque type whose details are not known outside
|
|
|
|
* tuplesort.c.
|
|
|
|
*/
|
1999-10-18 00:15:09 +02:00
|
|
|
typedef struct Tuplesortstate Tuplesortstate;
|
|
|
|
|
|
|
|
/*
|
2010-10-08 02:00:28 +02:00
|
|
|
* 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.
|
2006-05-23 23:37:59 +02:00
|
|
|
*
|
2010-10-08 02:00:28 +02:00
|
|
|
* 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
|
2011-04-10 17:42:00 +02:00
|
|
|
* and sort operator OIDs. We save some cycles by passing and returning the
|
2010-10-08 02:00:28 +02:00
|
|
|
* tuples in TupleTableSlots, rather than forming actual HeapTuples (which'd
|
2011-04-10 17:42:00 +02:00
|
|
|
* have to be converted to MinimalTuples). This API works well for sorts
|
2010-10-08 02:00:28 +02:00
|
|
|
* executed as parts of plan trees.
|
2008-03-17 00:15:08 +01:00
|
|
|
*
|
2010-10-08 02:00:28 +02:00
|
|
|
* 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
|
2011-04-10 17:42:00 +02:00
|
|
|
* header fields). The sort keys are specified by a btree index definition.
|
2010-10-08 02:00:28 +02:00
|
|
|
*
|
|
|
|
* The "index_hash" API is similar to index_btree, but the tuples are
|
|
|
|
* actually sorted by their hash codes not the raw data.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
extern Tuplesortstate *tuplesort_begin_heap(TupleDesc tupDesc,
|
2007-01-09 03:14:16 +01:00
|
|
|
int nkeys, AttrNumber *attNums,
|
2011-04-13 01:19:24 +02:00
|
|
|
Oid *sortOperators, Oid *sortCollations,
|
|
|
|
bool *nullsFirstFlags,
|
2004-02-03 18:34:04 +01:00
|
|
|
int workMem, bool randomAccess);
|
2010-10-08 02:00:28 +02:00
|
|
|
extern Tuplesortstate *tuplesort_begin_cluster(TupleDesc tupDesc,
|
2011-04-10 17:42:00 +02:00
|
|
|
Relation indexRel,
|
|
|
|
int workMem, bool randomAccess);
|
2008-03-17 00:15:08 +01:00
|
|
|
extern Tuplesortstate *tuplesort_begin_index_btree(Relation indexRel,
|
|
|
|
bool enforceUnique,
|
|
|
|
int workMem, bool randomAccess);
|
|
|
|
extern Tuplesortstate *tuplesort_begin_index_hash(Relation indexRel,
|
2009-06-11 16:49:15 +02:00
|
|
|
uint32 hash_mask,
|
|
|
|
int workMem, bool randomAccess);
|
1999-12-13 02:27:21 +01:00
|
|
|
extern Tuplesortstate *tuplesort_begin_datum(Oid datumType,
|
2011-04-13 01:19:24 +02:00
|
|
|
Oid sortOperator, Oid sortCollation,
|
|
|
|
bool nullsFirstFlag,
|
2004-02-03 18:34:04 +01:00
|
|
|
int workMem, bool randomAccess);
|
1999-10-18 00:15:09 +02:00
|
|
|
|
2007-05-04 03:13:45 +02:00
|
|
|
extern void tuplesort_set_bound(Tuplesortstate *state, int64 bound);
|
|
|
|
|
2006-06-27 18:53:02 +02:00
|
|
|
extern void tuplesort_puttupleslot(Tuplesortstate *state,
|
2006-10-04 02:30:14 +02:00
|
|
|
TupleTableSlot *slot);
|
2010-10-08 02:00:28 +02:00
|
|
|
extern void tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup);
|
2006-06-27 18:53:02 +02:00
|
|
|
extern void tuplesort_putindextuple(Tuplesortstate *state, IndexTuple tuple);
|
1999-12-13 02:27:21 +01:00
|
|
|
extern void tuplesort_putdatum(Tuplesortstate *state, Datum val,
|
2000-04-12 19:17:23 +02:00
|
|
|
bool isNull);
|
1999-12-13 02:27:21 +01:00
|
|
|
|
1999-10-18 00:15:09 +02:00
|
|
|
extern void tuplesort_performsort(Tuplesortstate *state);
|
|
|
|
|
2006-06-27 18:53:02 +02:00
|
|
|
extern bool tuplesort_gettupleslot(Tuplesortstate *state, bool forward,
|
2006-10-04 02:30:14 +02:00
|
|
|
TupleTableSlot *slot);
|
2010-10-08 02:00:28 +02:00
|
|
|
extern HeapTuple tuplesort_getheaptuple(Tuplesortstate *state, bool forward,
|
|
|
|
bool *should_free);
|
2006-06-27 18:53:02 +02:00
|
|
|
extern IndexTuple tuplesort_getindextuple(Tuplesortstate *state, bool forward,
|
2006-10-04 02:30:14 +02:00
|
|
|
bool *should_free);
|
1999-12-13 02:27:21 +01:00
|
|
|
extern bool tuplesort_getdatum(Tuplesortstate *state, bool forward,
|
2000-04-12 19:17:23 +02:00
|
|
|
Datum *val, bool *isNull);
|
1999-12-13 02:27:21 +01:00
|
|
|
|
1999-10-18 00:15:09 +02:00
|
|
|
extern void tuplesort_end(Tuplesortstate *state);
|
|
|
|
|
2009-08-10 07:46:50 +02:00
|
|
|
extern void tuplesort_get_stats(Tuplesortstate *state,
|
2010-02-26 03:01:40 +01:00
|
|
|
const char **sortMethod,
|
|
|
|
const char **spaceType,
|
|
|
|
long *spaceUsed);
|
2007-05-04 23:29:53 +02:00
|
|
|
|
2006-02-19 06:54:06 +01:00
|
|
|
extern int tuplesort_merge_order(long allowedMem);
|
|
|
|
|
1999-10-18 00:15:09 +02:00
|
|
|
/*
|
|
|
|
* These routines may only be called if randomAccess was specified 'true'.
|
1999-12-13 02:27:21 +01:00
|
|
|
* Likewise, backwards scan in gettuple/getdatum is only allowed if
|
|
|
|
* randomAccess was specified.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
extern void tuplesort_rescan(Tuplesortstate *state);
|
|
|
|
extern void tuplesort_markpos(Tuplesortstate *state);
|
|
|
|
extern void tuplesort_restorepos(Tuplesortstate *state);
|
|
|
|
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* TUPLESORT_H */
|