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.
|
|
|
|
*
|
2001-01-24 20:43:33 +01:00
|
|
|
* Portions Copyright (c) 1996-2001, 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
|
|
|
*
|
2001-10-28 07:26:15 +01:00
|
|
|
* $Id: tuplesort.h,v 1.10 2001/10/28 06:26:10 momjian Exp $
|
1999-10-18 00:15:09 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef TUPLESORT_H
|
|
|
|
#define TUPLESORT_H
|
|
|
|
|
|
|
|
#include "access/htup.h"
|
|
|
|
#include "access/itup.h"
|
2001-06-02 21:01:53 +02:00
|
|
|
#include "fmgr.h"
|
1999-10-18 00:15:09 +02:00
|
|
|
|
|
|
|
/* Tuplesortstate is an opaque type whose details are not known outside tuplesort.c. */
|
|
|
|
|
|
|
|
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.
|
1999-12-13 02:27:21 +01:00
|
|
|
* Yet a third slightly different interface supports sorting bare Datums.
|
1999-10-18 00:15:09 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
extern Tuplesortstate *tuplesort_begin_heap(TupleDesc tupDesc,
|
2001-10-25 07:50:21 +02:00
|
|
|
int nkeys,
|
|
|
|
Oid *sortOperators, AttrNumber *attNums,
|
|
|
|
bool randomAccess);
|
1999-10-18 00:15:09 +02:00
|
|
|
extern Tuplesortstate *tuplesort_begin_index(Relation indexRel,
|
2000-04-12 19:17:23 +02:00
|
|
|
bool enforceUnique,
|
|
|
|
bool randomAccess);
|
1999-12-13 02:27:21 +01:00
|
|
|
extern Tuplesortstate *tuplesort_begin_datum(Oid datumType,
|
2000-04-12 19:17:23 +02:00
|
|
|
Oid sortOperator,
|
|
|
|
bool randomAccess);
|
1999-10-18 00:15:09 +02:00
|
|
|
|
|
|
|
extern void tuplesort_puttuple(Tuplesortstate *state, void *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);
|
|
|
|
|
|
|
|
extern void *tuplesort_gettuple(Tuplesortstate *state, bool forward,
|
2000-04-12 19:17:23 +02:00
|
|
|
bool *should_free);
|
|
|
|
|
1999-10-18 00:15:09 +02:00
|
|
|
#define tuplesort_getheaptuple(state, forward, should_free) \
|
|
|
|
((HeapTuple) tuplesort_gettuple(state, forward, should_free))
|
|
|
|
#define tuplesort_getindextuple(state, forward, should_free) \
|
|
|
|
((IndexTuple) tuplesort_gettuple(state, forward, 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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-05-07 02:43:27 +02:00
|
|
|
/*
|
|
|
|
* This routine selects an appropriate sorting function to implement
|
|
|
|
* a sort operator as efficiently as possible.
|
|
|
|
*/
|
|
|
|
typedef enum
|
|
|
|
{
|
2001-10-28 07:26:15 +01:00
|
|
|
SORTFUNC_LT, /* raw "<" operator */
|
|
|
|
SORTFUNC_REVLT, /* raw "<" operator, but reverse NULLs */
|
|
|
|
SORTFUNC_CMP, /* -1 / 0 / 1 three-way comparator */
|
|
|
|
SORTFUNC_REVCMP /* 1 / 0 / -1 (reversed) 3-way comparator */
|
2001-05-07 02:43:27 +02:00
|
|
|
} SortFunctionKind;
|
|
|
|
|
|
|
|
extern void SelectSortFunction(Oid sortOperator,
|
2001-10-25 07:50:21 +02:00
|
|
|
RegProcedure *sortFunction,
|
|
|
|
SortFunctionKind *kind);
|
2001-05-07 02:43:27 +02:00
|
|
|
|
2001-06-02 21:01:53 +02:00
|
|
|
/*
|
|
|
|
* Apply a sort function (by now converted to fmgr lookup form)
|
|
|
|
* and return a 3-way comparison result. This takes care of handling
|
|
|
|
* NULLs and sort ordering direction properly.
|
|
|
|
*/
|
|
|
|
extern int32 ApplySortFunction(FmgrInfo *sortFunction, SortFunctionKind kind,
|
2001-10-25 07:50:21 +02:00
|
|
|
Datum datum1, bool isNull1,
|
|
|
|
Datum datum2, bool isNull2);
|
2001-10-28 07:26:15 +01:00
|
|
|
|
1999-10-18 00:15:09 +02:00
|
|
|
#endif /* TUPLESORT_H */
|