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