PostgreSQL Source Code: src/include/utils/tuplesort.h Source File

PostgreSQL Source Code git master
tuplesort.h
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * tuplesort.h
4 * Generalized tuple sorting routines.
5 *
6 * This module handles sorting of heap tuples, index tuples, or single
7 * Datums (and could easily support other kinds of sortable objects,
8 * if necessary). It works efficiently for both small and large amounts
9 * of data. Small amounts are sorted in-memory using qsort(). Large
10 * amounts are sorted using temporary files and a standard external sort
11 * algorithm. Parallel sorts use a variant of this external sort
12 * algorithm, and are typically only used for large amounts of data.
13 *
14 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
15 * Portions Copyright (c) 1994, Regents of the University of California
16 *
17 * src/include/utils/tuplesort.h
18 *
19 *-------------------------------------------------------------------------
20 */
21#ifndef TUPLESORT_H
22#define TUPLESORT_H
23
24#include "access/brin_tuple.h"
25#include "access/gin_tuple.h"
26#include "access/itup.h"
27#include "executor/tuptable.h"
28#include "storage/dsm.h"
29#include "utils/logtape.h"
30#include "utils/relcache.h"
31#include "utils/sortsupport.h"
32
33
34/*
35 * Tuplesortstate and Sharedsort are opaque types whose details are not
36 * known outside tuplesort.c.
37 */
38 typedef struct Tuplesortstate Tuplesortstate;
39 typedef struct Sharedsort Sharedsort;
40
41/*
42 * Tuplesort parallel coordination state, allocated by each participant in
43 * local memory. Participant caller initializes everything. See usage notes
44 * below.
45 */
46 typedef struct SortCoordinateData
47{
48 /* Worker process? If not, must be leader. */
49 bool isWorker;
50
51 /*
52 * Leader-process-passed number of participants known launched (workers
53 * set this to -1). Includes state within leader needed for it to
54 * participate as a worker, if any.
55 */
56 int nParticipants;
57
58 /* Private opaque state (points to shared memory) */
59 Sharedsort *sharedsort;
60 } SortCoordinateData;
61
62 typedef struct SortCoordinateData *SortCoordinate;
63
64/*
65 * Data structures for reporting sort statistics. Note that
66 * TuplesortInstrumentation can't contain any pointers because we
67 * sometimes put it in shared memory.
68 *
69 * The parallel-sort infrastructure relies on having a zero TuplesortMethod
70 * to indicate that a worker never did anything, so we assign zero to
71 * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be
72 * OR'ed together to represent a situation where different workers used
73 * different methods, so we need a separate bit for each one. Keep the
74 * NUM_TUPLESORTMETHODS constant in sync with the number of bits!
75 */
76 typedef enum
77{
78 SORT_TYPE_STILL_IN_PROGRESS = 0,
79 SORT_TYPE_TOP_N_HEAPSORT = 1 << 0,
80 SORT_TYPE_QUICKSORT = 1 << 1,
81 SORT_TYPE_EXTERNAL_SORT = 1 << 2,
82 SORT_TYPE_EXTERNAL_MERGE = 1 << 3,
83} TuplesortMethod;
84
85 #define NUM_TUPLESORTMETHODS 4
86
87 typedef enum
88{
89 SORT_SPACE_TYPE_DISK,
90 SORT_SPACE_TYPE_MEMORY,
91} TuplesortSpaceType;
92
93/* Bitwise option flags for tuple sorts */
94 #define TUPLESORT_NONE 0
95
96/* specifies whether non-sequential access to the sort result is required */
97 #define TUPLESORT_RANDOMACCESS (1 << 0)
98
99/* specifies if the tuplesort is able to support bounded sorts */
100 #define TUPLESORT_ALLOWBOUNDED (1 << 1)
101
102/*
103 * For bounded sort, tuples get pfree'd when they fall outside of the bound.
104 * When bounded sorts are not required, we can use a bump context for tuple
105 * allocation as there's no risk that pfree will ever be called for a tuple.
106 * Define a macro to make it easier for code to figure out if we're using a
107 * bump allocator.
108 */
109 #define TupleSortUseBumpTupleCxt(opt) (((opt) & TUPLESORT_ALLOWBOUNDED) == 0)
110
111 typedef struct TuplesortInstrumentation
112{
113 TuplesortMethod sortMethod; /* sort algorithm used */
114 TuplesortSpaceType spaceType; /* type of space spaceUsed represents */
115 int64 spaceUsed; /* space consumption, in kB */
116 } TuplesortInstrumentation;
117
118/*
119 * The objects we actually sort are SortTuple structs. These contain
120 * a pointer to the tuple proper (might be a MinimalTuple or IndexTuple),
121 * which is a separate palloc chunk --- we assume it is just one chunk and
122 * can be freed by a simple pfree() (except during merge, where we use a
123 * simple slab allocator, and during a non-bounded sort where we use a bump
124 * allocator). SortTuples also contain the tuple's first key column in
125 * Datum/nullflag format, and a source/input tape number that tracks which
126 * tape each heap element/slot belongs to during merging.
127 *
128 * Storing the first key column lets us save heap_getattr or index_getattr
129 * calls during tuple comparisons. We could extract and save all the key
130 * columns not just the first, but this would increase code complexity and
131 * overhead, and wouldn't actually save any comparison cycles in the common
132 * case where the first key determines the comparison result. Note that
133 * for a pass-by-reference datatype, datum1 points into the "tuple" storage.
134 *
135 * There is one special case: when the sort support infrastructure provides an
136 * "abbreviated key" representation, where the key is (typically) a pass by
137 * value proxy for a pass by reference type. In this case, the abbreviated key
138 * is stored in datum1 in place of the actual first key column.
139 *
140 * When sorting single Datums, the data value is represented directly by
141 * datum1/isnull1 for pass by value types (or null values). If the datatype is
142 * pass-by-reference and isnull1 is false, then "tuple" points to a separately
143 * palloc'd data value, otherwise "tuple" is NULL. The value of datum1 is then
144 * either the same pointer as "tuple", or is an abbreviated key value as
145 * described above. Accordingly, "tuple" is always used in preference to
146 * datum1 as the authoritative value for pass-by-reference cases.
147 */
148 typedef struct
149{
150 void *tuple; /* the tuple itself */
151 Datum datum1; /* value of first key column */
152 bool isnull1; /* is first key column NULL? */
153 int srctape; /* source tape number */
154} SortTuple;
155
156 typedef int (*SortTupleComparator) (const SortTuple *a, const SortTuple *b,
157 Tuplesortstate *state);
158
159/*
160 * The public part of a Tuple sort operation state. This data structure
161 * contains the definition of sort-variant-specific interface methods and
162 * the part of Tuple sort operation state required by their implementations.
163 */
164 typedef struct
165{
166 /*
167 * These function pointers decouple the routines that must know what kind
168 * of tuple we are sorting from the routines that don't need to know it.
169 * They are set up by the tuplesort_begin_xxx routines.
170 *
171 * Function to compare two tuples; result is per qsort() convention, ie:
172 * <0, 0, >0 according as a<b, a=b, a>b. The API must match
173 * qsort_arg_comparator.
174 */
175 SortTupleComparator comparetup;
176
177 /*
178 * Fall back to the full tuple for comparison, but only compare the first
179 * sortkey if it was abbreviated. Otherwise, only compare second and later
180 * sortkeys.
181 */
182 SortTupleComparator comparetup_tiebreak;
183
184 /*
185 * Alter datum1 representation in the SortTuple's array back from the
186 * abbreviated key to the first column value.
187 */
188 void (*removeabbrev) (Tuplesortstate *state, SortTuple *stups,
189 int count);
190
191 /*
192 * Function to write a stored tuple onto tape. The representation of the
193 * tuple on tape need not be the same as it is in memory.
194 */
195 void (*writetup) (Tuplesortstate *state, LogicalTape *tape,
196 SortTuple *stup);
197
198 /*
199 * Function to read a stored tuple from tape back into memory. 'len' is
200 * the already-read length of the stored tuple. The tuple is allocated
201 * from the slab memory arena, or is palloc'd, see
202 * tuplesort_readtup_alloc().
203 */
204 void (*readtup) (Tuplesortstate *state, SortTuple *stup,
205 LogicalTape *tape, unsigned int len);
206
207 /*
208 * Function to do some specific release of resources for the sort variant.
209 * In particular, this function should free everything stored in the "arg"
210 * field, which wouldn't be cleared on reset of the Tuple sort memory
211 * contexts. This can be NULL if nothing specific needs to be done.
212 */
213 void (*freestate) (Tuplesortstate *state);
214
215 /*
216 * The subsequent fields are used in the implementations of the functions
217 * above.
218 */
219 MemoryContext maincontext; /* memory context for tuple sort metadata that
220 * persists across multiple batches */
221 MemoryContext sortcontext; /* memory context holding most sort data */
222 MemoryContext tuplecontext; /* sub-context of sortcontext for tuple data */
223
224 /*
225 * Whether SortTuple's datum1 and isnull1 members are maintained by the
226 * above routines. If not, some sort specializations are disabled.
227 */
228 bool haveDatum1;
229
230 /*
231 * The sortKeys variable is used by every case other than the hash index
232 * case; it is set by tuplesort_begin_xxx. tupDesc is only used by the
233 * MinimalTuple and CLUSTER routines, though.
234 */
235 int nKeys; /* number of columns in sort key */
236 SortSupport sortKeys; /* array of length nKeys */
237
238 /*
239 * This variable is shared by the single-key MinimalTuple case and the
240 * Datum case (which both use qsort_ssup()). Otherwise, it's NULL. The
241 * presence of a value in this field is also checked by various sort
242 * specialization functions as an optimization when comparing the leading
243 * key in a tiebreak situation to determine if there are any subsequent
244 * keys to sort on.
245 */
246 SortSupport onlyKey;
247
248 int sortopt; /* Bitmask of flags used to setup sort */
249
250 bool tuples; /* Can SortTuple.tuple ever be set? */
251
252 void *arg; /* Specific information for the sort variant */
253} TuplesortPublic;
254
255/* Sort parallel code from state for sort__start probes */
256 #define PARALLEL_SORT(coordinate) (coordinate == NULL || \
257 (coordinate)->sharedsort == NULL ? 0 : \
258 (coordinate)->isWorker ? 1 : 2)
259
260 #define TuplesortstateGetPublic(state) ((TuplesortPublic *) state)
261
262/* When using this macro, beware of double evaluation of len */
263 #define LogicalTapeReadExact(tape, ptr, len) \
264 do { \
265 if (LogicalTapeRead(tape, ptr, len) != (size_t) (len)) \
266 elog(ERROR, "unexpected end of data"); \
267 } while(0)
268
269/*
270 * We provide multiple interfaces to what is essentially the same code,
271 * since different callers have different data to be sorted and want to
272 * specify the sort key information differently. There are two APIs for
273 * sorting HeapTuples and two more for sorting IndexTuples. Yet another
274 * API supports sorting bare Datums.
275 *
276 * Serial sort callers should pass NULL for their coordinate argument.
277 *
278 * The "heap" API actually stores/sorts MinimalTuples, which means it doesn't
279 * preserve the system columns (tuple identity and transaction visibility
280 * info). The sort keys are specified by column numbers within the tuples
281 * and sort operator OIDs. We save some cycles by passing and returning the
282 * tuples in TupleTableSlots, rather than forming actual HeapTuples (which'd
283 * have to be converted to MinimalTuples). This API works well for sorts
284 * executed as parts of plan trees.
285 *
286 * The "cluster" API stores/sorts full HeapTuples including all visibility
287 * info. The sort keys are specified by reference to a btree index that is
288 * defined on the relation to be sorted. Note that putheaptuple/getheaptuple
289 * go with this API, not the "begin_heap" one!
290 *
291 * The "index_btree" API stores/sorts IndexTuples (preserving all their
292 * header fields). The sort keys are specified by a btree index definition.
293 *
294 * The "index_hash" API is similar to index_btree, but the tuples are
295 * actually sorted by their hash codes not the raw data.
296 *
297 * The "index_brin" API is similar to index_btree, but the tuples are
298 * BrinTuple and are sorted by their block number not the raw data.
299 *
300 * Parallel sort callers are required to coordinate multiple tuplesort states
301 * in a leader process and one or more worker processes. The leader process
302 * must launch workers, and have each perform an independent "partial"
303 * tuplesort, typically fed by the parallel heap interface. The leader later
304 * produces the final output (internally, it merges runs output by workers).
305 *
306 * Callers must do the following to perform a sort in parallel using multiple
307 * worker processes:
308 *
309 * 1. Request tuplesort-private shared memory for n workers. Use
310 * tuplesort_estimate_shared() to get the required size.
311 * 2. Have leader process initialize allocated shared memory using
312 * tuplesort_initialize_shared(). Launch workers.
313 * 3. Initialize a coordinate argument within both the leader process, and
314 * for each worker process. This has a pointer to the shared
315 * tuplesort-private structure, as well as some caller-initialized fields.
316 * Leader's coordinate argument reliably indicates number of workers
317 * launched (this is unused by workers).
318 * 4. Begin a tuplesort using some appropriate tuplesort_begin* routine,
319 * (passing the coordinate argument) within each worker. The workMem
320 * arguments need not be identical. All other arguments should match
321 * exactly, though.
322 * 5. tuplesort_attach_shared() should be called by all workers. Feed tuples
323 * to each worker, and call tuplesort_performsort() within each when input
324 * is exhausted.
325 * 6. Call tuplesort_end() in each worker process. Worker processes can shut
326 * down once tuplesort_end() returns.
327 * 7. Begin a tuplesort in the leader using the same tuplesort_begin*
328 * routine, passing a leader-appropriate coordinate argument (this can
329 * happen as early as during step 3, actually, since we only need to know
330 * the number of workers successfully launched). The leader must now wait
331 * for workers to finish. Caller must use own mechanism for ensuring that
332 * next step isn't reached until all workers have called and returned from
333 * tuplesort_performsort(). (Note that it's okay if workers have already
334 * also called tuplesort_end() by then.)
335 * 8. Call tuplesort_performsort() in leader. Consume output using the
336 * appropriate tuplesort_get* routine. Leader can skip this step if
337 * tuplesort turns out to be unnecessary.
338 * 9. Call tuplesort_end() in leader.
339 *
340 * This division of labor assumes nothing about how input tuples are produced,
341 * but does require that caller combine the state of multiple tuplesorts for
342 * any purpose other than producing the final output. For example, callers
343 * must consider that tuplesort_get_stats() reports on only one worker's role
344 * in a sort (or the leader's role), and not statistics for the sort as a
345 * whole.
346 *
347 * Note that callers may use the leader process to sort runs as if it was an
348 * independent worker process (prior to the process performing a leader sort
349 * to produce the final sorted output). Doing so only requires a second
350 * "partial" tuplesort within the leader process, initialized like that of a
351 * worker process. The steps above don't touch on this directly. The only
352 * difference is that the tuplesort_attach_shared() call is never needed within
353 * leader process, because the backend as a whole holds the shared fileset
354 * reference. A worker Tuplesortstate in leader is expected to do exactly the
355 * same amount of total initial processing work as a worker process
356 * Tuplesortstate, since the leader process has nothing else to do before
357 * workers finish.
358 *
359 * Note that only a very small amount of memory will be allocated prior to
360 * the leader state first consuming input, and that workers will free the
361 * vast majority of their memory upon returning from tuplesort_performsort().
362 * Callers can rely on this to arrange for memory to be used in a way that
363 * respects a workMem-style budget across an entire parallel sort operation.
364 *
365 * Callers are responsible for parallel safety in general. However, they
366 * can at least rely on there being no parallel safety hazards within
367 * tuplesort, because tuplesort thinks of the sort as several independent
368 * sorts whose results are combined. Since, in general, the behavior of
369 * sort operators is immutable, caller need only worry about the parallel
370 * safety of whatever the process is through which input tuples are
371 * generated (typically, caller uses a parallel heap scan).
372 */
373
374
375extern Tuplesortstate *tuplesort_begin_common(int workMem,
376 SortCoordinate coordinate,
377 int sortopt);
378extern void tuplesort_set_bound(Tuplesortstate *state, int64 bound);
379extern bool tuplesort_used_bound(Tuplesortstate *state);
380extern void tuplesort_puttuple_common(Tuplesortstate *state,
381 SortTuple *tuple, bool useAbbrev,
382 Size tuplen);
383extern void tuplesort_performsort(Tuplesortstate *state);
384extern bool tuplesort_gettuple_common(Tuplesortstate *state, bool forward,
385 SortTuple *stup);
386extern bool tuplesort_skiptuples(Tuplesortstate *state, int64 ntuples,
387 bool forward);
388extern void tuplesort_end(Tuplesortstate *state);
389extern void tuplesort_reset(Tuplesortstate *state);
390
391extern void tuplesort_get_stats(Tuplesortstate *state,
392 TuplesortInstrumentation *stats);
393extern const char *tuplesort_method_name(TuplesortMethod m);
394extern const char *tuplesort_space_type_name(TuplesortSpaceType t);
395
396extern int tuplesort_merge_order(int64 allowedMem);
397
398extern Size tuplesort_estimate_shared(int nWorkers);
399extern void tuplesort_initialize_shared(Sharedsort *shared, int nWorkers,
400 dsm_segment *seg);
401extern void tuplesort_attach_shared(Sharedsort *shared, dsm_segment *seg);
402
403/*
404 * These routines may only be called if TUPLESORT_RANDOMACCESS was specified
405 * during tuplesort_begin_*. Additionally backwards scan in gettuple/getdatum
406 * also require TUPLESORT_RANDOMACCESS. Note that parallel sorts do not
407 * support random access.
408 */
409extern void tuplesort_rescan(Tuplesortstate *state);
410extern void tuplesort_markpos(Tuplesortstate *state);
411extern void tuplesort_restorepos(Tuplesortstate *state);
412
413extern void *tuplesort_readtup_alloc(Tuplesortstate *state, Size tuplen);
414
415
416/* tuplesortvariants.c */
417
418extern Tuplesortstate *tuplesort_begin_heap(TupleDesc tupDesc,
419 int nkeys, AttrNumber *attNums,
420 Oid *sortOperators, Oid *sortCollations,
421 bool *nullsFirstFlags,
422 int workMem, SortCoordinate coordinate,
423 int sortopt);
424extern Tuplesortstate *tuplesort_begin_cluster(TupleDesc tupDesc,
425 Relation indexRel, int workMem,
426 SortCoordinate coordinate,
427 int sortopt);
428extern Tuplesortstate *tuplesort_begin_index_btree(Relation heapRel,
429 Relation indexRel,
430 bool enforceUnique,
431 bool uniqueNullsNotDistinct,
432 int workMem, SortCoordinate coordinate,
433 int sortopt);
434extern Tuplesortstate *tuplesort_begin_index_hash(Relation heapRel,
435 Relation indexRel,
436 uint32 high_mask,
437 uint32 low_mask,
438 uint32 max_buckets,
439 int workMem, SortCoordinate coordinate,
440 int sortopt);
441extern Tuplesortstate *tuplesort_begin_index_gist(Relation heapRel,
442 Relation indexRel,
443 int workMem, SortCoordinate coordinate,
444 int sortopt);
445extern Tuplesortstate *tuplesort_begin_index_brin(int workMem, SortCoordinate coordinate,
446 int sortopt);
447extern Tuplesortstate *tuplesort_begin_index_gin(Relation heapRel,
448 Relation indexRel,
449 int workMem, SortCoordinate coordinate,
450 int sortopt);
451extern Tuplesortstate *tuplesort_begin_datum(Oid datumType,
452 Oid sortOperator, Oid sortCollation,
453 bool nullsFirstFlag,
454 int workMem, SortCoordinate coordinate,
455 int sortopt);
456
457extern void tuplesort_puttupleslot(Tuplesortstate *state,
458 TupleTableSlot *slot);
459extern void tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup);
460extern void tuplesort_putindextuplevalues(Tuplesortstate *state,
461 Relation rel, ItemPointer self,
462 const Datum *values, const bool *isnull);
463extern void tuplesort_putbrintuple(Tuplesortstate *state, BrinTuple *tuple, Size size);
464extern void tuplesort_putgintuple(Tuplesortstate *state, GinTuple *tuple, Size size);
465extern void tuplesort_putdatum(Tuplesortstate *state, Datum val,
466 bool isNull);
467
468extern bool tuplesort_gettupleslot(Tuplesortstate *state, bool forward,
469 bool copy, TupleTableSlot *slot, Datum *abbrev);
470extern HeapTuple tuplesort_getheaptuple(Tuplesortstate *state, bool forward);
471extern IndexTuple tuplesort_getindextuple(Tuplesortstate *state, bool forward);
472extern BrinTuple *tuplesort_getbrintuple(Tuplesortstate *state, Size *len,
473 bool forward);
474extern GinTuple *tuplesort_getgintuple(Tuplesortstate *state, Size *len,
475 bool forward);
476extern bool tuplesort_getdatum(Tuplesortstate *state, bool forward, bool copy,
477 Datum *val, bool *isNull, Datum *abbrev);
478
479
480#endif /* TUPLESORT_H */
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:153
int64_t int64
Definition: c.h:535
uint32_t uint32
Definition: c.h:538
size_t Size
Definition: c.h:610
long val
Definition: informix.c:689
b
int b
Definition: isn.c:74
a
int a
Definition: isn.c:73
const void size_t len
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
static void freestate(struct nfa *nfa, struct state *s)
Definition: regc_nfa.c:242
Definition: rel.h:56
Sharedsort * sharedsort
Definition: tuplesort.h:59
bool isnull1
Definition: tuplesort.h:152
void * tuple
Definition: tuplesort.h:150
int srctape
Definition: tuplesort.h:153
Datum datum1
Definition: tuplesort.h:151
TuplesortMethod sortMethod
Definition: tuplesort.h:113
TuplesortSpaceType spaceType
Definition: tuplesort.h:114
SortSupport onlyKey
Definition: tuplesort.h:246
MemoryContext maincontext
Definition: tuplesort.h:219
MemoryContext tuplecontext
Definition: tuplesort.h:222
MemoryContext sortcontext
Definition: tuplesort.h:221
bool haveDatum1
Definition: tuplesort.h:228
SortTupleComparator comparetup
Definition: tuplesort.h:175
SortSupport sortKeys
Definition: tuplesort.h:236
SortTupleComparator comparetup_tiebreak
Definition: tuplesort.h:182
void * arg
Definition: tuplesort.h:252
Definition: dsm.c:67
Definition: regguts.h:323
IndexTuple tuplesort_getindextuple(Tuplesortstate *state, bool forward)
void tuplesort_rescan(Tuplesortstate *state)
Definition: tuplesort.c:2398
void tuplesort_performsort(Tuplesortstate *state)
Definition: tuplesort.c:1359
struct SortCoordinateData SortCoordinateData
int tuplesort_merge_order(int64 allowedMem)
Definition: tuplesort.c:1774
Tuplesortstate * tuplesort_begin_index_gin(Relation heapRel, Relation indexRel, int workMem, SortCoordinate coordinate, int sortopt)
void tuplesort_initialize_shared(Sharedsort *shared, int nWorkers, dsm_segment *seg)
Definition: tuplesort.c:2932
HeapTuple tuplesort_getheaptuple(Tuplesortstate *state, bool forward)
void tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
GinTuple * tuplesort_getgintuple(Tuplesortstate *state, Size *len, bool forward)
void tuplesort_reset(Tuplesortstate *state)
Definition: tuplesort.c:1015
void tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel, ItemPointer self, const Datum *values, const bool *isnull)
bool tuplesort_skiptuples(Tuplesortstate *state, int64 ntuples, bool forward)
Definition: tuplesort.c:1706
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
Tuplesortstate * tuplesort_begin_index_brin(int workMem, SortCoordinate coordinate, int sortopt)
Tuplesortstate * tuplesort_begin_heap(TupleDesc tupDesc, int nkeys, AttrNumber *attNums, Oid *sortOperators, Oid *sortCollations, bool *nullsFirstFlags, int workMem, SortCoordinate coordinate, int sortopt)
bool tuplesort_used_bound(Tuplesortstate *state)
Definition: tuplesort.c:882
Tuplesortstate * tuplesort_begin_cluster(TupleDesc tupDesc, Relation indexRel, int workMem, SortCoordinate coordinate, int sortopt)
BrinTuple * tuplesort_getbrintuple(Tuplesortstate *state, Size *len, bool forward)
Tuplesortstate * tuplesort_begin_index_btree(Relation heapRel, Relation indexRel, bool enforceUnique, bool uniqueNullsNotDistinct, int workMem, SortCoordinate coordinate, int sortopt)
Tuplesortstate * tuplesort_begin_index_gist(Relation heapRel, Relation indexRel, int workMem, SortCoordinate coordinate, int sortopt)
Size tuplesort_estimate_shared(int nWorkers)
Definition: tuplesort.c:2911
struct SortCoordinateData * SortCoordinate
Definition: tuplesort.h:62
void tuplesort_get_stats(Tuplesortstate *state, TuplesortInstrumentation *stats)
Definition: tuplesort.c:2495
bool tuplesort_gettupleslot(Tuplesortstate *state, bool forward, bool copy, TupleTableSlot *slot, Datum *abbrev)
Tuplesortstate * tuplesort_begin_common(int workMem, SortCoordinate coordinate, int sortopt)
Definition: tuplesort.c:638
void tuplesort_end(Tuplesortstate *state)
Definition: tuplesort.c:947
void tuplesort_putgintuple(Tuplesortstate *state, GinTuple *tuple, Size size)
void tuplesort_markpos(Tuplesortstate *state)
Definition: tuplesort.c:2431
void tuplesort_puttuple_common(Tuplesortstate *state, SortTuple *tuple, bool useAbbrev, Size tuplen)
Definition: tuplesort.c:1165
const char * tuplesort_space_type_name(TuplesortSpaceType t)
Definition: tuplesort.c:2562
bool tuplesort_gettuple_common(Tuplesortstate *state, bool forward, SortTuple *stup)
Definition: tuplesort.c:1466
void tuplesort_attach_shared(Sharedsort *shared, dsm_segment *seg)
Definition: tuplesort.c:2955
Tuplesortstate * tuplesort_begin_datum(Oid datumType, Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, int workMem, SortCoordinate coordinate, int sortopt)
void tuplesort_putbrintuple(Tuplesortstate *state, BrinTuple *tuple, Size size)
const char * tuplesort_method_name(TuplesortMethod m)
Definition: tuplesort.c:2539
struct TuplesortInstrumentation TuplesortInstrumentation
void tuplesort_restorepos(Tuplesortstate *state)
Definition: tuplesort.c:2462
Tuplesortstate * tuplesort_begin_index_hash(Relation heapRel, Relation indexRel, uint32 high_mask, uint32 low_mask, uint32 max_buckets, int workMem, SortCoordinate coordinate, int sortopt)
void * tuplesort_readtup_alloc(Tuplesortstate *state, Size tuplen)
Definition: tuplesort.c:2877
TuplesortSpaceType
Definition: tuplesort.h:88
@ SORT_SPACE_TYPE_DISK
Definition: tuplesort.h:89
@ SORT_SPACE_TYPE_MEMORY
Definition: tuplesort.h:90
int(* SortTupleComparator)(const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
Definition: tuplesort.h:156
TuplesortMethod
Definition: tuplesort.h:77
@ SORT_TYPE_EXTERNAL_SORT
Definition: tuplesort.h:81
@ SORT_TYPE_TOP_N_HEAPSORT
Definition: tuplesort.h:79
@ SORT_TYPE_QUICKSORT
Definition: tuplesort.h:80
@ SORT_TYPE_STILL_IN_PROGRESS
Definition: tuplesort.h:78
@ SORT_TYPE_EXTERNAL_MERGE
Definition: tuplesort.h:82
void tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
bool tuplesort_getdatum(Tuplesortstate *state, bool forward, bool copy, Datum *val, bool *isNull, Datum *abbrev)
void tuplesort_set_bound(Tuplesortstate *state, int64 bound)
Definition: tuplesort.c:834

AltStyle によって変換されたページ (->オリジナル) /