execTuples.c File Reference

#include "postgres.h"
#include "access/heaptoast.h"
#include "access/htup_details.h"
#include "access/tupdesc_details.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "nodes/nodeFuncs.h"
#include "storage/bufmgr.h"
#include "utils/builtins.h"
#include "utils/expandeddatum.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"

Include dependency graph for execTuples.c:

Go to the source code of this file.

Functions
static TupleDesc	ExecTypeFromTLInternal (List *targetList, bool skipjunk)
static pg_attribute_always_inline void	slot_deform_heap_tuple (TupleTableSlot *slot, HeapTuple tuple, uint32 *offp, int natts)
static void	tts_buffer_heap_store_tuple (TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
static void	tts_heap_store_tuple (TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
static void	tts_virtual_init (TupleTableSlot *slot)
static void	tts_virtual_release (TupleTableSlot *slot)
static void	tts_virtual_clear (TupleTableSlot *slot)
static void	tts_virtual_getsomeattrs (TupleTableSlot *slot, int natts)
static Datum	tts_virtual_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
static void	tts_virtual_materialize (TupleTableSlot *slot)
static void	tts_virtual_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
static HeapTuple	tts_virtual_copy_heap_tuple (TupleTableSlot *slot)
static MinimalTuple	tts_virtual_copy_minimal_tuple (TupleTableSlot *slot)
static void	tts_heap_init (TupleTableSlot *slot)
static void	tts_heap_release (TupleTableSlot *slot)
static void	tts_heap_clear (TupleTableSlot *slot)
static void	tts_heap_getsomeattrs (TupleTableSlot *slot, int natts)
static Datum	tts_heap_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
static void	tts_heap_materialize (TupleTableSlot *slot)
static void	tts_heap_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
static HeapTuple	tts_heap_get_heap_tuple (TupleTableSlot *slot)
static HeapTuple	tts_heap_copy_heap_tuple (TupleTableSlot *slot)
static MinimalTuple	tts_heap_copy_minimal_tuple (TupleTableSlot *slot)
static void	tts_minimal_init (TupleTableSlot *slot)
static void	tts_minimal_release (TupleTableSlot *slot)
static void	tts_minimal_clear (TupleTableSlot *slot)
static void	tts_minimal_getsomeattrs (TupleTableSlot *slot, int natts)
static Datum	tts_minimal_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
static void	tts_minimal_materialize (TupleTableSlot *slot)
static void	tts_minimal_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
static MinimalTuple	tts_minimal_get_minimal_tuple (TupleTableSlot *slot)
static HeapTuple	tts_minimal_copy_heap_tuple (TupleTableSlot *slot)
static MinimalTuple	tts_minimal_copy_minimal_tuple (TupleTableSlot *slot)
static void	tts_minimal_store_tuple (TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
static void	tts_buffer_heap_init (TupleTableSlot *slot)
static void	tts_buffer_heap_release (TupleTableSlot *slot)
static void	tts_buffer_heap_clear (TupleTableSlot *slot)
static void	tts_buffer_heap_getsomeattrs (TupleTableSlot *slot, int natts)
static Datum	tts_buffer_heap_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
static void	tts_buffer_heap_materialize (TupleTableSlot *slot)
static void	tts_buffer_heap_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
static HeapTuple	tts_buffer_heap_get_heap_tuple (TupleTableSlot *slot)
static HeapTuple	tts_buffer_heap_copy_heap_tuple (TupleTableSlot *slot)
static MinimalTuple	tts_buffer_heap_copy_minimal_tuple (TupleTableSlot *slot)
TupleTableSlot *	MakeTupleTableSlot (TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
TupleTableSlot *	ExecAllocTableSlot (List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
void	ExecResetTupleTable (List *tupleTable, bool shouldFree)
TupleTableSlot *	MakeSingleTupleTableSlot (TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
void	ExecDropSingleTupleTableSlot (TupleTableSlot *slot)
void	ExecSetSlotDescriptor (TupleTableSlot *slot, TupleDesc tupdesc)
TupleTableSlot *	ExecStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
TupleTableSlot *	ExecStoreBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
TupleTableSlot *	ExecStorePinnedBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
TupleTableSlot *	ExecStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
void	ExecForceStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
void	ExecForceStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
TupleTableSlot *	ExecStoreVirtualTuple (TupleTableSlot *slot)
TupleTableSlot *	ExecStoreAllNullTuple (TupleTableSlot *slot)
void	ExecStoreHeapTupleDatum (Datum data, TupleTableSlot *slot)
HeapTuple	ExecFetchSlotHeapTuple (TupleTableSlot *slot, bool materialize, bool *shouldFree)
MinimalTuple	ExecFetchSlotMinimalTuple (TupleTableSlot *slot, bool *shouldFree)
Datum	ExecFetchSlotHeapTupleDatum (TupleTableSlot *slot)
void	ExecInitResultTypeTL (PlanState *planstate)
void	ExecInitResultSlot (PlanState *planstate, const TupleTableSlotOps *tts_ops)
void	ExecInitResultTupleSlotTL (PlanState *planstate, const TupleTableSlotOps *tts_ops)
void	ExecInitScanTupleSlot (EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
TupleTableSlot *	ExecInitExtraTupleSlot (EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
TupleTableSlot *	ExecInitNullTupleSlot (EState *estate, TupleDesc tupType, const TupleTableSlotOps *tts_ops)
void	slot_getmissingattrs (TupleTableSlot *slot, int startAttNum, int lastAttNum)
void	slot_getsomeattrs_int (TupleTableSlot *slot, int attnum)
TupleDesc	ExecTypeFromTL (List *targetList)
TupleDesc	ExecCleanTypeFromTL (List *targetList)
TupleDesc	ExecTypeFromExprList (List *exprList)
void	ExecTypeSetColNames (TupleDesc typeInfo, List *namesList)
TupleDesc	BlessTupleDesc (TupleDesc tupdesc)
AttInMetadata *	TupleDescGetAttInMetadata (TupleDesc tupdesc)
HeapTuple	BuildTupleFromCStrings (AttInMetadata *attinmeta, char **values)
Datum	HeapTupleHeaderGetDatum (HeapTupleHeader tuple)
TupOutputState *	begin_tup_output_tupdesc (DestReceiver *dest, TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
void	do_tup_output (TupOutputState *tstate, Datum *values, bool *isnull)
void	do_text_output_multiline (TupOutputState *tstate, const char *txt)
void	end_tup_output (TupOutputState *tstate)

Variables
const TupleTableSlotOps	TTSOpsVirtual
const TupleTableSlotOps	TTSOpsHeapTuple
const TupleTableSlotOps	TTSOpsMinimalTuple
const TupleTableSlotOps	TTSOpsBufferHeapTuple

Function Documentation

begin_tup_output_tupdesc()

TupOutputState* begin_tup_output_tupdesc	(	DestReceiver *	dest,
		TupleDesc	tupdesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 2236 of file execTuples.c.

References CMD_SELECT, generate_unaccent_rules::dest, TupOutputState::dest, MakeSingleTupleTableSlot(), palloc(), _DestReceiver::rStartup, and TupOutputState::slot.

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExplainQuery(), IdentifySystem(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

{
    TupOutputState *tstate;

    tstate = (TupOutputState *) palloc(sizeof(TupOutputState));

    tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
    tstate->dest = dest;

    tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);

    return tstate;
}

BlessTupleDesc()

TupleDesc BlessTupleDesc

(

TupleDesc

tupdesc

)

Definition at line 2052 of file execTuples.c.

References assign_record_type_typmod(), TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by aclexplode(), brin_metapage_info(), bt_page_items(), bt_page_items_bytea(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), exec_eval_datum(), ExecEvalWholeRowVar(), ExecInitExprRec(), ExecInitFunctionScan(), get_expr_result_type(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), init_sql_fcache(), MakeOldSnapshotTimeMappingTupleDesc(), pg_buffercache_pages(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_object_address(), pg_identify_object(), pg_identify_object_as_address(), pg_last_committed_xact(), pg_lock_status(), pg_partition_tree(), pg_prepared_xact(), pg_sequence_parameters(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_wal(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs(), pg_visibility_map_summary(), pg_visibility_tupdesc(), pg_walfile_name_offset(), pg_xact_commit_timestamp_origin(), pgstathashindex(), PLy_output_setup_record(), setup_firstcall(), ssl_extension_info(), test_predtest(), ts_setup_firstcall(), tsvector_unnest(), TupleDescGetAttInMetadata(), and verify_heapam_tupdesc().

{
    if (tupdesc->tdtypeid == RECORDOID &&
        tupdesc->tdtypmod < 0)
        assign_record_type_typmod(tupdesc);

    return tupdesc;             /* just for notational convenience */
}

BuildTupleFromCStrings()

HeapTuple BuildTupleFromCStrings	(	AttInMetadata *	attinmeta,
		char **	values
	)

Definition at line 2116 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, heap_form_tuple(), i, InputFunctionCall(), TupleDescData::natts, palloc(), pfree(), AttInMetadata::tupdesc, and TupleDescAttr.

Referenced by bt_metap(), bt_page_stats(), build_pgstattuple_type(), build_tuplestore_recursively(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), libpqrcv_processTuples(), materializeResult(), pg_config(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), prs_process_call(), show_all_settings(), storeRow(), ts_process_call(), tt_process_call(), and xpath_table().

{
    TupleDesc   tupdesc = attinmeta->tupdesc;
    int         natts = tupdesc->natts;
    Datum      *dvalues;
    bool       *nulls;
    int         i;
    HeapTuple   tuple;

    dvalues = (Datum *) palloc(natts * sizeof(Datum));
    nulls = (bool *) palloc(natts * sizeof(bool));

    /*
     * Call the "in" function for each non-dropped attribute, even for nulls,
     * to support domains.
     */
    for (i = 0; i < natts; i++)
    {
        if (!TupleDescAttr(tupdesc, i)->attisdropped)
        {
            /* Non-dropped attributes */
            dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
                                           values[i],
                                           attinmeta->attioparams[i],
                                           attinmeta->atttypmods[i]);
            if (values[i] != NULL)
                nulls[i] = false;
            else
                nulls[i] = true;
        }
        else
        {
            /* Handle dropped attributes by setting to NULL */
            dvalues[i] = (Datum) 0;
            nulls[i] = true;
        }
    }

    /*
     * Form a tuple
     */
    tuple = heap_form_tuple(tupdesc, dvalues, nulls);

    /*
     * Release locally palloc'd space.  XXX would probably be good to pfree
     * values of pass-by-reference datums, as well.
     */
    pfree(dvalues);
    pfree(nulls);

    return tuple;
}

do_text_output_multiline()

void do_text_output_multiline	(	TupOutputState *	tstate,
		const char *	txt
	)

Definition at line 2284 of file execTuples.c.

References cstring_to_text_with_len(), DatumGetPointer, do_tup_output(), pfree(), PointerGetDatum, and values.

Referenced by ExplainQuery().

{
    Datum       values[1];
    bool        isnull[1] = {false};

    while (*txt)
    {
        const char *eol;
        int         len;

        eol = strchr(txt, '\n');
        if (eol)
        {
            len = eol - txt;
            eol++;
        }
        else
        {
            len = strlen(txt);
            eol = txt + len;
        }

        values[0] = PointerGetDatum(cstring_to_text_with_len(txt, len));
        do_tup_output(tstate, values, isnull);
        pfree(DatumGetPointer(values[0]));
        txt = eol;
    }
}

do_tup_output()

void do_tup_output	(	TupOutputState *	tstate,
		Datum *	values,
		bool *	isnull
	)

Definition at line 2256 of file execTuples.c.

References TupOutputState::dest, ExecClearTuple(), ExecStoreVirtualTuple(), TupleDescData::natts, _DestReceiver::receiveSlot, TupOutputState::slot, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by CreateReplicationSlot(), do_text_output_multiline(), IdentifySystem(), ShowAllGUCConfig(), and StartReplication().

{
    TupleTableSlot *slot = tstate->slot;
    int         natts = slot->tts_tupleDescriptor->natts;

    /* make sure the slot is clear */
    ExecClearTuple(slot);

    /* insert data */
    memcpy(slot->tts_values, values, natts * sizeof(Datum));
    memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));

    /* mark slot as containing a virtual tuple */
    ExecStoreVirtualTuple(slot);

    /* send the tuple to the receiver */
    (void) tstate->dest->receiveSlot(slot, tstate->dest);

    /* clean up */
    ExecClearTuple(slot);
}

end_tup_output()

void end_tup_output

(

TupOutputState *

tstate

)

Definition at line 2314 of file execTuples.c.

References TupOutputState::dest, ExecDropSingleTupleTableSlot(), pfree(), _DestReceiver::rShutdown, and TupOutputState::slot.

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExplainQuery(), IdentifySystem(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

{
    tstate->dest->rShutdown(tstate->dest);
    /* note that destroying the dest is not ours to do */
    ExecDropSingleTupleTableSlot(tstate->slot);
    pfree(tstate);
}

ExecAllocTableSlot()

TupleTableSlot* ExecAllocTableSlot	(	List **	tupleTable,
		TupleDesc	desc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1141 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

Referenced by AfterTriggerSaveEvent(), ExecInitExtraTupleSlot(), ExecInitIndexOnlyScan(), ExecInitResultSlot(), ExecInitScanTupleSlot(), and find_hash_columns().

{
    TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);

    *tupleTable = lappend(*tupleTable, slot);

    return slot;
}

ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL

(

List *

targetList

)

Definition at line 1920 of file execTuples.c.

References ExecTypeFromTLInternal().

Referenced by ExecInitJunkFilter(), PlanCacheComputeResultDesc(), and PortalStart().

{
    return ExecTypeFromTLInternal(targetList, true);
}

ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot

(

TupleTableSlot *

slot

)

Definition at line 1224 of file execTuples.c.

References Assert, ExecClearTuple(), IsA, pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by acquire_sample_rows(), afterTriggerInvokeEvents(), AlterDomainNotNull(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), compute_index_stats(), CopyMultiInsertBufferCleanup(), copyTemplateDependencies(), CopyTo(), DefineQueryRewrite(), end_tup_output(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), InsertPgAttributeTuples(), recordMultipleDependencies(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), tuplesort_free(), unique_key_recheck(), validateDomainConstraint(), and validateForeignKeyConstraint().

{
    /* This should match ExecResetTupleTable's processing of one slot */
    Assert(IsA(slot, TupleTableSlot));
    ExecClearTuple(slot);
    slot->tts_ops->release(slot);
    if (slot->tts_tupleDescriptor)
        ReleaseTupleDesc(slot->tts_tupleDescriptor);
    if (!TTS_FIXED(slot))
    {
        if (slot->tts_values)
            pfree(slot->tts_values);
        if (slot->tts_isnull)
            pfree(slot->tts_isnull);
    }
    pfree(slot);
}

ExecFetchSlotHeapTuple()

HeapTuple ExecFetchSlotHeapTuple	(	TupleTableSlot *	slot,
		bool	materialize,
		bool *	shouldFree
	)

Definition at line 1614 of file execTuples.c.

References Assert, TupleTableSlotOps::copy_heap_tuple, TupleTableSlotOps::get_heap_tuple, TupleTableSlotOps::materialize, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by AfterTriggerExecute(), apply_returning_filter(), CatalogTuplesMultiInsertWithInfo(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecFetchSlotHeapTupleDatum(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), heap_multi_insert(), heapam_relation_copy_for_cluster(), heapam_tuple_complete_speculative(), heapam_tuple_insert(), heapam_tuple_insert_speculative(), heapam_tuple_update(), systable_getnext(), systable_getnext_ordered(), systable_recheck_tuple(), and validateForeignKeyConstraint().

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(!TTS_EMPTY(slot));

    /* Materialize the tuple so that the slot "owns" it, if requested. */
    if (materialize)
        slot->tts_ops->materialize(slot);

    if (slot->tts_ops->get_heap_tuple == NULL)
    {
        if (shouldFree)
            *shouldFree = true;
        return slot->tts_ops->copy_heap_tuple(slot);
    }
    else
    {
        if (shouldFree)
            *shouldFree = false;
        return slot->tts_ops->get_heap_tuple(slot);
    }
}

ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum

(

TupleTableSlot *

slot

)

Definition at line 1693 of file execTuples.c.

References ExecFetchSlotHeapTuple(), heap_copy_tuple_as_datum(), pfree(), and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

{
    HeapTuple   tup;
    TupleDesc   tupdesc;
    bool        shouldFree;
    Datum       ret;

    /* Fetch slot's contents in regular-physical-tuple form */
    tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
    tupdesc = slot->tts_tupleDescriptor;

    /* Convert to Datum form */
    ret = heap_copy_tuple_as_datum(tup, tupdesc);

    if (shouldFree)
        pfree(tup);

    return ret;
}

ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple	(	TupleTableSlot *	slot,
		bool *	shouldFree
	)

Definition at line 1662 of file execTuples.c.

References Assert, TupleTableSlotOps::copy_minimal_tuple, TupleTableSlotOps::get_minimal_tuple, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by ExecHashJoinImpl(), ExecHashSkewTableInsert(), ExecHashTableInsert(), ExecParallelHashJoinPartitionOuter(), ExecParallelHashTableInsert(), ExecParallelHashTableInsertCurrentBatch(), hashagg_spill_tuple(), and tqueueReceiveSlot().

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(!TTS_EMPTY(slot));

    if (slot->tts_ops->get_minimal_tuple)
    {
        if (shouldFree)
            *shouldFree = false;
        return slot->tts_ops->get_minimal_tuple(slot);
    }
    else
    {
        if (shouldFree)
            *shouldFree = true;
        return slot->tts_ops->copy_minimal_tuple(slot);
    }
}

ExecForceStoreHeapTuple()

void ExecForceStoreHeapTuple	(	HeapTuple	tuple,
		TupleTableSlot *	slot,
		bool	shouldFree
	)

Definition at line 1439 of file execTuples.c.

References BufferHeapTupleTableSlot::base, ExecClearTuple(), ExecMaterializeSlot(), ExecStoreHeapTuple(), ExecStoreVirtualTuple(), heap_copytuple(), heap_deform_tuple(), MemoryContextSwitchTo(), pfree(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TTS_IS_BUFFERTUPLE, TTS_IS_HEAPTUPLE, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

Referenced by agg_retrieve_direct(), ExecARDeleteTriggers(), ExecARUpdateTriggers(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecDelete(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), IndexNextWithReorder(), IndexOnlyNext(), and store_returning_result().

{
    if (TTS_IS_HEAPTUPLE(slot))
    {
        ExecStoreHeapTuple(tuple, slot, shouldFree);
    }
    else if (TTS_IS_BUFFERTUPLE(slot))
    {
        MemoryContext oldContext;
        BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

        ExecClearTuple(slot);
        slot->tts_flags &= ~TTS_FLAG_EMPTY;
        oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
        bslot->base.tuple = heap_copytuple(tuple);
        slot->tts_flags |= TTS_FLAG_SHOULDFREE;
        MemoryContextSwitchTo(oldContext);

        if (shouldFree)
            pfree(tuple);
    }
    else
    {
        ExecClearTuple(slot);
        heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
                          slot->tts_values, slot->tts_isnull);
        ExecStoreVirtualTuple(slot);

        if (shouldFree)
        {
            ExecMaterializeSlot(slot);
            pfree(tuple);
        }
    }
}

ExecForceStoreMinimalTuple()

void ExecForceStoreMinimalTuple	(	MinimalTuple	mtup,
		TupleTableSlot *	slot,
		bool	shouldFree
	)

Definition at line 1482 of file execTuples.c.

References ExecClearTuple(), ExecMaterializeSlot(), ExecStoreVirtualTuple(), heap_deform_tuple(), MINIMAL_TUPLE_OFFSET, pfree(), HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_IS_MINIMALTUPLE, TupleTableSlot::tts_isnull, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ExecHashJoinGetSavedTuple(), ExecParallelHashJoinNewBatch(), and ExecParallelHashJoinOuterGetTuple().

{
    if (TTS_IS_MINIMALTUPLE(slot))
    {
        tts_minimal_store_tuple(slot, mtup, shouldFree);
    }
    else
    {
        HeapTupleData htup;

        ExecClearTuple(slot);

        htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
        htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
        heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
                          slot->tts_values, slot->tts_isnull);
        ExecStoreVirtualTuple(slot);

        if (shouldFree)
        {
            ExecMaterializeSlot(slot);
            pfree(mtup);
        }
    }
}

ExecInitExtraTupleSlot()

TupleTableSlot* ExecInitExtraTupleSlot	(	EState *	estate,
		TupleDesc	tupledesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1801 of file execTuples.c.

References EState::es_tupleTable, and ExecAllocTableSlot().

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update(), build_pertrans_for_aggref(), ExecGetReturningSlot(), ExecGetTriggerNewSlot(), ExecGetTriggerOldSlot(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHashJoin(), ExecInitLimit(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNullTupleSlot(), ExecInitPartitionInfo(), ExecInitSubPlan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), gather_merge_setup(), and InitPlan().

{
    return ExecAllocTableSlot(&estate->es_tupleTable, tupledesc, tts_ops);
}

ExecInitNullTupleSlot()

TupleTableSlot* ExecInitNullTupleSlot	(	EState *	estate,
		TupleDesc	tupType,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1817 of file execTuples.c.

References ExecInitExtraTupleSlot(), and ExecStoreAllNullTuple().

Referenced by ExecInitHashJoin(), ExecInitMergeJoin(), and ExecInitNestLoop().

{
    TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);

    return ExecStoreAllNullTuple(slot);
}

ExecInitResultSlot()

void ExecInitResultSlot	(	PlanState *	planstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1749 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), PlanState::ps_ResultTupleDesc, PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, and PlanState::state.

Referenced by ExecConditionalAssignProjectionInfo(), and ExecInitResultTupleSlotTL().

{
    TupleTableSlot *slot;

    slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
                              planstate->ps_ResultTupleDesc, tts_ops);
    planstate->ps_ResultTupleSlot = slot;

    planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
    planstate->resultops = tts_ops;
    planstate->resultopsset = true;
}

ExecInitResultTupleSlotTL()

void ExecInitResultTupleSlotTL	(	PlanState *	planstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1769 of file execTuples.c.

References ExecInitResultSlot(), and ExecInitResultTypeTL().

Referenced by ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitResult(), ExecInitSetOp(), ExecInitSort(), ExecInitUnique(), and ExecInitWindowAgg().

{
    ExecInitResultTypeTL(planstate);
    ExecInitResultSlot(planstate, tts_ops);
}

ExecInitResultTypeTL()

void ExecInitResultTypeTL

(

PlanState *

planstate

)

Definition at line 1725 of file execTuples.c.

References ExecTypeFromTL(), PlanState::plan, PlanState::ps_ResultTupleDesc, and Plan::targetlist.

Referenced by ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitRecursiveUnion(), ExecInitResultTupleSlotTL(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

{
    TupleDesc   tupDesc = ExecTypeFromTL(planstate->plan->targetlist);

    planstate->ps_ResultTupleDesc = tupDesc;
}

ExecInitScanTupleSlot()

void ExecInitScanTupleSlot	(	EState *	estate,
		ScanState *	scanstate,
		TupleDesc	tupledesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1781 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), ScanState::ps, PlanState::scandesc, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, and ScanState::ss_ScanTupleSlot.

Referenced by ExecCreateScanSlotFromOuterPlan(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitNamedTuplestoreScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

{
    scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable,
                                                     tupledesc, tts_ops);
    scanstate->ps.scandesc = tupledesc;
    scanstate->ps.scanopsfixed = tupledesc != NULL;
    scanstate->ps.scanops = tts_ops;
    scanstate->ps.scanopsset = true;
}

ExecResetTupleTable()

void ExecResetTupleTable	(	List *	tupleTable,
		bool	shouldFree
	)

Definition at line 1161 of file execTuples.c.

References ExecClearTuple(), lfirst_node, list_free(), pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by afterTriggerInvokeEvents(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CopyFrom(), EvalPlanQualEnd(), and ExecEndPlan().

{
    ListCell   *lc;

    foreach(lc, tupleTable)
    {
        TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);

        /* Always release resources and reset the slot to empty */
        ExecClearTuple(slot);
        slot->tts_ops->release(slot);
        if (slot->tts_tupleDescriptor)
        {
            ReleaseTupleDesc(slot->tts_tupleDescriptor);
            slot->tts_tupleDescriptor = NULL;
        }

        /* If shouldFree, release memory occupied by the slot itself */
        if (shouldFree)
        {
            if (!TTS_FIXED(slot))
            {
                if (slot->tts_values)
                    pfree(slot->tts_values);
                if (slot->tts_isnull)
                    pfree(slot->tts_isnull);
            }
            pfree(slot);
        }
    }

    /* If shouldFree, release the list structure */
    if (shouldFree)
        list_free(tupleTable);
}

ExecSetSlotDescriptor()

void ExecSetSlotDescriptor	(	TupleTableSlot *	slot,
		TupleDesc	tupdesc
	)

Definition at line 1259 of file execTuples.c.

References Assert, ExecClearTuple(), MemoryContextAlloc(), TupleDescData::natts, pfree(), PinTupleDesc, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ExecAssignScanType(), ExecInitJunkFilter(), and ExecInitJunkFilterConversion().

{
    Assert(!TTS_FIXED(slot));

    /* For safety, make sure slot is empty before changing it */
    ExecClearTuple(slot);

    /*
     * Release any old descriptor.  Also release old Datum/isnull arrays if
     * present (we don't bother to check if they could be re-used).
     */
    if (slot->tts_tupleDescriptor)
        ReleaseTupleDesc(slot->tts_tupleDescriptor);

    if (slot->tts_values)
        pfree(slot->tts_values);
    if (slot->tts_isnull)
        pfree(slot->tts_isnull);

    /*
     * Install the new descriptor; if it's refcounted, bump its refcount.
     */
    slot->tts_tupleDescriptor = tupdesc;
    PinTupleDesc(tupdesc);

    /*
     * Allocate Datum/isnull arrays of the appropriate size.  These must have
     * the same lifetime as the slot, so allocate in the slot's own context.
     */
    slot->tts_values = (Datum *)
        MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
    slot->tts_isnull = (bool *)
        MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
}

ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple

(

TupleTableSlot *

slot

)

Definition at line 1546 of file execTuples.c.

References Assert, ExecClearTuple(), ExecStoreVirtualTuple(), MemSet, TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ATRewriteTable(), BitmapHeapNext(), ExecDelete(), ExecInitNullTupleSlot(), get_returning_data(), and prepare_projection_slot().

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);

    /* Clear any old contents */
    ExecClearTuple(slot);

    /*
     * Fill all the columns of the virtual tuple with nulls
     */
    MemSet(slot->tts_values, 0,
           slot->tts_tupleDescriptor->natts * sizeof(Datum));
    memset(slot->tts_isnull, true,
           slot->tts_tupleDescriptor->natts * sizeof(bool));

    return ExecStoreVirtualTuple(slot);
}

ExecStoreBufferHeapTuple()

TupleTableSlot* ExecStoreBufferHeapTuple	(	HeapTuple	tuple,
		TupleTableSlot *	slot,
		Buffer	buffer
	)

Definition at line 1362 of file execTuples.c.

References Assert, BufferIsValid, elog, ERROR, HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heap_getnextslot(), heapam_index_build_range_scan(), heapam_index_fetch_tuple(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_tuple(), and heapam_scan_sample_next_tuple().

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(BufferIsValid(buffer));

    if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
        elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
    tts_buffer_heap_store_tuple(slot, tuple, buffer, false);

    slot->tts_tableOid = tuple->t_tableOid;

    return slot;
}

ExecStoreHeapTuple()

TupleTableSlot* ExecStoreHeapTuple	(	HeapTuple	tuple,
		TupleTableSlot *	slot,
		bool	shouldFree
	)

Definition at line 1322 of file execTuples.c.

References Assert, elog, ERROR, HeapTupleData::t_tableOid, tts_heap_store_tuple(), TTS_IS_HEAPTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by CatalogIndexInsert(), comparetup_cluster(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), get_returning_data(), heapam_index_validate_scan(), postgresIterateForeignScan(), setop_retrieve_direct(), and tts_heap_copyslot().

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);

    if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
        elog(ERROR, "trying to store a heap tuple into wrong type of slot");
    tts_heap_store_tuple(slot, tuple, shouldFree);

    slot->tts_tableOid = tuple->t_tableOid;

    return slot;
}

ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum	(	Datum	data,
		TupleTableSlot *	slot
	)

Definition at line 1576 of file execTuples.c.

References DatumGetHeapTupleHeader, ExecClearTuple(), ExecStoreVirtualTuple(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by EvalPlanQualFetchRowMark().

{
    HeapTupleData tuple = {0};
    HeapTupleHeader td;

    td = DatumGetHeapTupleHeader(data);

    tuple.t_len = HeapTupleHeaderGetDatumLength(td);
    tuple.t_self = td->t_ctid;
    tuple.t_data = td;

    ExecClearTuple(slot);

    heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
                      slot->tts_values, slot->tts_isnull);
    ExecStoreVirtualTuple(slot);
}

ExecStoreMinimalTuple()

TupleTableSlot* ExecStoreMinimalTuple	(	MinimalTuple	mtup,
		TupleTableSlot *	slot,
		bool	shouldFree
	)

Definition at line 1416 of file execTuples.c.

References Assert, elog, ERROR, TTS_IS_MINIMALTUPLE, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by agg_refill_hash_table(), agg_retrieve_hash_table_in_memory(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), gather_getnext(), gather_merge_readnext(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash_internal(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

{
    /*
     * sanity checks
     */
    Assert(mtup != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);

    if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
        elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
    tts_minimal_store_tuple(slot, mtup, shouldFree);

    return slot;
}

ExecStorePinnedBufferHeapTuple()

TupleTableSlot* ExecStorePinnedBufferHeapTuple	(	HeapTuple	tuple,
		TupleTableSlot *	slot,
		Buffer	buffer
	)

Definition at line 1388 of file execTuples.c.

References Assert, BufferIsValid, elog, ERROR, HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heapam_fetch_row_version(), and heapam_tuple_lock().

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(BufferIsValid(buffer));

    if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
        elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
    tts_buffer_heap_store_tuple(slot, tuple, buffer, true);

    slot->tts_tableOid = tuple->t_tableOid;

    return slot;
}

ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple

(

TupleTableSlot *

slot

)

Definition at line 1522 of file execTuples.c.

References Assert, TupleDescData::natts, TTS_EMPTY, TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_hash_table_in_memory(), apply_returning_filter(), ATRewriteTable(), CopyFrom(), copyTemplateDependencies(), do_tup_output(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hashagg_spill_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), InsertPgAttributeTuples(), ordered_set_transition_multi(), prepare_hash_slot(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), and ValuesNext().

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(TTS_EMPTY(slot));

    slot->tts_flags &= ~TTS_FLAG_EMPTY;
    slot->tts_nvalid = slot->tts_tupleDescriptor->natts;

    return slot;
}

ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList

(

List *

exprList

)

Definition at line 1967 of file execTuples.c.

References CreateTemplateTupleDesc(), exprCollation(), exprType(), exprTypmod(), lfirst, list_length(), TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecInitExprRec(), and ExecInitValuesScan().

{
    TupleDesc   typeInfo;
    ListCell   *lc;
    int         cur_resno = 1;

    typeInfo = CreateTemplateTupleDesc(list_length(exprList));

    foreach(lc, exprList)
    {
        Node       *e = lfirst(lc);

        TupleDescInitEntry(typeInfo,
                           cur_resno,
                           NULL,
                           exprType(e),
                           exprTypmod(e),
                           0);
        TupleDescInitEntryCollation(typeInfo,
                                    cur_resno,
                                    exprCollation(e));
        cur_resno++;
    }

    return typeInfo;
}

ExecTypeFromTL()

TupleDesc ExecTypeFromTL

(

List *

targetList

)

Definition at line 1908 of file execTuples.c.

References ExecTypeFromTLInternal().

Referenced by build_pertrans_for_aggref(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitModifyTable(), ExecInitPartitionInfo(), ExecInitResultTypeTL(), ExecInitSubPlan(), find_hash_columns(), and ordered_set_startup().

{
    return ExecTypeFromTLInternal(targetList, false);
}

ExecTypeFromTLInternal()

static TupleDesc ExecTypeFromTLInternal ( List *  targetList, bool  skipjunk  )

static

Definition at line 1926 of file execTuples.c.

References CreateTemplateTupleDesc(), ExecCleanTargetListLength(), ExecTargetListLength(), TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), lfirst, TargetEntry::resjunk, TargetEntry::resname, TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecCleanTypeFromTL(), and ExecTypeFromTL().

{
    TupleDesc   typeInfo;
    ListCell   *l;
    int         len;
    int         cur_resno = 1;

    if (skipjunk)
        len = ExecCleanTargetListLength(targetList);
    else
        len = ExecTargetListLength(targetList);
    typeInfo = CreateTemplateTupleDesc(len);

    foreach(l, targetList)
    {
        TargetEntry *tle = lfirst(l);

        if (skipjunk && tle->resjunk)
            continue;
        TupleDescInitEntry(typeInfo,
                           cur_resno,
                           tle->resname,
                           exprType((Node *) tle->expr),
                           exprTypmod((Node *) tle->expr),
                           0);
        TupleDescInitEntryCollation(typeInfo,
                                    cur_resno,
                                    exprCollation((Node *) tle->expr));
        cur_resno++;
    }

    return typeInfo;
}

ExecTypeSetColNames()

void ExecTypeSetColNames	(	TupleDesc	typeInfo,
		List *	namesList
	)

Definition at line 2006 of file execTuples.c.

References lfirst, NameStr, namestrcpy(), TupleDescData::natts, strVal, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by ExecEvalWholeRowVar(), and ExecInitExprRec().

{
    bool        modified = false;
    int         colno = 0;
    ListCell   *lc;

    foreach(lc, namesList)
    {
        char       *cname = strVal(lfirst(lc));
        Form_pg_attribute attr;

        /* Guard against too-long names list */
        if (colno >= typeInfo->natts)
            break;
        attr = TupleDescAttr(typeInfo, colno);
        colno++;

        /* Ignore empty aliases (these must be for dropped columns) */
        if (cname[0] == '\0')
            continue;

        /* Change tupdesc only if alias is actually different */
        if (strcmp(cname, NameStr(attr->attname)) != 0)
        {
            namestrcpy(&(attr->attname), cname);
            modified = true;
        }
    }

    /* If we modified the tupdesc, it's now a new record type */
    if (modified)
    {
        typeInfo->tdtypeid = RECORDOID;
        typeInfo->tdtypmod = -1;
    }
}

HeapTupleHeaderGetDatum()

Datum HeapTupleHeaderGetDatum

(

HeapTupleHeader

tuple

)

Definition at line 2205 of file execTuples.c.

References HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, HeapTupleHeaderHasExternal, lookup_rowtype_tupdesc(), PointerGetDatum, ReleaseTupleDesc, and toast_flatten_tuple_to_datum().

Referenced by populate_composite(), and populate_recordset_record().

{
    Datum       result;
    TupleDesc   tupDesc;

    /* No work if there are no external TOAST pointers in the tuple */
    if (!HeapTupleHeaderHasExternal(tuple))
        return PointerGetDatum(tuple);

    /* Use the type data saved by heap_form_tuple to look up the rowtype */
    tupDesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(tuple),
                                     HeapTupleHeaderGetTypMod(tuple));

    /* And do the flattening */
    result = toast_flatten_tuple_to_datum(tuple,
                                          HeapTupleHeaderGetDatumLength(tuple),
                                          tupDesc);

    ReleaseTupleDesc(tupDesc);

    return result;
}

MakeSingleTupleTableSlot()

TupleTableSlot* MakeSingleTupleTableSlot	(	TupleDesc	tupdesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1208 of file execTuples.c.

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTableExt(), CatalogIndexInsert(), compute_index_stats(), copyTemplateDependencies(), ExecInitIncrementalSort(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitPartitionDispatchInfo(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_sql_fcache(), InsertPgAttributeTuples(), ordered_set_startup(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), table_slot_create(), tstoreStartupReceiver(), and tuplesort_begin_cluster().

{
    TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops);

    return slot;
}

MakeTupleTableSlot()

TupleTableSlot* MakeTupleTableSlot	(	TupleDesc	tupleDesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1082 of file execTuples.c.

References TupleTableSlotOps::base_slot_size, CurrentMemoryContext, TupleTableSlotOps::init, MAXALIGN, TupleDescData::natts, palloc0(), PinTupleDesc, T_TupleTableSlot, TTS_FLAG_EMPTY, TTS_FLAG_FIXED, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and TupleTableSlot::type.

Referenced by ExecAllocTableSlot(), ExecConstraints(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), and MakeSingleTupleTableSlot().

{
    Size        basesz,
                allocsz;
    TupleTableSlot *slot;

    basesz = tts_ops->base_slot_size;

    /*
     * When a fixed descriptor is specified, we can reduce overhead by
     * allocating the entire slot in one go.
     */
    if (tupleDesc)
        allocsz = MAXALIGN(basesz) +
            MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
            MAXALIGN(tupleDesc->natts * sizeof(bool));
    else
        allocsz = basesz;

    slot = palloc0(allocsz);
    /* const for optimization purposes, OK to modify at allocation time */
    *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
    slot->type = T_TupleTableSlot;
    slot->tts_flags |= TTS_FLAG_EMPTY;
    if (tupleDesc != NULL)
        slot->tts_flags |= TTS_FLAG_FIXED;
    slot->tts_tupleDescriptor = tupleDesc;
    slot->tts_mcxt = CurrentMemoryContext;
    slot->tts_nvalid = 0;

    if (tupleDesc != NULL)
    {
        slot->tts_values = (Datum *)
            (((char *) slot)
             + MAXALIGN(basesz));
        slot->tts_isnull = (bool *)
            (((char *) slot)
             + MAXALIGN(basesz)
             + MAXALIGN(tupleDesc->natts * sizeof(Datum)));

        PinTupleDesc(tupleDesc);
    }

    /*
     * And allow slot type specific initialization.
     */
    slot->tts_ops->init(slot);

    return slot;
}

slot_deform_heap_tuple()

static pg_attribute_always_inline void slot_deform_heap_tuple ( TupleTableSlot *  slot, HeapTuple  tuple, uint32 *  offp, int  natts  )

static

Definition at line 895 of file execTuples.c.

References att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull, attnum, TupleTableSlotOps::base_slot_size, fetchatt, HeapTupleHasNulls, HeapTupleHeaderGetNatts, init, Min, HeapTupleHeaderData::t_bits, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, tts_buffer_heap_clear(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_copy_minimal_tuple(), tts_buffer_heap_copyslot(), tts_buffer_heap_get_heap_tuple(), tts_buffer_heap_getsomeattrs(), tts_buffer_heap_getsysattr(), tts_buffer_heap_init(), tts_buffer_heap_materialize(), tts_buffer_heap_release(), TTS_FLAG_SLOW, tts_heap_clear(), tts_heap_copy_heap_tuple(), tts_heap_copy_minimal_tuple(), tts_heap_copyslot(), tts_heap_get_heap_tuple(), tts_heap_getsomeattrs(), tts_heap_getsysattr(), tts_heap_init(), tts_heap_materialize(), tts_heap_release(), TupleTableSlot::tts_isnull, tts_minimal_clear(), tts_minimal_copy_heap_tuple(), tts_minimal_copy_minimal_tuple(), tts_minimal_copyslot(), tts_minimal_get_minimal_tuple(), tts_minimal_getsomeattrs(), tts_minimal_getsysattr(), tts_minimal_init(), tts_minimal_materialize(), tts_minimal_release(), TupleTableSlot::tts_nvalid, TTS_SLOW, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, tts_virtual_clear(), tts_virtual_copy_heap_tuple(), tts_virtual_copy_minimal_tuple(), tts_virtual_copyslot(), tts_virtual_getsomeattrs(), tts_virtual_getsysattr(), tts_virtual_init(), tts_virtual_materialize(), tts_virtual_release(), TupleDescAttr, and values.

Referenced by tts_buffer_heap_getsomeattrs(), tts_heap_getsomeattrs(), and tts_minimal_getsomeattrs().

{
    TupleDesc   tupleDesc = slot->tts_tupleDescriptor;
    Datum      *values = slot->tts_values;
    bool       *isnull = slot->tts_isnull;
    HeapTupleHeader tup = tuple->t_data;
    bool        hasnulls = HeapTupleHasNulls(tuple);
    int         attnum;
    char       *tp;             /* ptr to tuple data */
    uint32      off;            /* offset in tuple data */
    bits8      *bp = tup->t_bits;   /* ptr to null bitmap in tuple */
    bool        slow;           /* can we use/set attcacheoff? */

    /* We can only fetch as many attributes as the tuple has. */
    natts = Min(HeapTupleHeaderGetNatts(tuple->t_data), natts);

    /*
     * Check whether the first call for this tuple, and initialize or restore
     * loop state.
     */
    attnum = slot->tts_nvalid;
    if (attnum == 0)
    {
        /* Start from the first attribute */
        off = 0;
        slow = false;
    }
    else
    {
        /* Restore state from previous execution */
        off = *offp;
        slow = TTS_SLOW(slot);
    }

    tp = (char *) tup + tup->t_hoff;

    for (; attnum < natts; attnum++)
    {
        Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);

        if (hasnulls && att_isnull(attnum, bp))
        {
            values[attnum] = (Datum) 0;
            isnull[attnum] = true;
            slow = true;        /* can't use attcacheoff anymore */
            continue;
        }

        isnull[attnum] = false;

        if (!slow && thisatt->attcacheoff >= 0)
            off = thisatt->attcacheoff;
        else if (thisatt->attlen == -1)
        {
            /*
             * We can only cache the offset for a varlena attribute if the
             * offset is already suitably aligned, so that there would be no
             * pad bytes in any case: then the offset will be valid for either
             * an aligned or unaligned value.
             */
            if (!slow &&
                off == att_align_nominal(off, thisatt->attalign))
                thisatt->attcacheoff = off;
            else
            {
                off = att_align_pointer(off, thisatt->attalign, -1,
                                        tp + off);
                slow = true;
            }
        }
        else
        {
            /* not varlena, so safe to use att_align_nominal */
            off = att_align_nominal(off, thisatt->attalign);

            if (!slow)
                thisatt->attcacheoff = off;
        }

        values[attnum] = fetchatt(thisatt, tp + off);

        off = att_addlength_pointer(off, thisatt->attlen, tp + off);

        if (thisatt->attlen <= 0)
            slow = true;        /* can't use attcacheoff anymore */
    }

    /*
     * Save state for next execution
     */
    slot->tts_nvalid = attnum;
    *offp = off;
    if (slow)
        slot->tts_flags |= TTS_FLAG_SLOW;
    else
        slot->tts_flags &= ~TTS_FLAG_SLOW;
}

slot_getmissingattrs()

void slot_getmissingattrs	(	TupleTableSlot *	slot,
		int	startAttNum,
		int	lastAttNum
	)

Definition at line 1838 of file execTuples.c.

References AttrMissing::am_present, AttrMissing::am_value, TupleDescData::constr, TupleConstr::missing, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_getsomeattrs_int().

{
    AttrMissing *attrmiss = NULL;

    if (slot->tts_tupleDescriptor->constr)
        attrmiss = slot->tts_tupleDescriptor->constr->missing;

    if (!attrmiss)
    {
        /* no missing values array at all, so just fill everything in as NULL */
        memset(slot->tts_values + startAttNum, 0,
               (lastAttNum - startAttNum) * sizeof(Datum));
        memset(slot->tts_isnull + startAttNum, 1,
               (lastAttNum - startAttNum) * sizeof(bool));
    }
    else
    {
        int         missattnum;

        /* if there is a missing values array we must process them one by one */
        for (missattnum = startAttNum;
             missattnum < lastAttNum;
             missattnum++)
        {
            slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
            slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
        }
    }
}

slot_getsomeattrs_int()

void slot_getsomeattrs_int	(	TupleTableSlot *	slot,
		int	attnum
	)

Definition at line 1872 of file execTuples.c.

References Assert, attnum, elog, ERROR, TupleTableSlotOps::getsomeattrs, TupleDescData::natts, slot_getmissingattrs(), TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by slot_getsomeattrs().

{
    /* Check for caller errors */
    Assert(slot->tts_nvalid < attnum);  /* checked in slot_getsomeattrs */
    Assert(attnum > 0);

    if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
        elog(ERROR, "invalid attribute number %d", attnum);

    /* Fetch as many attributes as possible from the underlying tuple. */
    slot->tts_ops->getsomeattrs(slot, attnum);

    /*
     * If the underlying tuple doesn't have enough attributes, tuple
     * descriptor must have the missing attributes.
     */
    if (unlikely(slot->tts_nvalid < attnum))
    {
        slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
        slot->tts_nvalid = attnum;
    }
}

tts_buffer_heap_clear()

static void tts_buffer_heap_clear ( TupleTableSlot *  slot )

static

Definition at line 638 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_freetuple(), InvalidBuffer, ItemPointerSetInvalid, HeapTupleTableSlot::off, ReleaseBuffer(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    /*
     * Free the memory for heap tuple if allowed. A tuple coming from buffer
     * can never be freed. But we may have materialized a tuple from buffer.
     * Such a tuple can be freed.
     */
    if (TTS_SHOULDFREE(slot))
    {
        /* We should have unpinned the buffer while materializing the tuple. */
        Assert(!BufferIsValid(bslot->buffer));

        heap_freetuple(bslot->base.tuple);
        slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
    }

    if (BufferIsValid(bslot->buffer))
        ReleaseBuffer(bslot->buffer);

    slot->tts_nvalid = 0;
    slot->tts_flags |= TTS_FLAG_EMPTY;
    ItemPointerSetInvalid(&slot->tts_tid);
    bslot->base.tuple = NULL;
    bslot->base.off = 0;
    bslot->buffer = InvalidBuffer;
}

tts_buffer_heap_copy_heap_tuple()

static HeapTuple tts_buffer_heap_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 803 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, heap_copytuple(), tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    if (!bslot->base.tuple)
        tts_buffer_heap_materialize(slot);

    return heap_copytuple(bslot->base.tuple);
}

tts_buffer_heap_copy_minimal_tuple()

static MinimalTuple tts_buffer_heap_copy_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 816 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, minimal_tuple_from_heap_tuple(), tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    if (!bslot->base.tuple)
        tts_buffer_heap_materialize(slot);

    return minimal_tuple_from_heap_tuple(bslot->base.tuple);
}

tts_buffer_heap_copyslot()

static void tts_buffer_heap_copyslot ( TupleTableSlot *  dstslot, TupleTableSlot *  srcslot  )

static

Definition at line 748 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, ExecClearTuple(), ExecCopySlotHeapTuple(), MemoryContextSwitchTo(), tts_buffer_heap_store_tuple(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_ops, TTS_SHOULDFREE, HeapTupleTableSlot::tupdata, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bsrcslot = (BufferHeapTupleTableSlot *) srcslot;
    BufferHeapTupleTableSlot *bdstslot = (BufferHeapTupleTableSlot *) dstslot;

    /*
     * If the source slot is of a different kind, or is a buffer slot that has
     * been materialized / is virtual, make a new copy of the tuple. Otherwise
     * make a new reference to the in-buffer tuple.
     */
    if (dstslot->tts_ops != srcslot->tts_ops ||
        TTS_SHOULDFREE(srcslot) ||
        !bsrcslot->base.tuple)
    {
        MemoryContext oldContext;

        ExecClearTuple(dstslot);
        dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
        oldContext = MemoryContextSwitchTo(dstslot->tts_mcxt);
        bdstslot->base.tuple = ExecCopySlotHeapTuple(srcslot);
        dstslot->tts_flags |= TTS_FLAG_SHOULDFREE;
        MemoryContextSwitchTo(oldContext);
    }
    else
    {
        Assert(BufferIsValid(bsrcslot->buffer));

        tts_buffer_heap_store_tuple(dstslot, bsrcslot->base.tuple,
                                    bsrcslot->buffer, false);

        /*
         * The HeapTupleData portion of the source tuple might be shorter
         * lived than the destination slot. Therefore copy the HeapTuple into
         * our slot's tupdata, which is guaranteed to live long enough (but
         * will still point into the buffer).
         */
        memcpy(&bdstslot->base.tupdata, bdstslot->base.tuple, sizeof(HeapTupleData));
        bdstslot->base.tuple = &bdstslot->base.tupdata;
    }
}

tts_buffer_heap_get_heap_tuple()

static HeapTuple tts_buffer_heap_get_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 790 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    if (!bslot->base.tuple)
        tts_buffer_heap_materialize(slot);

    return bslot->base.tuple;
}

tts_buffer_heap_getsomeattrs()

static void tts_buffer_heap_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 668 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, HeapTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    slot_deform_heap_tuple(slot, bslot->base.tuple, &bslot->base.off, natts);
}

tts_buffer_heap_getsysattr()

static Datum tts_buffer_heap_getsysattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

static

Definition at line 678 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, heap_getsysattr(), TTS_EMPTY, TupleTableSlot::tts_tupleDescriptor, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    return heap_getsysattr(bslot->base.tuple, attnum,
                           slot->tts_tupleDescriptor, isnull);
}

tts_buffer_heap_init()

static void tts_buffer_heap_init ( TupleTableSlot *  slot )

static

Definition at line 628 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_buffer_heap_materialize()

static void tts_buffer_heap_materialize ( TupleTableSlot *  slot )

static

Definition at line 689 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_copytuple(), heap_form_tuple(), InvalidBuffer, likely, MemoryContextSwitchTo(), HeapTupleTableSlot::off, ReleaseBuffer(), TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_copy_minimal_tuple(), and tts_buffer_heap_get_heap_tuple().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    MemoryContext oldContext;

    Assert(!TTS_EMPTY(slot));

    /* If slot has its tuple already materialized, nothing to do. */
    if (TTS_SHOULDFREE(slot))
        return;

    oldContext = MemoryContextSwitchTo(slot->tts_mcxt);

    /*
     * Have to deform from scratch, otherwise tts_values[] entries could point
     * into the non-materialized tuple (which might be gone when accessed).
     */
    bslot->base.off = 0;
    slot->tts_nvalid = 0;

    if (!bslot->base.tuple)
    {
        /*
         * Normally BufferHeapTupleTableSlot should have a tuple + buffer
         * associated with it, unless it's materialized (which would've
         * returned above). But when it's useful to allow storing virtual
         * tuples in a buffer slot, which then also needs to be
         * materializable.
         */
        bslot->base.tuple = heap_form_tuple(slot->tts_tupleDescriptor,
                                            slot->tts_values,
                                            slot->tts_isnull);
    }
    else
    {
        bslot->base.tuple = heap_copytuple(bslot->base.tuple);

        /*
         * A heap tuple stored in a BufferHeapTupleTableSlot should have a
         * buffer associated with it, unless it's materialized or virtual.
         */
        if (likely(BufferIsValid(bslot->buffer)))
            ReleaseBuffer(bslot->buffer);
        bslot->buffer = InvalidBuffer;
    }

    /*
     * We don't set TTS_FLAG_SHOULDFREE until after releasing the buffer, if
     * any.  This avoids having a transient state that would fall foul of our
     * assertions that a slot with TTS_FLAG_SHOULDFREE doesn't own a buffer.
     * In the unlikely event that ReleaseBuffer() above errors out, we'd
     * effectively leak the copied tuple, but that seems fairly harmless.
     */
    slot->tts_flags |= TTS_FLAG_SHOULDFREE;

    MemoryContextSwitchTo(oldContext);
}

tts_buffer_heap_release()

static void tts_buffer_heap_release ( TupleTableSlot *  slot )

static

Definition at line 633 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_buffer_heap_store_tuple()

static void tts_buffer_heap_store_tuple ( TupleTableSlot *  slot, HeapTuple  tuple, Buffer  buffer, bool  transfer_pin  )

inlinestatic

Definition at line 829 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_freetuple(), IncrBufferRefCount(), HeapTupleTableSlot::off, pg_attribute_always_inline, ReleaseBuffer(), HeapTupleData::t_self, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by ExecStoreBufferHeapTuple(), ExecStorePinnedBufferHeapTuple(), and tts_buffer_heap_copyslot().

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;

    if (TTS_SHOULDFREE(slot))
    {
        /* materialized slot shouldn't have a buffer to release */
        Assert(!BufferIsValid(bslot->buffer));

        heap_freetuple(bslot->base.tuple);
        slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
    }

    slot->tts_flags &= ~TTS_FLAG_EMPTY;
    slot->tts_nvalid = 0;
    bslot->base.tuple = tuple;
    bslot->base.off = 0;
    slot->tts_tid = tuple->t_self;

    /*
     * If tuple is on a disk page, keep the page pinned as long as we hold a
     * pointer into it.  We assume the caller already has such a pin.  If
     * transfer_pin is true, we'll transfer that pin to this slot, if not
     * we'll pin it again ourselves.
     *
     * This is coded to optimize the case where the slot previously held a
     * tuple on the same disk page: in that case releasing and re-acquiring
     * the pin is a waste of cycles.  This is a common situation during
     * seqscans, so it's worth troubling over.
     */
    if (bslot->buffer != buffer)
    {
        if (BufferIsValid(bslot->buffer))
            ReleaseBuffer(bslot->buffer);

        bslot->buffer = buffer;

        if (!transfer_pin && BufferIsValid(buffer))
            IncrBufferRefCount(buffer);
    }
    else if (transfer_pin && BufferIsValid(buffer))
    {
        /*
         * In transfer_pin mode the caller won't know about the same-page
         * optimization, so we gotta release its pin.
         */
        ReleaseBuffer(buffer);
    }
}

tts_heap_clear()

static void tts_heap_clear ( TupleTableSlot *  slot )

static

Definition at line 303 of file execTuples.c.

References heap_freetuple(), ItemPointerSetInvalid, HeapTupleTableSlot::off, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), and tts_heap_store_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    /* Free the memory for the heap tuple if it's allowed. */
    if (TTS_SHOULDFREE(slot))
    {
        heap_freetuple(hslot->tuple);
        slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
    }

    slot->tts_nvalid = 0;
    slot->tts_flags |= TTS_FLAG_EMPTY;
    ItemPointerSetInvalid(&slot->tts_tid);
    hslot->off = 0;
    hslot->tuple = NULL;
}

tts_heap_copy_heap_tuple()

static HeapTuple tts_heap_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 408 of file execTuples.c.

References Assert, heap_copytuple(), TTS_EMPTY, tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));
    if (!hslot->tuple)
        tts_heap_materialize(slot);

    return heap_copytuple(hslot->tuple);
}

tts_heap_copy_minimal_tuple()

static MinimalTuple tts_heap_copy_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 420 of file execTuples.c.

References minimal_tuple_from_heap_tuple(), tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    if (!hslot->tuple)
        tts_heap_materialize(slot);

    return minimal_tuple_from_heap_tuple(hslot->tuple);
}

tts_heap_copyslot()

static void tts_heap_copyslot ( TupleTableSlot *  dstslot, TupleTableSlot *  srcslot  )

static

Definition at line 383 of file execTuples.c.

References ExecCopySlotHeapTuple(), ExecStoreHeapTuple(), MemoryContextSwitchTo(), and TupleTableSlot::tts_mcxt.

Referenced by slot_deform_heap_tuple().

{
    HeapTuple   tuple;
    MemoryContext oldcontext;

    oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
    tuple = ExecCopySlotHeapTuple(srcslot);
    MemoryContextSwitchTo(oldcontext);

    ExecStoreHeapTuple(tuple, dstslot, true);
}

tts_heap_get_heap_tuple()

static HeapTuple tts_heap_get_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 396 of file execTuples.c.

References Assert, TTS_EMPTY, tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));
    if (!hslot->tuple)
        tts_heap_materialize(slot);

    return hslot->tuple;
}

tts_heap_getsomeattrs()

static void tts_heap_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 322 of file execTuples.c.

References Assert, HeapTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    slot_deform_heap_tuple(slot, hslot->tuple, &hslot->off, natts);
}

tts_heap_getsysattr()

static Datum tts_heap_getsysattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

static

Definition at line 332 of file execTuples.c.

References Assert, heap_getsysattr(), TTS_EMPTY, TupleTableSlot::tts_tupleDescriptor, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    return heap_getsysattr(hslot->tuple, attnum,
                           slot->tts_tupleDescriptor, isnull);
}

tts_heap_init()

static void tts_heap_init ( TupleTableSlot *  slot )

static

Definition at line 293 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_heap_materialize()

static void tts_heap_materialize ( TupleTableSlot *  slot )

static

Definition at line 343 of file execTuples.c.

References Assert, heap_copytuple(), heap_form_tuple(), MemoryContextSwitchTo(), HeapTupleTableSlot::off, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_heap_copy_heap_tuple(), tts_heap_copy_minimal_tuple(), and tts_heap_get_heap_tuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
    MemoryContext oldContext;

    Assert(!TTS_EMPTY(slot));

    /* If slot has its tuple already materialized, nothing to do. */
    if (TTS_SHOULDFREE(slot))
        return;

    oldContext = MemoryContextSwitchTo(slot->tts_mcxt);

    /*
     * Have to deform from scratch, otherwise tts_values[] entries could point
     * into the non-materialized tuple (which might be gone when accessed).
     */
    slot->tts_nvalid = 0;
    hslot->off = 0;

    if (!hslot->tuple)
        hslot->tuple = heap_form_tuple(slot->tts_tupleDescriptor,
                                       slot->tts_values,
                                       slot->tts_isnull);
    else
    {
        /*
         * The tuple contained in this slot is not allocated in the memory
         * context of the given slot (else it would have TTS_SHOULDFREE set).
         * Copy the tuple into the given slot's memory context.
         */
        hslot->tuple = heap_copytuple(hslot->tuple);
    }

    slot->tts_flags |= TTS_FLAG_SHOULDFREE;

    MemoryContextSwitchTo(oldContext);
}

tts_heap_release()

static void tts_heap_release ( TupleTableSlot *  slot )

static

Definition at line 298 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_heap_store_tuple()

static void tts_heap_store_tuple ( TupleTableSlot *  slot, HeapTuple  tuple, bool  shouldFree  )

static

Definition at line 431 of file execTuples.c.

References HeapTupleTableSlot::off, HeapTupleData::t_self, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, tts_heap_clear(), TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by ExecStoreHeapTuple().

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;

    tts_heap_clear(slot);

    slot->tts_nvalid = 0;
    hslot->tuple = tuple;
    hslot->off = 0;
    slot->tts_flags &= ~(TTS_FLAG_EMPTY | TTS_FLAG_SHOULDFREE);
    slot->tts_tid = tuple->t_self;

    if (shouldFree)
        slot->tts_flags |= TTS_FLAG_SHOULDFREE;
}

tts_minimal_clear()

static void tts_minimal_clear ( TupleTableSlot *  slot )

static

Definition at line 470 of file execTuples.c.

References heap_free_minimal_tuple(), ItemPointerSetInvalid, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

Referenced by slot_deform_heap_tuple(), and tts_minimal_store_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    if (TTS_SHOULDFREE(slot))
    {
        heap_free_minimal_tuple(mslot->mintuple);
        slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
    }

    slot->tts_nvalid = 0;
    slot->tts_flags |= TTS_FLAG_EMPTY;
    ItemPointerSetInvalid(&slot->tts_tid);
    mslot->off = 0;
    mslot->mintuple = NULL;
}

tts_minimal_copy_heap_tuple()

static HeapTuple tts_minimal_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 577 of file execTuples.c.

References heap_tuple_from_minimal_tuple(), MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    if (!mslot->mintuple)
        tts_minimal_materialize(slot);

    return heap_tuple_from_minimal_tuple(mslot->mintuple);
}

tts_minimal_copy_minimal_tuple()

static MinimalTuple tts_minimal_copy_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 588 of file execTuples.c.

References heap_copy_minimal_tuple(), MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    if (!mslot->mintuple)
        tts_minimal_materialize(slot);

    return heap_copy_minimal_tuple(mslot->mintuple);
}

tts_minimal_copyslot()

static void tts_minimal_copyslot ( TupleTableSlot *  dstslot, TupleTableSlot *  srcslot  )

static

Definition at line 553 of file execTuples.c.

References ExecCopySlotMinimalTuple(), ExecStoreMinimalTuple(), MemoryContextSwitchTo(), and TupleTableSlot::tts_mcxt.

Referenced by slot_deform_heap_tuple().

{
    MemoryContext oldcontext;
    MinimalTuple mintuple;

    oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
    mintuple = ExecCopySlotMinimalTuple(srcslot);
    MemoryContextSwitchTo(oldcontext);

    ExecStoreMinimalTuple(mintuple, dstslot, true);
}

tts_minimal_get_minimal_tuple()

static MinimalTuple tts_minimal_get_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 566 of file execTuples.c.

References MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    if (!mslot->mintuple)
        tts_minimal_materialize(slot);

    return mslot->mintuple;
}

tts_minimal_getsomeattrs()

static void tts_minimal_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 488 of file execTuples.c.

References Assert, MinimalTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    Assert(!TTS_EMPTY(slot));

    slot_deform_heap_tuple(slot, mslot->tuple, &mslot->off, natts);
}

tts_minimal_getsysattr()

static Datum tts_minimal_getsysattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

static

Definition at line 498 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

{
    elog(ERROR, "minimal tuple table slot does not have system attributes");

    return 0;                   /* silence compiler warnings */
}

tts_minimal_init()

static void tts_minimal_init ( TupleTableSlot *  slot )

static

Definition at line 453 of file execTuples.c.

References MinimalTupleTableSlot::minhdr, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    /*
     * Initialize the heap tuple pointer to access attributes of the minimal
     * tuple contained in the slot as if its a heap tuple.
     */
    mslot->tuple = &mslot->minhdr;
}

tts_minimal_materialize()

static void tts_minimal_materialize ( TupleTableSlot *  slot )

static

Definition at line 506 of file execTuples.c.

References Assert, heap_copy_minimal_tuple(), heap_form_minimal_tuple(), MemoryContextSwitchTo(), MinimalTupleTableSlot::minhdr, MINIMAL_TUPLE_OFFSET, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_minimal_copy_heap_tuple(), tts_minimal_copy_minimal_tuple(), and tts_minimal_get_minimal_tuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
    MemoryContext oldContext;

    Assert(!TTS_EMPTY(slot));

    /* If slot has its tuple already materialized, nothing to do. */
    if (TTS_SHOULDFREE(slot))
        return;

    oldContext = MemoryContextSwitchTo(slot->tts_mcxt);

    /*
     * Have to deform from scratch, otherwise tts_values[] entries could point
     * into the non-materialized tuple (which might be gone when accessed).
     */
    slot->tts_nvalid = 0;
    mslot->off = 0;

    if (!mslot->mintuple)
    {
        mslot->mintuple = heap_form_minimal_tuple(slot->tts_tupleDescriptor,
                                                  slot->tts_values,
                                                  slot->tts_isnull);
    }
    else
    {
        /*
         * The minimal tuple contained in this slot is not allocated in the
         * memory context of the given slot (else it would have TTS_SHOULDFREE
         * set).  Copy the minimal tuple into the given slot's memory context.
         */
        mslot->mintuple = heap_copy_minimal_tuple(mslot->mintuple);
    }

    slot->tts_flags |= TTS_FLAG_SHOULDFREE;

    Assert(mslot->tuple == &mslot->minhdr);

    mslot->minhdr.t_len = mslot->mintuple->t_len + MINIMAL_TUPLE_OFFSET;
    mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mslot->mintuple - MINIMAL_TUPLE_OFFSET);

    MemoryContextSwitchTo(oldContext);
}

tts_minimal_release()

static void tts_minimal_release ( TupleTableSlot *  slot )

static

Definition at line 465 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_minimal_store_tuple()

static void tts_minimal_store_tuple ( TupleTableSlot *  slot, MinimalTuple  mtup, bool  shouldFree  )

static

Definition at line 599 of file execTuples.c.

References Assert, MinimalTupleTableSlot::minhdr, MINIMAL_TUPLE_OFFSET, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_EMPTY, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, tts_minimal_clear(), TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and MinimalTupleTableSlot::tuple.

Referenced by ExecForceStoreMinimalTuple(), and ExecStoreMinimalTuple().

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;

    tts_minimal_clear(slot);

    Assert(!TTS_SHOULDFREE(slot));
    Assert(TTS_EMPTY(slot));

    slot->tts_flags &= ~TTS_FLAG_EMPTY;
    slot->tts_nvalid = 0;
    mslot->off = 0;

    mslot->mintuple = mtup;
    Assert(mslot->tuple == &mslot->minhdr);
    mslot->minhdr.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
    mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
    /* no need to set t_self or t_tableOid since we won't allow access */

    if (shouldFree)
        slot->tts_flags |= TTS_FLAG_SHOULDFREE;
}

tts_virtual_clear()

static void tts_virtual_clear ( TupleTableSlot *  slot )

static

Definition at line 107 of file execTuples.c.

References VirtualTupleTableSlot::data, ItemPointerSetInvalid, pfree(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and unlikely.

Referenced by slot_deform_heap_tuple(), and tts_virtual_copyslot().

{
    if (unlikely(TTS_SHOULDFREE(slot)))
    {
        VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;

        pfree(vslot->data);
        vslot->data = NULL;

        slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
    }

    slot->tts_nvalid = 0;
    slot->tts_flags |= TTS_FLAG_EMPTY;
    ItemPointerSetInvalid(&slot->tts_tid);
}

tts_virtual_copy_heap_tuple()

static HeapTuple tts_virtual_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 268 of file execTuples.c.

References Assert, heap_form_tuple(), TTS_EMPTY, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_deform_heap_tuple().

{
    Assert(!TTS_EMPTY(slot));

    return heap_form_tuple(slot->tts_tupleDescriptor,
                           slot->tts_values,
                           slot->tts_isnull);
}

tts_virtual_copy_minimal_tuple()

static MinimalTuple tts_virtual_copy_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 278 of file execTuples.c.

References Assert, heap_form_minimal_tuple(), TTS_EMPTY, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_deform_heap_tuple().

{
    Assert(!TTS_EMPTY(slot));

    return heap_form_minimal_tuple(slot->tts_tupleDescriptor,
                                   slot->tts_values,
                                   slot->tts_isnull);
}

tts_virtual_copyslot()

static void tts_virtual_copyslot ( TupleTableSlot *  dstslot, TupleTableSlot *  srcslot  )

static

Definition at line 244 of file execTuples.c.

References Assert, TupleDescData::natts, slot_getallattrs(), TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, tts_virtual_clear(), and tts_virtual_materialize().

Referenced by slot_deform_heap_tuple().

{
    TupleDesc   srcdesc = srcslot->tts_tupleDescriptor;

    Assert(srcdesc->natts <= dstslot->tts_tupleDescriptor->natts);

    tts_virtual_clear(dstslot);

    slot_getallattrs(srcslot);

    for (int natt = 0; natt < srcdesc->natts; natt++)
    {
        dstslot->tts_values[natt] = srcslot->tts_values[natt];
        dstslot->tts_isnull[natt] = srcslot->tts_isnull[natt];
    }

    dstslot->tts_nvalid = srcdesc->natts;
    dstslot->tts_flags &= ~TTS_FLAG_EMPTY;

    /* make sure storage doesn't depend on external memory */
    tts_virtual_materialize(dstslot);
}

tts_virtual_getsomeattrs()

static void tts_virtual_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 130 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

{
    elog(ERROR, "getsomeattrs is not required to be called on a virtual tuple table slot");
}

tts_virtual_getsysattr()

static Datum tts_virtual_getsysattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

static

Definition at line 136 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

{
    elog(ERROR, "virtual tuple table slot does not have system attributes");

    return 0;                   /* silence compiler warnings */
}

tts_virtual_init()

static void tts_virtual_init ( TupleTableSlot *  slot )

static

Definition at line 97 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

tts_virtual_materialize()

static void tts_virtual_materialize ( TupleTableSlot *  slot )

static

Definition at line 151 of file execTuples.c.

References att_addlength_datum, att_align_nominal, VirtualTupleTableSlot::data, DatumGetEOHP(), DatumGetPointer, EOH_flatten_into(), EOH_get_flat_size(), MemoryContextAlloc(), TupleDescData::natts, PointerGetDatum, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescAttr, val, and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by slot_deform_heap_tuple(), and tts_virtual_copyslot().

{
    VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;
    TupleDesc   desc = slot->tts_tupleDescriptor;
    Size        sz = 0;
    char       *data;

    /* already materialized */
    if (TTS_SHOULDFREE(slot))
        return;

    /* compute size of memory required */
    for (int natt = 0; natt < desc->natts; natt++)
    {
        Form_pg_attribute att = TupleDescAttr(desc, natt);
        Datum       val;

        if (att->attbyval || slot->tts_isnull[natt])
            continue;

        val = slot->tts_values[natt];

        if (att->attlen == -1 &&
            VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
        {
            /*
             * We want to flatten the expanded value so that the materialized
             * slot doesn't depend on it.
             */
            sz = att_align_nominal(sz, att->attalign);
            sz += EOH_get_flat_size(DatumGetEOHP(val));
        }
        else
        {
            sz = att_align_nominal(sz, att->attalign);
            sz = att_addlength_datum(sz, att->attlen, val);
        }
    }

    /* all data is byval */
    if (sz == 0)
        return;

    /* allocate memory */
    vslot->data = data = MemoryContextAlloc(slot->tts_mcxt, sz);
    slot->tts_flags |= TTS_FLAG_SHOULDFREE;

    /* and copy all attributes into the pre-allocated space */
    for (int natt = 0; natt < desc->natts; natt++)
    {
        Form_pg_attribute att = TupleDescAttr(desc, natt);
        Datum       val;

        if (att->attbyval || slot->tts_isnull[natt])
            continue;

        val = slot->tts_values[natt];

        if (att->attlen == -1 &&
            VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
        {
            Size        data_length;

            /*
             * We want to flatten the expanded value so that the materialized
             * slot doesn't depend on it.
             */
            ExpandedObjectHeader *eoh = DatumGetEOHP(val);

            data = (char *) att_align_nominal(data,
                                              att->attalign);
            data_length = EOH_get_flat_size(eoh);
            EOH_flatten_into(eoh, data, data_length);

            slot->tts_values[natt] = PointerGetDatum(data);
            data += data_length;
        }
        else
        {
            Size        data_length = 0;

            data = (char *) att_align_nominal(data, att->attalign);
            data_length = att_addlength_datum(data_length, att->attlen, val);

            memcpy(data, DatumGetPointer(val), data_length);

            slot->tts_values[natt] = PointerGetDatum(data);
            data += data_length;
        }
    }
}

tts_virtual_release()

static void tts_virtual_release ( TupleTableSlot *  slot )

static

Definition at line 102 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

{
}

TupleDescGetAttInMetadata()

AttInMetadata* TupleDescGetAttInMetadata

(

TupleDesc

tupdesc

)

Definition at line 2067 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, BlessTupleDesc(), fmgr_info(), getTypeInputInfo(), i, TupleDescData::natts, palloc(), palloc0(), AttInMetadata::tupdesc, and TupleDescAttr.

Referenced by bt_metap(), bt_page_stats(), build_pgstattuple_type(), connectby_text(), connectby_text_serial(), create_foreign_modify(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), hash_page_items(), libpqrcv_processTuples(), materializeResult(), pg_config(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pg_stats_ext_mcvlist_items(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), pltcl_func_handler(), pltcl_init_tuple_store(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignScan(), prs_setup_firstcall(), show_all_settings(), storeRow(), ts_setup_firstcall(), tt_setup_firstcall(), and xpath_table().

{
    int         natts = tupdesc->natts;
    int         i;
    Oid         atttypeid;
    Oid         attinfuncid;
    FmgrInfo   *attinfuncinfo;
    Oid        *attioparams;
    int32      *atttypmods;
    AttInMetadata *attinmeta;

    attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));

    /* "Bless" the tupledesc so that we can make rowtype datums with it */
    attinmeta->tupdesc = BlessTupleDesc(tupdesc);

    /*
     * Gather info needed later to call the "in" function for each attribute
     */
    attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
    attioparams = (Oid *) palloc0(natts * sizeof(Oid));
    atttypmods = (int32 *) palloc0(natts * sizeof(int32));

    for (i = 0; i < natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);

        /* Ignore dropped attributes */
        if (!att->attisdropped)
        {
            atttypeid = att->atttypid;
            getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
            fmgr_info(attinfuncid, &attinfuncinfo[i]);
            atttypmods[i] = att->atttypmod;
        }
    }
    attinmeta->attinfuncs = attinfuncinfo;
    attinmeta->attioparams = attioparams;
    attinmeta->atttypmods = atttypmods;

    return attinmeta;
}

Variable Documentation

TTSOpsBufferHeapTuple

const TupleTableSlotOps TTSOpsBufferHeapTuple

Initial value:

= {
    .base_slot_size = sizeof(BufferHeapTupleTableSlot),
    .init = tts_buffer_heap_init,
    .release = tts_buffer_heap_release,
    .clear = tts_buffer_heap_clear,
    .getsomeattrs = tts_buffer_heap_getsomeattrs,
    .getsysattr = tts_buffer_heap_getsysattr,
    .materialize = tts_buffer_heap_materialize,
    .copyslot = tts_buffer_heap_copyslot,
    .get_heap_tuple = tts_buffer_heap_get_heap_tuple,

    
    .get_minimal_tuple = NULL,
    .copy_heap_tuple = tts_buffer_heap_copy_heap_tuple,
    .copy_minimal_tuple = tts_buffer_heap_copy_minimal_tuple
}

Definition at line 86 of file execTuples.c.

Referenced by CheckOpSlotCompatibility(), heapam_slot_callbacks(), and slot_compile_deform().

TTSOpsHeapTuple

const TupleTableSlotOps TTSOpsHeapTuple

Initial value:

= {
    .base_slot_size = sizeof(HeapTupleTableSlot),
    .init = tts_heap_init,
    .release = tts_heap_release,
    .clear = tts_heap_clear,
    .getsomeattrs = tts_heap_getsomeattrs,
    .getsysattr = tts_heap_getsysattr,
    .materialize = tts_heap_materialize,
    .copyslot = tts_heap_copyslot,
    .get_heap_tuple = tts_heap_get_heap_tuple,

    
    .get_minimal_tuple = NULL,
    .copy_heap_tuple = tts_heap_copy_heap_tuple,
    .copy_minimal_tuple = tts_heap_copy_minimal_tuple
}

Definition at line 84 of file execTuples.c.

Referenced by CatalogIndexInsert(), CheckOpSlotCompatibility(), compute_index_stats(), copyTemplateDependencies(), ExecInitForeignScan(), ExecInitSetOp(), ExecuteCallStmt(), heapam_index_validate_scan(), InsertPgAttributeTuples(), recordMultipleDependencies(), slot_compile_deform(), table_slot_callbacks(), and tuplesort_begin_cluster().

TTSOpsMinimalTuple

const TupleTableSlotOps TTSOpsMinimalTuple

Initial value:

= {
    .base_slot_size = sizeof(MinimalTupleTableSlot),
    .init = tts_minimal_init,
    .release = tts_minimal_release,
    .clear = tts_minimal_clear,
    .getsomeattrs = tts_minimal_getsomeattrs,
    .getsysattr = tts_minimal_getsysattr,
    .materialize = tts_minimal_materialize,
    .copyslot = tts_minimal_copyslot,

    
    .get_heap_tuple = NULL,
    .get_minimal_tuple = tts_minimal_get_minimal_tuple,
    .copy_heap_tuple = tts_minimal_copy_heap_tuple,
    .copy_minimal_tuple = tts_minimal_copy_minimal_tuple
}

Definition at line 85 of file execTuples.c.

Referenced by afterTriggerInvokeEvents(), build_pertrans_for_aggref(), BuildTupleHashTableExt(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), find_hash_columns(), gather_merge_setup(), hashagg_recompile_expressions(), hypothetical_dense_rank_final(), init_sql_fcache(), ordered_set_startup(), RunFromStore(), and slot_compile_deform().

TTSOpsVirtual

const TupleTableSlotOps TTSOpsVirtual

Initial value:

= {
    .base_slot_size = sizeof(VirtualTupleTableSlot),
    .init = tts_virtual_init,
    .release = tts_virtual_release,
    .clear = tts_virtual_clear,
    .getsomeattrs = tts_virtual_getsomeattrs,
    .getsysattr = tts_virtual_getsysattr,
    .materialize = tts_virtual_materialize,
    .copyslot = tts_virtual_copyslot,

    
    .get_heap_tuple = NULL,
    .get_minimal_tuple = NULL,
    .copy_heap_tuple = tts_virtual_copy_heap_tuple,
    .copy_minimal_tuple = tts_virtual_copy_minimal_tuple
}

Definition at line 83 of file execTuples.c.

Referenced by AfterTriggerSaveEvent(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CheckOpSlotCompatibility(), CreateReplicationSlot(), ExecComputeSlotInfo(), ExecConditionalAssignProjectionInfo(), ExecConstraints(), ExecGetResultSlotOps(), ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitProjectSet(), ExecInitResult(), ExecInitSort(), ExecInitSubPlan(), ExecInitValuesScan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), ExplainQuery(), IdentifySystem(), InitPlan(), llvm_compile_expr(), RI_Initial_Check(), RI_PartitionRemove_Check(), ShowAllGUCConfig(), ShowGUCConfigOption(), slot_compile_deform(), StartReplication(), table_slot_callbacks(), and tstoreStartupReceiver().