tuplestore.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "commands/tablespace.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "storage/buffile.h"
#include "utils/memutils.h"
#include "utils/resowner.h"
#include "utils/tuplestore.h"

Include dependency graph for tuplestore.c:

Go to the source code of this file.

Data Structures
struct	TSReadPointer
struct	Tuplestorestate

Macros
#define	COPYTUP(state, tup)   ((*(state)->copytup) (state, tup))
#define	WRITETUP(state, tup)   ((*(state)->writetup) (state, tup))
#define	READTUP(state, len)   ((*(state)->readtup) (state, len))
#define	LACKMEM(state)   ((state)->availMem < 0)
#define	USEMEM(state, amt)   ((state)->availMem -= (amt))
#define	FREEMEM(state, amt)   ((state)->availMem += (amt))

Enumerations
enum	TupStoreStatus { TSS_INMEM , TSS_WRITEFILE , TSS_READFILE }

Functions
static Tuplestorestate *	tuplestore_begin_common (int eflags, bool interXact, int maxKBytes)
static void	tuplestore_puttuple_common (Tuplestorestate *state, void *tuple)
static void	dumptuples (Tuplestorestate *state)
static void	tuplestore_updatemax (Tuplestorestate *state)
static unsigned int	getlen (Tuplestorestate *state, bool eofOK)
static void *	copytup_heap (Tuplestorestate *state, void *tup)
static void	writetup_heap (Tuplestorestate *state, void *tup)
static void *	readtup_heap (Tuplestorestate *state, unsigned int len)
Tuplestorestate *	tuplestore_begin_heap (bool randomAccess, bool interXact, int maxKBytes)
void	tuplestore_set_eflags (Tuplestorestate *state, int eflags)
int	tuplestore_alloc_read_pointer (Tuplestorestate *state, int eflags)
void	tuplestore_clear (Tuplestorestate *state)
void	tuplestore_end (Tuplestorestate *state)
void	tuplestore_select_read_pointer (Tuplestorestate *state, int ptr)
int64	tuplestore_tuple_count (Tuplestorestate *state)
bool	tuplestore_ateof (Tuplestorestate *state)
static bool	grow_memtuples (Tuplestorestate *state)
void	tuplestore_puttupleslot (Tuplestorestate *state, TupleTableSlot *slot)
void	tuplestore_puttuple (Tuplestorestate *state, HeapTuple tuple)
void	tuplestore_putvalues (Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)
static void *	tuplestore_gettuple (Tuplestorestate *state, bool forward, bool *should_free)
bool	tuplestore_gettupleslot (Tuplestorestate *state, bool forward, bool copy, TupleTableSlot *slot)
bool	tuplestore_gettupleslot_force (Tuplestorestate *state, bool forward, bool copy, TupleTableSlot *slot)
bool	tuplestore_advance (Tuplestorestate *state, bool forward)
bool	tuplestore_skiptuples (Tuplestorestate *state, int64 ntuples, bool forward)
void	tuplestore_rescan (Tuplestorestate *state)
void	tuplestore_copy_read_pointer (Tuplestorestate *state, int srcptr, int destptr)
void	tuplestore_trim (Tuplestorestate *state)
void	tuplestore_get_stats (Tuplestorestate *state, char **max_storage_type, int64 *max_space)
bool	tuplestore_in_memory (Tuplestorestate *state)

Macro Definition Documentation

COPYTUP

#define COPYTUP	(		state,
			tup
	)		((*(state)->copytup) (state, tup))

Definition at line 186 of file tuplestore.c.

FREEMEM

#define FREEMEM	(		state,
			amt
	)		((state)->availMem += (amt))

Definition at line 191 of file tuplestore.c.

LACKMEM

#define LACKMEM

(

state

)

((state)->availMem < 0)

Definition at line 189 of file tuplestore.c.

READTUP

#define READTUP	(		state,
			len
	)		((*(state)->readtup) (state, len))

Definition at line 188 of file tuplestore.c.

USEMEM

#define USEMEM	(		state,
			amt
	)		((state)->availMem -= (amt))

Definition at line 190 of file tuplestore.c.

WRITETUP

#define WRITETUP	(		state,
			tup
	)		((*(state)->writetup) (state, tup))

Definition at line 187 of file tuplestore.c.

Enumeration Type Documentation

TupStoreStatus

enum TupStoreStatus

Enumerator
TSS_INMEM
TSS_WRITEFILE
TSS_READFILE

Definition at line 73 of file tuplestore.c.

{
    TSS_INMEM,                  /* Tuples still fit in memory */
    TSS_WRITEFILE,              /* Writing to temp file */
    TSS_READFILE,               /* Reading from temp file */
} TupStoreStatus;

Function Documentation

copytup_heap()

static void * copytup_heap ( Tuplestorestate *  state, void *  tup  )

static

Definition at line 1622 of file tuplestore.c.

{
    MinimalTuple tuple;
 
    tuple = minimal_tuple_from_heap_tuple((HeapTuple) tup, 0);
    USEMEM(state, GetMemoryChunkSpace(tuple));
    return tuple;
}

References fb(), GetMemoryChunkSpace(), minimal_tuple_from_heap_tuple(), and USEMEM.

Referenced by tuplestore_begin_heap().

dumptuples()

static void dumptuples ( Tuplestorestate *  state )

static

Definition at line 1291 of file tuplestore.c.

{
    int         i;
 
    for (i = state->memtupdeleted;; i++)
    {
        TSReadPointer *readptr = state->readptrs;
        int         j;
 
        for (j = 0; j < state->readptrcount; readptr++, j++)
        {
            if (i == readptr->current && !readptr->eof_reached)
                BufFileTell(state->myfile,
                            &readptr->file, &readptr->offset);
        }
        if (i >= state->memtupcount)
            break;
        WRITETUP(state, state->memtuples[i]);
    }
    state->memtupdeleted = 0;
    state->memtupcount = 0;
}

References BufFileTell(), TSReadPointer::current, TSReadPointer::eof_reached, TSReadPointer::file, i, j, TSReadPointer::offset, and WRITETUP.

Referenced by tuplestore_puttuple_common().

getlen()

static unsigned int getlen ( Tuplestorestate *  state, bool  eofOK  )

static

Definition at line 1598 of file tuplestore.c.

{
    unsigned int len;
    size_t      nbytes;
 
    nbytes = BufFileReadMaybeEOF(state->myfile, &len, sizeof(len), eofOK);
    if (nbytes == 0)
        return 0;
    else
        return len;
}

References BufFileReadMaybeEOF(), fb(), and len.

Referenced by tuplestore_gettuple().

grow_memtuples()

static bool grow_memtuples ( Tuplestorestate *  state )

static

Definition at line 613 of file tuplestore.c.

{
    int         newmemtupsize;
    int         memtupsize = state->memtupsize;
    int64       memNowUsed = state->allowedMem - state->availMem;
 
    /* Forget it if we've already maxed out memtuples, per comment above */
    if (!state->growmemtuples)
        return false;
 
    /* Select new value of memtupsize */
    if (memNowUsed <= state->availMem)
    {
        /*
         * We've used no more than half of allowedMem; double our usage,
         * clamping at INT_MAX tuples.
         */
        if (memtupsize < INT_MAX / 2)
            newmemtupsize = memtupsize * 2;
        else
        {
            newmemtupsize = INT_MAX;
            state->growmemtuples = false;
        }
    }
    else
    {
        /*
         * This will be the last increment of memtupsize.  Abandon doubling
         * strategy and instead increase as much as we safely can.
         *
         * To stay within allowedMem, we can't increase memtupsize by more
         * than availMem / sizeof(void *) elements. In practice, we want to
         * increase it by considerably less, because we need to leave some
         * space for the tuples to which the new array slots will refer.  We
         * assume the new tuples will be about the same size as the tuples
         * we've already seen, and thus we can extrapolate from the space
         * consumption so far to estimate an appropriate new size for the
         * memtuples array.  The optimal value might be higher or lower than
         * this estimate, but it's hard to know that in advance.  We again
         * clamp at INT_MAX tuples.
         *
         * This calculation is safe against enlarging the array so much that
         * LACKMEM becomes true, because the memory currently used includes
         * the present array; thus, there would be enough allowedMem for the
         * new array elements even if no other memory were currently used.
         *
         * We do the arithmetic in float8, because otherwise the product of
         * memtupsize and allowedMem could overflow.  Any inaccuracy in the
         * result should be insignificant; but even if we computed a
         * completely insane result, the checks below will prevent anything
         * really bad from happening.
         */
        double      grow_ratio;
 
        grow_ratio = (double) state->allowedMem / (double) memNowUsed;
        if (memtupsize * grow_ratio < INT_MAX)
            newmemtupsize = (int) (memtupsize * grow_ratio);
        else
            newmemtupsize = INT_MAX;
 
        /* We won't make any further enlargement attempts */
        state->growmemtuples = false;
    }
 
    /* Must enlarge array by at least one element, else report failure */
    if (newmemtupsize <= memtupsize)
        goto noalloc;
 
    /*
     * On a 32-bit machine, allowedMem could exceed MaxAllocHugeSize.  Clamp
     * to ensure our request won't be rejected.  Note that we can easily
     * exhaust address space before facing this outcome.  (This is presently
     * impossible due to guc.c's MAX_KILOBYTES limitation on work_mem, but
     * don't rely on that at this distance.)
     */
    if ((Size) newmemtupsize >= MaxAllocHugeSize / sizeof(void *))
    {
        newmemtupsize = (int) (MaxAllocHugeSize / sizeof(void *));
        state->growmemtuples = false;   /* can't grow any more */
    }
 
    /*
     * We need to be sure that we do not cause LACKMEM to become true, else
     * the space management algorithm will go nuts.  The code above should
     * never generate a dangerous request, but to be safe, check explicitly
     * that the array growth fits within availMem.  (We could still cause
     * LACKMEM if the memory chunk overhead associated with the memtuples
     * array were to increase.  That shouldn't happen because we chose the
     * initial array size large enough to ensure that palloc will be treating
     * both old and new arrays as separate chunks.  But we'll check LACKMEM
     * explicitly below just in case.)
     */
    if (state->availMem < (int64) ((newmemtupsize - memtupsize) * sizeof(void *)))
        goto noalloc;
 
    /* OK, do it */
    FREEMEM(state, GetMemoryChunkSpace(state->memtuples));
    state->memtupsize = newmemtupsize;
    state->memtuples = (void **)
        repalloc_huge(state->memtuples,
                      state->memtupsize * sizeof(void *));
    USEMEM(state, GetMemoryChunkSpace(state->memtuples));
    if (LACKMEM(state))
        elog(ERROR, "unexpected out-of-memory situation in tuplestore");
    return true;
 
noalloc:
    /* If for any reason we didn't realloc, shut off future attempts */
    state->growmemtuples = false;
    return false;
}

References elog, ERROR, fb(), FREEMEM, GetMemoryChunkSpace(), LACKMEM, MaxAllocHugeSize, repalloc_huge(), and USEMEM.

Referenced by tuplestore_puttuple_common().

readtup_heap()

static void * readtup_heap ( Tuplestorestate *  state, unsigned int  len  )

static

Definition at line 1653 of file tuplestore.c.

{
    unsigned int tupbodylen = len - sizeof(int);
    unsigned int tuplen = tupbodylen + MINIMAL_TUPLE_DATA_OFFSET;
    MinimalTuple tuple = (MinimalTuple) palloc(tuplen);
    char       *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
 
    /* read in the tuple proper */
    tuple->t_len = tuplen;
    BufFileReadExact(state->myfile, tupbody, tupbodylen);
    if (state->backward)        /* need trailing length word? */
        BufFileReadExact(state->myfile, &tuplen, sizeof(tuplen));
    return tuple;
}

References BufFileReadExact(), fb(), len, MINIMAL_TUPLE_DATA_OFFSET, palloc(), and MinimalTupleData::t_len.

Referenced by tuplestore_begin_heap().

tuplestore_advance()

bool tuplestore_advance	(	Tuplestorestate *	state,
		bool	forward
	)

Definition at line 1195 of file tuplestore.c.

{
    void       *tuple;
    bool        should_free;
 
    tuple = tuplestore_gettuple(state, forward, &should_free);
 
    if (tuple)
    {
        if (should_free)
            pfree(tuple);
        return true;
    }
    else
    {
        return false;
    }
}

References fb(), pfree(), and tuplestore_gettuple().

Referenced by CteScanNext(), ExecMaterial(), and window_gettupleslot().

tuplestore_alloc_read_pointer()

int tuplestore_alloc_read_pointer	(	Tuplestorestate *	state,
		int	eflags
	)

Definition at line 396 of file tuplestore.c.

{
    /* Check for possible increase of requirements */
    if (state->status != TSS_INMEM || state->memtupcount != 0)
    {
        if ((state->eflags | eflags) != state->eflags)
            elog(ERROR, "too late to require new tuplestore eflags");
    }
 
    /* Make room for another read pointer if needed */
    if (state->readptrcount >= state->readptrsize)
    {
        int         newcnt = state->readptrsize * 2;
 
        state->readptrs = (TSReadPointer *)
            repalloc(state->readptrs, newcnt * sizeof(TSReadPointer));
        state->readptrsize = newcnt;
    }
 
    /* And set it up */
    state->readptrs[state->readptrcount] = state->readptrs[0];
    state->readptrs[state->readptrcount].eflags = eflags;
 
    state->eflags |= eflags;
 
    return state->readptrcount++;
}

References elog, ERROR, fb(), repalloc(), and TSS_INMEM.

Referenced by ExecInitCteScan(), ExecInitNamedTuplestoreScan(), ExecMaterial(), and prepare_tuplestore().

tuplestore_ateof()

bool tuplestore_ateof

(

Tuplestorestate *

state

)

Definition at line 592 of file tuplestore.c.

{
    return state->readptrs[state->activeptr].eof_reached;
}

Referenced by CteScanNext(), and ExecMaterial().

tuplestore_begin_common()

static Tuplestorestate * tuplestore_begin_common ( int  eflags, bool  interXact, int  maxKBytes  )

static

Definition at line 257 of file tuplestore.c.

{
    Tuplestorestate *state;
 
    state = palloc0_object(Tuplestorestate);
 
    state->status = TSS_INMEM;
    state->eflags = eflags;
    state->interXact = interXact;
    state->truncated = false;
    state->usedDisk = false;
    state->maxSpace = 0;
    state->allowedMem = maxKBytes * (int64) 1024;
    state->availMem = state->allowedMem;
    state->myfile = NULL;
 
    /*
     * The palloc/pfree pattern for tuple memory is in a FIFO pattern.  A
     * generation context is perfectly suited for this.
     */
    state->context = GenerationContextCreate(CurrentMemoryContext,
                                             "tuplestore tuples",
                                             ALLOCSET_DEFAULT_SIZES);
    state->resowner = CurrentResourceOwner;
 
    state->memtupdeleted = 0;
    state->memtupcount = 0;
    state->tuples = 0;
 
    /*
     * Initial size of array must be more than ALLOCSET_SEPARATE_THRESHOLD;
     * see comments in grow_memtuples().
     */
    state->memtupsize = Max(16384 / sizeof(void *),
                            ALLOCSET_SEPARATE_THRESHOLD / sizeof(void *) + 1);
 
    state->growmemtuples = true;
    state->memtuples = (void **) palloc(state->memtupsize * sizeof(void *));
 
    USEMEM(state, GetMemoryChunkSpace(state->memtuples));
 
    state->activeptr = 0;
    state->readptrcount = 1;
    state->readptrsize = 8;     /* arbitrary */
    state->readptrs = (TSReadPointer *)
        palloc(state->readptrsize * sizeof(TSReadPointer));
 
    state->readptrs[0].eflags = eflags;
    state->readptrs[0].eof_reached = false;
    state->readptrs[0].current = 0;
 
    return state;
}

References ALLOCSET_DEFAULT_SIZES, ALLOCSET_SEPARATE_THRESHOLD, CurrentMemoryContext, CurrentResourceOwner, fb(), GenerationContextCreate(), GetMemoryChunkSpace(), Max, palloc(), palloc0_object, TSS_INMEM, and USEMEM.

Referenced by tuplestore_begin_heap().

tuplestore_begin_heap()

Tuplestorestate * tuplestore_begin_heap	(	bool	randomAccess,
		bool	interXact,
		int	maxKBytes
	)

Definition at line 331 of file tuplestore.c.

{
    Tuplestorestate *state;
    int         eflags;
 
    /*
     * This interpretation of the meaning of randomAccess is compatible with
     * the pre-8.3 behavior of tuplestores.
     */
    eflags = randomAccess ?
        (EXEC_FLAG_BACKWARD | EXEC_FLAG_REWIND) :
        (EXEC_FLAG_REWIND);
 
    state = tuplestore_begin_common(eflags, interXact, maxKBytes);
 
    state->copytup = copytup_heap;
    state->writetup = writetup_heap;
    state->readtup = readtup_heap;
 
    return state;
}

References copytup_heap(), EXEC_FLAG_BACKWARD, EXEC_FLAG_REWIND, fb(), readtup_heap(), tuplestore_begin_common(), and writetup_heap().

Referenced by connectby(), crosstab(), exec_init_tuple_store(), ExecHashBuildNullTupleStore(), ExecInitCteScan(), ExecInitRecursiveUnion(), ExecMakeTableFunctionResult(), ExecMaterial(), get_crosstab_tuplestore(), GetCurrentFDWTuplestore(), InitMaterializedSRF(), libpqrcv_processTuples(), MakeTransitionCaptureState(), materializeQueryResult(), materializeResult(), plperl_return_next_internal(), pltcl_init_tuple_store(), populate_recordset_worker(), PortalCreateHoldStore(), postquel_start(), prepare_tuplestore(), storeRow(), and tfuncFetchRows().

tuplestore_clear()

void tuplestore_clear

(

Tuplestorestate *

state

)

Definition at line 431 of file tuplestore.c.

{
    int         i;
    TSReadPointer *readptr;
 
    /* update the maxSpace before doing any USEMEM/FREEMEM adjustments */
    tuplestore_updatemax(state);
 
    if (state->myfile)
        BufFileClose(state->myfile);
    state->myfile = NULL;
 
#ifdef USE_ASSERT_CHECKING
    {
        int64       availMem = state->availMem;
 
        /*
         * Below, we reset the memory context for storing tuples.  To save
         * from having to always call GetMemoryChunkSpace() on all stored
         * tuples, we adjust the availMem to forget all the tuples and just
         * recall USEMEM for the space used by the memtuples array.  Here we
         * just Assert that's correct and the memory tracking hasn't gone
         * wrong anywhere.
         */
        for (i = state->memtupdeleted; i < state->memtupcount; i++)
            availMem += GetMemoryChunkSpace(state->memtuples[i]);
 
        availMem += GetMemoryChunkSpace(state->memtuples);
 
        Assert(availMem == state->allowedMem);
    }
#endif
 
    /* clear the memory consumed by the memory tuples */
    MemoryContextReset(state->context);
 
    /*
     * Zero the used memory and re-consume the space for the memtuples array.
     * This saves having to FREEMEM for each stored tuple.
     */
    state->availMem = state->allowedMem;
    USEMEM(state, GetMemoryChunkSpace(state->memtuples));
 
    state->status = TSS_INMEM;
    state->truncated = false;
    state->memtupdeleted = 0;
    state->memtupcount = 0;
    state->tuples = 0;
    readptr = state->readptrs;
    for (i = 0; i < state->readptrcount; readptr++, i++)
    {
        readptr->eof_reached = false;
        readptr->current = 0;
    }
}

References Assert, BufFileClose(), TSReadPointer::current, TSReadPointer::eof_reached, fb(), GetMemoryChunkSpace(), i, MemoryContextReset(), TSS_INMEM, tuplestore_updatemax(), and USEMEM.

Referenced by ExecRecursiveUnion(), ExecReScanCteScan(), ExecReScanRecursiveUnion(), and release_partition().

tuplestore_copy_read_pointer()

void tuplestore_copy_read_pointer	(	Tuplestorestate *	state,
		int	srcptr,
		int	destptr
	)

Definition at line 1353 of file tuplestore.c.

{
    TSReadPointer *sptr = &state->readptrs[srcptr];
    TSReadPointer *dptr = &state->readptrs[destptr];
 
    Assert(srcptr >= 0 && srcptr < state->readptrcount);
    Assert(destptr >= 0 && destptr < state->readptrcount);
 
    /* Assigning to self is a no-op */
    if (srcptr == destptr)
        return;
 
    if (dptr->eflags != sptr->eflags)
    {
        /* Possible change of overall eflags, so copy and then recompute */
        int         eflags;
        int         i;
 
        *dptr = *sptr;
        eflags = state->readptrs[0].eflags;
        for (i = 1; i < state->readptrcount; i++)
            eflags |= state->readptrs[i].eflags;
        state->eflags = eflags;
    }
    else
        *dptr = *sptr;
 
    switch (state->status)
    {
        case TSS_INMEM:
        case TSS_WRITEFILE:
            /* no work */
            break;
        case TSS_READFILE:
 
            /*
             * This case is a bit tricky since the active read pointer's
             * position corresponds to the seek point, not what is in its
             * variables.  Assigning to the active requires a seek, and
             * assigning from the active requires a tell, except when
             * eof_reached.
             */
            if (destptr == state->activeptr)
            {
                if (dptr->eof_reached)
                {
                    if (BufFileSeek(state->myfile,
                                    state->writepos_file,
                                    state->writepos_offset,
                                    SEEK_SET) != 0)
                        ereport(ERROR,
                                (errcode_for_file_access(),
                                 errmsg("could not seek in tuplestore temporary file")));
                }
                else
                {
                    if (BufFileSeek(state->myfile,
                                    dptr->file, dptr->offset,
                                    SEEK_SET) != 0)
                        ereport(ERROR,
                                (errcode_for_file_access(),
                                 errmsg("could not seek in tuplestore temporary file")));
                }
            }
            else if (srcptr == state->activeptr)
            {
                if (!dptr->eof_reached)
                    BufFileTell(state->myfile,
                                &dptr->file,
                                &dptr->offset);
            }
            break;
        default:
            elog(ERROR, "invalid tuplestore state");
            break;
    }
}

References Assert, BufFileSeek(), BufFileTell(), elog, ereport, errcode_for_file_access(), errmsg, ERROR, fb(), i, TSS_INMEM, TSS_READFILE, and TSS_WRITEFILE.

Referenced by ExecMaterialMarkPos(), and ExecMaterialRestrPos().

tuplestore_end()

void tuplestore_end

(

Tuplestorestate *

state

)

Definition at line 493 of file tuplestore.c.

{
    if (state->myfile)
        BufFileClose(state->myfile);
 
    MemoryContextDelete(state->context);
    pfree(state->memtuples);
    pfree(state->readptrs);
    pfree(state);
}

References BufFileClose(), MemoryContextDelete(), and pfree().

Referenced by AfterTriggerFreeQuery(), ExecEndCteScan(), ExecEndFunctionScan(), ExecEndHashJoin(), ExecEndMaterial(), ExecEndRecursiveUnion(), ExecEndTableFuncScan(), ExecEndWindowAgg(), ExecHashJoinImpl(), ExecHashJoinReInitializeDSM(), ExecMakeFunctionResultSet(), ExecReScanFunctionScan(), ExecReScanHashJoin(), ExecReScanMaterial(), ExecReScanTableFuncScan(), PortalDrop(), ShutdownSetExpr(), ShutdownSQLFunction(), storeRow(), and walrcv_clear_result().

tuplestore_get_stats()

void tuplestore_get_stats	(	Tuplestorestate *	state,
		char **	max_storage_type,
		int64 *	max_space
	)

Definition at line 1566 of file tuplestore.c.

{
    tuplestore_updatemax(state);
 
    if (state->usedDisk)
        *max_storage_type = "Disk";
    else
        *max_storage_type = "Memory";
 
    *max_space = state->maxSpace;
}

References fb(), and tuplestore_updatemax().

Referenced by show_ctescan_info(), show_material_info(), show_recursive_union_info(), show_table_func_scan_info(), and show_windowagg_info().

tuplestore_gettuple()

static void * tuplestore_gettuple ( Tuplestorestate *  state, bool  forward, bool *  should_free  )

static

Definition at line 956 of file tuplestore.c.

{
    TSReadPointer *readptr = &state->readptrs[state->activeptr];
    unsigned int tuplen;
    void       *tup;
 
    Assert(forward || (readptr->eflags & EXEC_FLAG_BACKWARD));
 
    switch (state->status)
    {
        case TSS_INMEM:
            *should_free = false;
            if (forward)
            {
                if (readptr->eof_reached)
                    return NULL;
                if (readptr->current < state->memtupcount)
                {
                    /* We have another tuple, so return it */
                    return state->memtuples[readptr->current++];
                }
                readptr->eof_reached = true;
                return NULL;
            }
            else
            {
                /*
                 * if all tuples are fetched already then we return last
                 * tuple, else tuple before last returned.
                 */
                if (readptr->eof_reached)
                {
                    readptr->current = state->memtupcount;
                    readptr->eof_reached = false;
                }
                else
                {
                    if (readptr->current <= state->memtupdeleted)
                    {
                        Assert(!state->truncated);
                        return NULL;
                    }
                    readptr->current--; /* last returned tuple */
                }
                if (readptr->current <= state->memtupdeleted)
                {
                    Assert(!state->truncated);
                    return NULL;
                }
                return state->memtuples[readptr->current - 1];
            }
            break;
 
        case TSS_WRITEFILE:
            /* Skip state change if we'll just return NULL */
            if (readptr->eof_reached && forward)
                return NULL;
 
            /*
             * Switch from writing to reading.
             */
            BufFileTell(state->myfile,
                        &state->writepos_file, &state->writepos_offset);
            if (!readptr->eof_reached)
                if (BufFileSeek(state->myfile,
                                readptr->file, readptr->offset,
                                SEEK_SET) != 0)
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("could not seek in tuplestore temporary file")));
            state->status = TSS_READFILE;
            pg_fallthrough;
 
        case TSS_READFILE:
            *should_free = true;
            if (forward)
            {
                if ((tuplen = getlen(state, true)) != 0)
                {
                    tup = READTUP(state, tuplen);
                    return tup;
                }
                else
                {
                    readptr->eof_reached = true;
                    return NULL;
                }
            }
 
            /*
             * Backward.
             *
             * if all tuples are fetched already then we return last tuple,
             * else tuple before last returned.
             *
             * Back up to fetch previously-returned tuple's ending length
             * word. If seek fails, assume we are at start of file.
             */
            if (BufFileSeek(state->myfile, 0, -(pgoff_t) sizeof(unsigned int),
                            SEEK_CUR) != 0)
            {
                /* even a failed backwards fetch gets you out of eof state */
                readptr->eof_reached = false;
                Assert(!state->truncated);
                return NULL;
            }
            tuplen = getlen(state, false);
 
            if (readptr->eof_reached)
            {
                readptr->eof_reached = false;
                /* We will return the tuple returned before returning NULL */
            }
            else
            {
                /*
                 * Back up to get ending length word of tuple before it.
                 */
                if (BufFileSeek(state->myfile, 0,
                                -(pgoff_t) (tuplen + 2 * sizeof(unsigned int)),
                                SEEK_CUR) != 0)
                {
                    /*
                     * If that fails, presumably the prev tuple is the first
                     * in the file.  Back up so that it becomes next to read
                     * in forward direction (not obviously right, but that is
                     * what in-memory case does).
                     */
                    if (BufFileSeek(state->myfile, 0,
                                    -(pgoff_t) (tuplen + sizeof(unsigned int)),
                                    SEEK_CUR) != 0)
                        ereport(ERROR,
                                (errcode_for_file_access(),
                                 errmsg("could not seek in tuplestore temporary file")));
                    Assert(!state->truncated);
                    return NULL;
                }
                tuplen = getlen(state, false);
            }
 
            /*
             * Now we have the length of the prior tuple, back up and read it.
             * Note: READTUP expects we are positioned after the initial
             * length word of the tuple, so back up to that point.
             */
            if (BufFileSeek(state->myfile, 0,
                            -(pgoff_t) tuplen,
                            SEEK_CUR) != 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not seek in tuplestore temporary file")));
            tup = READTUP(state, tuplen);
            return tup;
 
        default:
            elog(ERROR, "invalid tuplestore state");
            return NULL;        /* keep compiler quiet */
    }
}

References Assert, BufFileSeek(), BufFileTell(), TSReadPointer::current, TSReadPointer::eflags, elog, TSReadPointer::eof_reached, ereport, errcode_for_file_access(), errmsg, ERROR, EXEC_FLAG_BACKWARD, fb(), TSReadPointer::file, getlen(), TSReadPointer::offset, pg_fallthrough, READTUP, TSS_INMEM, TSS_READFILE, and TSS_WRITEFILE.

Referenced by tuplestore_advance(), tuplestore_gettupleslot(), tuplestore_gettupleslot_force(), and tuplestore_skiptuples().

tuplestore_gettupleslot()

bool tuplestore_gettupleslot	(	Tuplestorestate *	state,
		bool	forward,
		bool	copy,
		TupleTableSlot *	slot
	)

Definition at line 1131 of file tuplestore.c.

{
    MinimalTuple tuple;
    bool        should_free;
 
    tuple = (MinimalTuple) tuplestore_gettuple(state, forward, &should_free);
 
    if (tuple)
    {
        if (copy && !should_free)
        {
            tuple = heap_copy_minimal_tuple(tuple, 0);
            should_free = true;
        }
        ExecStoreMinimalTuple(tuple, slot, should_free);
        return true;
    }
    else
    {
        ExecClearTuple(slot);
        return false;
    }
}

References ExecClearTuple(), ExecStoreMinimalTuple(), fb(), heap_copy_minimal_tuple(), and tuplestore_gettuple().

Referenced by AfterTriggerExecute(), check_pub_dead_tuple_retention(), check_publications(), check_publications_origin_sequences(), check_publications_origin_tables(), copy_sequences(), CteScanNext(), ExecHashJoinImpl(), ExecMakeFunctionResultSet(), ExecMaterial(), ExecWindowAgg(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), FunctionNext(), NamedTuplestoreScanNext(), RunFromStore(), TableFuncNext(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), validate_remote_info(), window_gettupleslot(), and WorkTableScanNext().

tuplestore_gettupleslot_force()

bool tuplestore_gettupleslot_force	(	Tuplestorestate *	state,
		bool	forward,
		bool	copy,
		TupleTableSlot *	slot
	)

Definition at line 1163 of file tuplestore.c.

{
    MinimalTuple tuple;
    bool        should_free;
 
    tuple = (MinimalTuple) tuplestore_gettuple(state, forward, &should_free);
 
    if (tuple)
    {
        if (copy && !should_free)
        {
            tuple = heap_copy_minimal_tuple(tuple, 0);
            should_free = true;
        }
        ExecForceStoreMinimalTuple(tuple, slot, should_free);
        return true;
    }
    else
    {
        ExecClearTuple(slot);
        return false;
    }
}

References ExecClearTuple(), ExecForceStoreMinimalTuple(), fb(), heap_copy_minimal_tuple(), and tuplestore_gettuple().

Referenced by ExecHashJoinImpl().

tuplestore_in_memory()

bool tuplestore_in_memory

(

Tuplestorestate *

state

)

Definition at line 1587 of file tuplestore.c.

{
    return (state->status == TSS_INMEM);
}

References TSS_INMEM.

Referenced by spool_tuples().

tuplestore_puttuple()

void tuplestore_puttuple	(	Tuplestorestate *	state,
		HeapTuple	tuple
	)

Definition at line 765 of file tuplestore.c.

{
    MemoryContext oldcxt = MemoryContextSwitchTo(state->context);
 
    /*
     * Copy the tuple.  (Must do this even in WRITEFILE case.  Note that
     * COPYTUP includes USEMEM, so we needn't do that here.)
     */
    tuple = COPYTUP(state, tuple);
 
    tuplestore_puttuple_common(state, tuple);
 
    MemoryContextSwitchTo(oldcxt);
}

References COPYTUP, fb(), MemoryContextSwitchTo(), and tuplestore_puttuple_common().

Referenced by build_tuplestore_recursively(), crosstab(), each_object_field_end(), elements_array_element_end(), exec_stmt_return_next(), ExecMakeTableFunctionResult(), fill_hba_line(), fill_ident_line(), get_crosstab_tuplestore(), libpqrcv_processTuples(), materializeQueryResult(), materializeResult(), pg_available_wal_summaries(), pg_wal_summary_contents(), pgrowlocks(), plperl_return_next_internal(), pltcl_returnnext(), populate_recordset_record(), report_corruption_internal(), storeRow(), and xpath_table().

tuplestore_puttuple_common()

static void tuplestore_puttuple_common ( Tuplestorestate *  state, void *  tuple  )

static

Definition at line 800 of file tuplestore.c.

{
    TSReadPointer *readptr;
    int         i;
    ResourceOwner oldowner;
    MemoryContext oldcxt;
 
    state->tuples++;
 
    switch (state->status)
    {
        case TSS_INMEM:
 
            /*
             * Update read pointers as needed; see API spec above.
             */
            readptr = state->readptrs;
            for (i = 0; i < state->readptrcount; readptr++, i++)
            {
                if (readptr->eof_reached && i != state->activeptr)
                {
                    readptr->eof_reached = false;
                    readptr->current = state->memtupcount;
                }
            }
 
            /*
             * Grow the array as needed.  Note that we try to grow the array
             * when there is still one free slot remaining --- if we fail,
             * there'll still be room to store the incoming tuple, and then
             * we'll switch to tape-based operation.
             */
            if (state->memtupcount >= state->memtupsize - 1)
            {
                (void) grow_memtuples(state);
                Assert(state->memtupcount < state->memtupsize);
            }
 
            /* Stash the tuple in the in-memory array */
            state->memtuples[state->memtupcount++] = tuple;
 
            /*
             * Done if we still fit in available memory and have array slots.
             */
            if (state->memtupcount < state->memtupsize && !LACKMEM(state))
                return;
 
            /*
             * Nope; time to switch to tape-based operation.  Make sure that
             * the temp file(s) are created in suitable temp tablespaces.
             */
            PrepareTempTablespaces();
 
            /* associate the file with the store's resource owner */
            oldowner = CurrentResourceOwner;
            CurrentResourceOwner = state->resowner;
 
            /*
             * We switch out of the state->context as this is a generation
             * context, which isn't ideal for allocations relating to the
             * BufFile.
             */
            oldcxt = MemoryContextSwitchTo(state->context->parent);
 
            state->myfile = BufFileCreateTemp(state->interXact);
 
            MemoryContextSwitchTo(oldcxt);
 
            CurrentResourceOwner = oldowner;
 
            /*
             * Freeze the decision about whether trailing length words will be
             * used.  We can't change this choice once data is on tape, even
             * though callers might drop the requirement.
             */
            state->backward = (state->eflags & EXEC_FLAG_BACKWARD) != 0;
 
            /*
             * Update the maximum space used before dumping the tuples.  It's
             * possible that more space will be used by the tuples in memory
             * than the space that will be used on disk.
             */
            tuplestore_updatemax(state);
 
            state->status = TSS_WRITEFILE;
            dumptuples(state);
            break;
        case TSS_WRITEFILE:
 
            /*
             * Update read pointers as needed; see API spec above. Note:
             * BufFileTell is quite cheap, so not worth trying to avoid
             * multiple calls.
             */
            readptr = state->readptrs;
            for (i = 0; i < state->readptrcount; readptr++, i++)
            {
                if (readptr->eof_reached && i != state->activeptr)
                {
                    readptr->eof_reached = false;
                    BufFileTell(state->myfile,
                                &readptr->file,
                                &readptr->offset);
                }
            }
 
            WRITETUP(state, tuple);
            break;
        case TSS_READFILE:
 
            /*
             * Switch from reading to writing.
             */
            if (!state->readptrs[state->activeptr].eof_reached)
                BufFileTell(state->myfile,
                            &state->readptrs[state->activeptr].file,
                            &state->readptrs[state->activeptr].offset);
            if (BufFileSeek(state->myfile,
                            state->writepos_file, state->writepos_offset,
                            SEEK_SET) != 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not seek in tuplestore temporary file")));
            state->status = TSS_WRITEFILE;
 
            /*
             * Update read pointers as needed; see API spec above.
             */
            readptr = state->readptrs;
            for (i = 0; i < state->readptrcount; readptr++, i++)
            {
                if (readptr->eof_reached && i != state->activeptr)
                {
                    readptr->eof_reached = false;
                    readptr->file = state->writepos_file;
                    readptr->offset = state->writepos_offset;
                }
            }
 
            WRITETUP(state, tuple);
            break;
        default:
            elog(ERROR, "invalid tuplestore state");
            break;
    }
}

References Assert, BufFileCreateTemp(), BufFileSeek(), BufFileTell(), TSReadPointer::current, CurrentResourceOwner, dumptuples(), elog, TSReadPointer::eof_reached, ereport, errcode_for_file_access(), errmsg, ERROR, EXEC_FLAG_BACKWARD, fb(), TSReadPointer::file, grow_memtuples(), i, LACKMEM, MemoryContextSwitchTo(), TSReadPointer::offset, PrepareTempTablespaces(), TSS_INMEM, TSS_READFILE, TSS_WRITEFILE, tuplestore_updatemax(), and WRITETUP.

Referenced by tuplestore_puttuple(), tuplestore_puttupleslot(), and tuplestore_putvalues().

tuplestore_puttupleslot()

void tuplestore_puttupleslot	(	Tuplestorestate *	state,
		TupleTableSlot *	slot
	)

Definition at line 743 of file tuplestore.c.

{
    MinimalTuple tuple;
    MemoryContext oldcxt = MemoryContextSwitchTo(state->context);
 
    /*
     * Form a MinimalTuple in working memory
     */
    tuple = ExecCopySlotMinimalTuple(slot);
    USEMEM(state, GetMemoryChunkSpace(tuple));
 
    tuplestore_puttuple_common(state, tuple);
 
    MemoryContextSwitchTo(oldcxt);
}

References ExecCopySlotMinimalTuple(), fb(), GetMemoryChunkSpace(), MemoryContextSwitchTo(), tuplestore_puttuple_common(), and USEMEM.

Referenced by AfterTriggerSaveEvent(), begin_partition(), CteScanNext(), ExecHashJoinOuterGetTuple(), ExecMaterial(), ExecParallelHashJoinOuterGetTuple(), ExecParallelHashJoinPartitionOuter(), ExecRecursiveUnion(), MultiExecParallelHash(), MultiExecPrivateHash(), spool_tuples(), sqlfunction_receive(), TransitionTableAddTuple(), tstoreReceiveSlot_notoast(), and tstoreReceiveSlot_tupmap().

tuplestore_putvalues()

void tuplestore_putvalues	(	Tuplestorestate *	state,
		TupleDesc	tdesc,
		const Datum *	values,
		const bool *	isnull
	)

Definition at line 785 of file tuplestore.c.

{
    MinimalTuple tuple;
    MemoryContext oldcxt = MemoryContextSwitchTo(state->context);
 
    tuple = heap_form_minimal_tuple(tdesc, values, isnull, 0);
    USEMEM(state, GetMemoryChunkSpace(tuple));
 
    tuplestore_puttuple_common(state, tuple);
 
    MemoryContextSwitchTo(oldcxt);
}

References fb(), GetMemoryChunkSpace(), heap_form_minimal_tuple(), MemoryContextSwitchTo(), tuplestore_puttuple_common(), USEMEM, and values.

Referenced by brin_page_items(), dblink_get_notify(), each_worker_jsonb(), elements_worker_jsonb(), exec_stmt_return_next(), ExecMakeTableFunctionResult(), get_altertable_subcmdinfo(), get_available_versions_for_extension(), GetWALBlockInfo(), GetWALRecordsInfo(), GetXLogSummaryStats(), gist_page_items(), gist_page_items_bytea(), injection_points_list(), LogicalOutputWrite(), pg_available_extensions(), pg_buffercache_usage_counts(), pg_config(), pg_cursor(), pg_event_trigger_ddl_commands(), pg_event_trigger_dropped_objects(), pg_extension_update_paths(), pg_get_aios(), pg_get_dsm_registry_allocations(), pg_get_loaded_modules(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_get_shmem_allocations_numa(), pg_get_wait_events(), pg_get_wal_resource_managers(), pg_ls_dir(), pg_ls_dir_files(), pg_options_to_table(), pg_prepared_statement(), pg_show_replication_origin_status(), pg_stat_get_activity(), pg_stat_get_progress_info(), pg_stat_get_recovery_prefetch(), pg_stat_get_slru(), pg_stat_get_subscription(), pg_stat_get_wal_senders(), pg_stat_io_build_tuples(), pg_stat_statements_internal(), pg_tablespace_databases(), pg_timezone_names(), plperl_return_next_internal(), pltcl_returnnext(), postgres_fdw_get_connections_internal(), PutMemoryContextsStatsTupleStore(), show_all_file_settings(), split_text_accum_result(), tfuncLoadRows(), and tstoreReceiveSlot_detoast().

tuplestore_rescan()

void tuplestore_rescan

(

Tuplestorestate *

state

)

Definition at line 1318 of file tuplestore.c.

{
    TSReadPointer *readptr = &state->readptrs[state->activeptr];
 
    Assert(readptr->eflags & EXEC_FLAG_REWIND);
    Assert(!state->truncated);
 
    switch (state->status)
    {
        case TSS_INMEM:
            readptr->eof_reached = false;
            readptr->current = 0;
            break;
        case TSS_WRITEFILE:
            readptr->eof_reached = false;
            readptr->file = 0;
            readptr->offset = 0;
            break;
        case TSS_READFILE:
            readptr->eof_reached = false;
            if (BufFileSeek(state->myfile, 0, 0, SEEK_SET) != 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not seek in tuplestore temporary file")));
            break;
        default:
            elog(ERROR, "invalid tuplestore state");
            break;
    }
}

References Assert, BufFileSeek(), TSReadPointer::current, TSReadPointer::eflags, elog, TSReadPointer::eof_reached, ereport, errcode_for_file_access(), errmsg, ERROR, EXEC_FLAG_REWIND, fb(), TSReadPointer::file, TSReadPointer::offset, TSS_INMEM, TSS_READFILE, and TSS_WRITEFILE.

Referenced by DoPortalRewind(), ExecInitCteScan(), ExecInitNamedTuplestoreScan(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanHashJoin(), ExecReScanMaterial(), ExecReScanNamedTuplestoreScan(), ExecReScanTableFuncScan(), ExecReScanWorkTableScan(), FunctionNext(), and PersistHoldablePortal().

tuplestore_select_read_pointer()

void tuplestore_select_read_pointer	(	Tuplestorestate *	state,
		int	ptr
	)

Definition at line 508 of file tuplestore.c.

{
    TSReadPointer *readptr;
    TSReadPointer *oldptr;
 
    Assert(ptr >= 0 && ptr < state->readptrcount);
 
    /* No work if already active */
    if (ptr == state->activeptr)
        return;
 
    readptr = &state->readptrs[ptr];
    oldptr = &state->readptrs[state->activeptr];
 
    switch (state->status)
    {
        case TSS_INMEM:
        case TSS_WRITEFILE:
            /* no work */
            break;
        case TSS_READFILE:
 
            /*
             * First, save the current read position in the pointer about to
             * become inactive.
             */
            if (!oldptr->eof_reached)
                BufFileTell(state->myfile,
                            &oldptr->file,
                            &oldptr->offset);
 
            /*
             * We have to make the temp file's seek position equal to the
             * logical position of the new read pointer.  In eof_reached
             * state, that's the EOF, which we have available from the saved
             * write position.
             */
            if (readptr->eof_reached)
            {
                if (BufFileSeek(state->myfile,
                                state->writepos_file,
                                state->writepos_offset,
                                SEEK_SET) != 0)
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("could not seek in tuplestore temporary file")));
            }
            else
            {
                if (BufFileSeek(state->myfile,
                                readptr->file,
                                readptr->offset,
                                SEEK_SET) != 0)
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("could not seek in tuplestore temporary file")));
            }
            break;
        default:
            elog(ERROR, "invalid tuplestore state");
            break;
    }
 
    state->activeptr = ptr;
}

References Assert, BufFileSeek(), BufFileTell(), elog, TSReadPointer::eof_reached, ereport, errcode_for_file_access(), errmsg, ERROR, fb(), TSReadPointer::file, TSReadPointer::offset, TSS_INMEM, TSS_READFILE, and TSS_WRITEFILE.

Referenced by CteScanNext(), ExecInitCteScan(), ExecInitNamedTuplestoreScan(), ExecReScanCteScan(), ExecReScanNamedTuplestoreScan(), ExecWindowAgg(), NamedTuplestoreScanNext(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), window_gettupleslot(), and WinSetMarkPosition().

tuplestore_set_eflags()

void tuplestore_set_eflags	(	Tuplestorestate *	state,
		int	eflags
	)

Definition at line 372 of file tuplestore.c.

{
    int         i;
 
    if (state->status != TSS_INMEM || state->memtupcount != 0)
        elog(ERROR, "too late to call tuplestore_set_eflags");
 
    state->readptrs[0].eflags = eflags;
    for (i = 1; i < state->readptrcount; i++)
        eflags |= state->readptrs[i].eflags;
    state->eflags = eflags;
}

References elog, ERROR, i, and TSS_INMEM.

Referenced by ExecInitCteScan(), ExecMaterial(), and prepare_tuplestore().

tuplestore_skiptuples()

bool tuplestore_skiptuples	(	Tuplestorestate *	state,
		int64	ntuples,
		bool	forward
	)

Definition at line 1220 of file tuplestore.c.

{
    TSReadPointer *readptr = &state->readptrs[state->activeptr];
 
    Assert(forward || (readptr->eflags & EXEC_FLAG_BACKWARD));
 
    if (ntuples <= 0)
        return true;
 
    switch (state->status)
    {
        case TSS_INMEM:
            if (forward)
            {
                if (readptr->eof_reached)
                    return false;
                if (state->memtupcount - readptr->current >= ntuples)
                {
                    readptr->current += ntuples;
                    return true;
                }
                readptr->current = state->memtupcount;
                readptr->eof_reached = true;
                return false;
            }
            else
            {
                if (readptr->eof_reached)
                {
                    readptr->current = state->memtupcount;
                    readptr->eof_reached = false;
                    ntuples--;
                }
                if (readptr->current - state->memtupdeleted > ntuples)
                {
                    readptr->current -= ntuples;
                    return true;
                }
                Assert(!state->truncated);
                readptr->current = state->memtupdeleted;
                return false;
            }
            break;
 
        default:
            /* We don't currently try hard to optimize other cases */
            while (ntuples-- > 0)
            {
                void       *tuple;
                bool        should_free;
 
                tuple = tuplestore_gettuple(state, forward, &should_free);
 
                if (tuple == NULL)
                    return false;
                if (should_free)
                    pfree(tuple);
                CHECK_FOR_INTERRUPTS();
            }
            return true;
    }
}

References Assert, CHECK_FOR_INTERRUPTS, TSReadPointer::current, TSReadPointer::eflags, TSReadPointer::eof_reached, EXEC_FLAG_BACKWARD, fb(), pfree(), TSS_INMEM, and tuplestore_gettuple().

Referenced by PersistHoldablePortal(), window_gettupleslot(), and WinSetMarkPosition().

tuplestore_trim()

void tuplestore_trim

(

Tuplestorestate *

state

)

Definition at line 1445 of file tuplestore.c.

{
    int         oldest;
    int         nremove;
    int         i;
 
    /*
     * Truncation is disallowed if any read pointer requires rewind
     * capability.
     */
    if (state->eflags & EXEC_FLAG_REWIND)
        return;
 
    /*
     * We don't bother trimming temp files since it usually would mean more
     * work than just letting them sit in kernel buffers until they age out.
     */
    if (state->status != TSS_INMEM)
        return;
 
    /* Find the oldest read pointer */
    oldest = state->memtupcount;
    for (i = 0; i < state->readptrcount; i++)
    {
        if (!state->readptrs[i].eof_reached)
            oldest = Min(oldest, state->readptrs[i].current);
    }
 
    /*
     * Note: you might think we could remove all the tuples before the oldest
     * "current", since that one is the next to be returned.  However, since
     * tuplestore_gettuple returns a direct pointer to our internal copy of
     * the tuple, it's likely that the caller has still got the tuple just
     * before "current" referenced in a slot. So we keep one extra tuple
     * before the oldest "current".  (Strictly speaking, we could require such
     * callers to use the "copy" flag to tuplestore_gettupleslot, but for
     * efficiency we allow this one case to not use "copy".)
     */
    nremove = oldest - 1;
    if (nremove <= 0)
        return;                 /* nothing to do */
 
    Assert(nremove >= state->memtupdeleted);
    Assert(nremove <= state->memtupcount);
 
    /* before freeing any memory, update the statistics */
    tuplestore_updatemax(state);
 
    /* Release no-longer-needed tuples */
    for (i = state->memtupdeleted; i < nremove; i++)
    {
        FREEMEM(state, GetMemoryChunkSpace(state->memtuples[i]));
        pfree(state->memtuples[i]);
        state->memtuples[i] = NULL;
    }
    state->memtupdeleted = nremove;
 
    /* mark tuplestore as truncated (used for Assert crosschecks only) */
    state->truncated = true;
 
    /*
     * If nremove is less than 1/8th memtupcount, just stop here, leaving the
     * "deleted" slots as NULL.  This prevents us from expending O(N^2) time
     * repeatedly memmove-ing a large pointer array.  The worst case space
     * wastage is pretty small, since it's just pointers and not whole tuples.
     */
    if (nremove < state->memtupcount / 8)
        return;
 
    /*
     * Slide the array down and readjust pointers.
     *
     * In mergejoin's current usage, it's demonstrable that there will always
     * be exactly one non-removed tuple; so optimize that case.
     */
    if (nremove + 1 == state->memtupcount)
        state->memtuples[0] = state->memtuples[nremove];
    else
        memmove(state->memtuples, state->memtuples + nremove,
                (state->memtupcount - nremove) * sizeof(void *));
 
    state->memtupdeleted = 0;
    state->memtupcount -= nremove;
    for (i = 0; i < state->readptrcount; i++)
    {
        if (!state->readptrs[i].eof_reached)
            state->readptrs[i].current -= nremove;
    }
}

References Assert, EXEC_FLAG_REWIND, fb(), FREEMEM, GetMemoryChunkSpace(), i, Min, pfree(), TSS_INMEM, and tuplestore_updatemax().

Referenced by ExecMaterialMarkPos(), and ExecWindowAgg().

tuplestore_tuple_count()

int64 tuplestore_tuple_count

(

Tuplestorestate *

state

)

Definition at line 581 of file tuplestore.c.

{
    return state->tuples;
}

Referenced by exec_stmt_return_query(), fetch_remote_table_info(), and SPI_register_trigger_data().

tuplestore_updatemax()

static void tuplestore_updatemax ( Tuplestorestate *  state )

static

Definition at line 1541 of file tuplestore.c.

{
    if (state->status == TSS_INMEM)
        state->maxSpace = Max(state->maxSpace,
                              state->allowedMem - state->availMem);
    else
    {
        state->maxSpace = Max(state->maxSpace,
                              BufFileSize(state->myfile));
 
        /*
         * usedDisk never gets set to false again after spilling to disk, even
         * if tuplestore_clear() is called and new tuples go to memory again.
         */
        state->usedDisk = true;
    }
}

References BufFileSize(), Max, and TSS_INMEM.

Referenced by tuplestore_clear(), tuplestore_get_stats(), tuplestore_puttuple_common(), and tuplestore_trim().

writetup_heap()

static void writetup_heap ( Tuplestorestate *  state, void *  tup  )

static

Definition at line 1632 of file tuplestore.c.

{
    MinimalTuple tuple = (MinimalTuple) tup;
 
    /* the part of the MinimalTuple we'll write: */
    char       *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
    unsigned int tupbodylen = tuple->t_len - MINIMAL_TUPLE_DATA_OFFSET;
 
    /* total on-disk footprint: */
    unsigned int tuplen = tupbodylen + sizeof(int);
 
    BufFileWrite(state->myfile, &tuplen, sizeof(tuplen));
    BufFileWrite(state->myfile, tupbody, tupbodylen);
    if (state->backward)        /* need trailing length word? */
        BufFileWrite(state->myfile, &tuplen, sizeof(tuplen));
 
    FREEMEM(state, GetMemoryChunkSpace(tuple));
    heap_free_minimal_tuple(tuple);
}

References BufFileWrite(), fb(), FREEMEM, GetMemoryChunkSpace(), heap_free_minimal_tuple(), MINIMAL_TUPLE_DATA_OFFSET, and MinimalTupleData::t_len.

Referenced by tuplestore_begin_heap().