execTuples.c File Reference

#include "postgres.h"
#include "access/heaptoast.h"
#include "access/htup_details.h"
#include "access/tupdesc_details.h"
#include "access/xact.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 reqnatts, bool support_cstring)
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 bool	tts_virtual_is_current_xact_tuple (TupleTableSlot *slot)
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, Size extra)
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 bool	tts_heap_is_current_xact_tuple (TupleTableSlot *slot)
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, Size extra)
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 bool	tts_minimal_is_current_xact_tuple (TupleTableSlot *slot)
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, Size extra)
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 bool	tts_buffer_is_current_xact_tuple (TupleTableSlot *slot)
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, Size extra)
TupleTableSlot *	MakeTupleTableSlot (TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops, uint16 flags)
TupleTableSlot *	ExecAllocTableSlot (List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops, uint16 flags)
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, uint16 flags)
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, const Datum *values, const 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 2525 of file execTuples.c.

{
    TupOutputState *tstate;
 
    tstate = palloc_object(TupOutputState);
 
    tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
    tstate->dest = dest;
 
    tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
 
    return tstate;
}

References CMD_SELECT, fb(), MakeSingleTupleTableSlot(), and palloc_object.

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExecWaitStmt(), ExplainQuery(), IdentifySystem(), ReadReplicationSlot(), SendTablespaceList(), SendXlogRecPtrResult(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

BlessTupleDesc()

TupleDesc BlessTupleDesc

(

TupleDesc

tupdesc

)

Definition at line 2338 of file execTuples.c.

{
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupdesc->firstNonCachedOffsetAttr >= 0);
 
    if (tupdesc->tdtypeid == RECORDOID &&
        tupdesc->tdtypmod < 0)
        assign_record_type_typmod(tupdesc);
 
    return tupdesc;             /* just for notational convenience */
}

References Assert, assign_record_type_typmod(), fb(), TupleDescData::firstNonCachedOffsetAttr, TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by aclexplode(), BeginCopyTo(), brin_metapage_info(), bt_page_items_bytea(), bt_page_items_internal(), exec_eval_datum(), ExecEvalWholeRowVar(), ExecInitExprRec(), ExecInitFunctionScan(), get_expr_result_type(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), init_execution_state(), InitMaterializedSRF(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), pg_get_catalog_foreign_keys(), pg_get_publication_tables(), pg_get_sequence_data(), pg_lock_status(), pg_prepared_xact(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_wal_build_tuple(), pg_stats_ext_mcvlist_items(), pg_visibility_tupdesc(), pg_walfile_name_offset(), pgstathashindex(), PLy_output_setup_record(), setup_firstcall(), ssl_extension_info(), test_custom_stats_fixed_report(), test_custom_stats_var_report(), test_enc_conversion(), test_predtest(), and TupleDescGetAttInMetadata().

BuildTupleFromCStrings()

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

Definition at line 2405 of file execTuples.c.

{
    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 (!TupleDescCompactAttr(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;
}

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, CompactAttribute::attisdropped, AttInMetadata::atttypmods, fb(), heap_form_tuple(), i, InputFunctionCall(), TupleDescData::natts, palloc(), pfree(), AttInMetadata::tupdesc, TupleDescCompactAttr(), and values.

Referenced by bt_metap(), bt_multi_page_stats(), bt_page_stats_internal(), build_pgstattuple_type(), build_tuplestore_recursively(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), libpqrcv_processTuples(), materializeQueryResult(), materializeResult(), pg_get_keywords(), pg_get_multixact_members(), 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().

do_text_output_multiline()

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

Definition at line 2573 of file execTuples.c.

{
    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;
    }
}

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

Referenced by ExplainQuery().

do_tup_output()

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

Definition at line 2545 of file execTuples.c.

{
    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);
}

References ExecClearTuple(), ExecStoreVirtualTuple(), fb(), TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and values.

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

end_tup_output()

void end_tup_output

(

TupOutputState *

tstate

)

Definition at line 2603 of file execTuples.c.

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

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

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExecWaitStmt(), ExplainQuery(), IdentifySystem(), ReadReplicationSlot(), SendTablespaceList(), SendXlogRecPtrResult(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

ExecAllocTableSlot()

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

Definition at line 1430 of file execTuples.c.

{
    TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops, flags);
 
    *tupleTable = lappend(*tupleTable, slot);
 
    return slot;
}

References fb(), lappend(), and MakeTupleTableSlot().

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

ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL

(

List *

targetList

)

Definition at line 2210 of file execTuples.c.

{
    return ExecTypeFromTLInternal(targetList, true);
}

References ExecTypeFromTLInternal().

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

ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot

(

TupleTableSlot *

slot

)

Definition at line 1513 of file execTuples.c.

{
    /* 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);
}

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(), AfterTriggerFreeQuery(), afterTriggerInvokeEvents(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), check_pub_dead_tuple_retention(), check_publications(), check_publications_origin_sequences(), check_publications_origin_tables(), compute_expr_stats(), compute_index_stats(), copy_sequences(), CopyMultiInsertBufferCleanup(), CopyRelationTo(), copyTemplateDependencies(), DefineTSConfiguration(), deleteSplitPartitionContext(), end_tup_output(), EnumValuesCreate(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_relation_list(), fetch_remote_table_info(), FindConflictTuple(), freestate_cluster(), get_actual_variable_range(), get_rel_sync_entry(), heap_entry_is_visible(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), MergePartitionsMoveRows(), pgoutput_change(), recordMultipleDependencies(), RelationFindDeletedTupleInfoByIndex(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), SplitPartitionMoveRows(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), unique_key_recheck(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTuple()

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

Definition at line 1909 of file execTuples.c.

{
    /*
     * 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);
    }
}

References Assert, TupleTableSlotOps::copy_heap_tuple, fb(), 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(), update_most_recent_deletion_info(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum

(

TupleTableSlot *

slot

)

Definition at line 1988 of file execTuples.c.

{
    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;
}

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

Referenced by CopyToJsonOneRow(), ExecMakeFunctionResultSet(), and postquel_get_single_result().

ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple	(	TupleTableSlot *	slot,
		bool *	shouldFree
	)

Definition at line 1957 of file execTuples.c.

{
    /*
     * 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, 0);
    }
}

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

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

ExecForceStoreHeapTuple()

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

Definition at line 1734 of file execTuples.c.

{
    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);
        }
    }
}

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

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

ExecForceStoreMinimalTuple()

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

Definition at line 1777 of file execTuples.c.

{
    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);
        }
    }
}

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

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

ExecInitExtraTupleSlot()

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

Definition at line 2097 of file execTuples.c.

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

References EState::es_tupleTable, and ExecAllocTableSlot().

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

ExecInitNullTupleSlot()

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

Definition at line 2113 of file execTuples.c.

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

References ExecInitExtraTupleSlot(), ExecStoreAllNullTuple(), and fb().

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

ExecInitResultSlot()

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

Definition at line 2044 of file execTuples.c.

{
    TupleTableSlot *slot;
 
    slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
                              planstate->ps_ResultTupleDesc, tts_ops, 0);
    planstate->ps_ResultTupleSlot = slot;
 
    planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
    planstate->resultops = tts_ops;
    planstate->resultopsset = true;
}

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

Referenced by ExecConditionalAssignProjectionInfo(), and ExecInitResultTupleSlotTL().

ExecInitResultTupleSlotTL()

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

Definition at line 2064 of file execTuples.c.

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

References ExecInitResultSlot(), and ExecInitResultTypeTL().

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

ExecInitResultTypeTL()

void ExecInitResultTypeTL

(

PlanState *

planstate

)

Definition at line 2020 of file execTuples.c.

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

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(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

ExecInitScanTupleSlot()

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

Definition at line 2076 of file execTuples.c.

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

References EState::es_tupleTable, ExecAllocTableSlot(), and fb().

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

ExecResetTupleTable()

void ExecResetTupleTable	(	List *	tupleTable,
		bool	shouldFree
	)

Definition at line 1450 of file execTuples.c.

{
    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);
}

References ExecClearTuple(), fb(), 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(), CopyFrom(), EvalPlanQualEnd(), ExecEndPlan(), and finish_edata().

ExecSetSlotDescriptor()

void ExecSetSlotDescriptor	(	TupleTableSlot *	slot,
		TupleDesc	tupdesc
	)

Definition at line 1548 of file execTuples.c.

{
    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));
 
    /*
     * We round the size of tts_isnull up to the next highest multiple of 8.
     * This is needed as populate_isnull_array() operates on 8 elements at a
     * time when converting a tuple's NULL bitmap into a boolean array.
     */
    slot->tts_isnull = (bool *)
        MemoryContextAlloc(slot->tts_mcxt, TYPEALIGN(8, tupdesc->natts * sizeof(bool)));
}

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

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

ExecStoreAllNullTuple()

TupleTableSlot * ExecStoreAllNullTuple

(

TupleTableSlot *

slot

)

Definition at line 1841 of file execTuples.c.

{
    /*
     * 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);
}

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

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

ExecStoreBufferHeapTuple()

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

Definition at line 1657 of file execTuples.c.

{
    /*
     * 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;
}

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

Referenced by heap_getnextslot(), heap_getnextslot_tidrange(), 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().

ExecStoreHeapTuple()

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

Definition at line 1617 of file execTuples.c.

{
    /*
     * 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;
}

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

Referenced by CatalogIndexInsert(), comparetup_cluster_tiebreak(), compute_expr_stats(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), get_returning_data(), heapam_index_validate_scan(), make_build_data(), pgoutput_change(), postgresIterateForeignScan(), and tts_heap_copyslot().

ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum	(	Datum	data,
		TupleTableSlot *	slot
	)

Definition at line 1871 of file execTuples.c.

{
    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);
}

References data, 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().

ExecStoreMinimalTuple()

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

Definition at line 1711 of file execTuples.c.

{
    /*
     * 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;
}

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

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

ExecStorePinnedBufferHeapTuple()

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

Definition at line 1683 of file execTuples.c.

{
    /*
     * 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;
}

References Assert, BufferIsValid(), elog, ERROR, fb(), 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().

ExecStoreVirtualTuple()

TupleTableSlot * ExecStoreVirtualTuple

(

TupleTableSlot *

slot

)

Definition at line 1817 of file execTuples.c.

{
    /*
     * 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;
}

References Assert, fb(), TupleDescData::natts, TTS_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(), DefineTSConfiguration(), do_tup_output(), EnumValuesCreate(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecEvalPreOrderedDistinctMulti(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hashagg_spill_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), InsertPgAttributeTuples(), MakeConfigurationMapping(), MergePartitionsMoveRows(), ordered_set_transition_multi(), pgoutput_row_filter(), prepare_hash_slot(), prepare_probe_slot(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_data(), slot_store_data(), SplitPartitionMoveRows(), StoreIndexTuple(), and ValuesNext().

ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList

(

List *

exprList

)

Definition at line 2259 of file execTuples.c.

{
    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++;
    }
 
    TupleDescFinalize(typeInfo);
 
    return typeInfo;
}

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

Referenced by ExecInitExprRec(), ExecInitMemoize(), and ExecInitValuesScan().

ExecTypeFromTL()

TupleDesc ExecTypeFromTL

(

List *

targetList

)

Definition at line 2198 of file execTuples.c.

{
    return ExecTypeFromTLInternal(targetList, false);
}

References ExecTypeFromTLInternal().

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

ExecTypeFromTLInternal()

static TupleDesc ExecTypeFromTLInternal ( List *  targetList, bool  skipjunk  )

static

Definition at line 2216 of file execTuples.c.

{
    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++;
    }
 
    TupleDescFinalize(typeInfo);
 
    return typeInfo;
}

References CreateTemplateTupleDesc(), ExecCleanTargetListLength(), ExecTargetListLength(), exprCollation(), exprType(), exprTypmod(), fb(), len, lfirst, TupleDescFinalize(), TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecCleanTypeFromTL(), and ExecTypeFromTL().

ExecTypeSetColNames()

void ExecTypeSetColNames	(	TupleDesc	typeInfo,
		List *	namesList
	)

Definition at line 2294 of file execTuples.c.

{
    int         colno = 0;
    ListCell   *lc;
 
    /* It's only OK to change col names in a not-yet-blessed RECORD type */
    Assert(typeInfo->tdtypeid == RECORDOID);
    Assert(typeInfo->tdtypmod < 0);
 
    foreach(lc, namesList)
    {
        char       *cname = strVal(lfirst(lc));
        Form_pg_attribute attr;
 
        /* Guard against too-long names list (probably can't happen) */
        if (colno >= typeInfo->natts)
            break;
        attr = TupleDescAttr(typeInfo, colno);
        colno++;
 
        /*
         * Do nothing for empty aliases or dropped columns (these cases
         * probably can't arise in RECORD types, either)
         */
        if (cname[0] == '\0' || attr->attisdropped)
            continue;
 
        /* OK, assign the column name */
        namestrcpy(&(attr->attname), cname);
    }
}

References Assert, fb(), lfirst, namestrcpy(), strVal, and TupleDescAttr().

Referenced by ExecEvalWholeRowVar(), and ExecInitExprRec().

HeapTupleHeaderGetDatum()

Datum HeapTupleHeaderGetDatum

(

HeapTupleHeader

tuple

)

Definition at line 2494 of file execTuples.c.

{
    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;
}

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

Referenced by HeapTupleGetDatum(), populate_composite(), and populate_recordset_record().

MakeSingleTupleTableSlot()

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

Definition at line 1497 of file execTuples.c.

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

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTable(), CatalogIndexInsert(), check_pub_dead_tuple_retention(), check_publications(), check_publications_origin_sequences(), check_publications_origin_tables(), compute_expr_stats(), compute_index_stats(), copy_sequences(), copyTemplateDependencies(), DefineTSConfiguration(), EnumValuesCreate(), ExecInitIncrementalSort(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMemoize(), ExecInitPartitionDispatchInfo(), ExecInsert(), ExecPrepareTuplestoreResult(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), GetAfterTriggersStoreSlot(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_execution_state(), init_tuple_slot(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), ordered_set_startup(), pgoutput_row_filter(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), table_slot_create(), tstoreStartupReceiver(), tuplesort_begin_cluster(), and validate_remote_info().

MakeTupleTableSlot()

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

Definition at line 1351 of file execTuples.c.

{
    Size        basesz,
                allocsz;
    TupleTableSlot *slot;
 
    basesz = tts_ops->base_slot_size;
 
    /* Ensure callers don't have any way to set transient flags permanently */
    flags &= ~TTS_FLAGS_TRANSIENT;
 
    /*
     * When a fixed descriptor is specified, we can reduce overhead by
     * allocating the entire slot in one go.
     *
     * We round the size of tts_isnull up to the next highest multiple of 8.
     * This is needed as populate_isnull_array() operates on 8 elements at a
     * time when converting a tuple's NULL bitmap into a boolean array.
     */
    if (tupleDesc)
        allocsz = MAXALIGN(basesz) +
            MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
            TYPEALIGN(8, 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 | flags;
    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);
 
        /*
         * Precalculate the maximum guaranteed attribute that has to exist in
         * every tuple which gets deformed into this slot.  When the
         * TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS flag is enabled, we simply take
         * the precalculated value from the tupleDesc, otherwise the
         * optimization is disabled, and we set the value to 0.
         */
        if ((flags & TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS) != 0)
            slot->tts_first_nonguaranteed = tupleDesc->firstNonGuaranteedAttr;
        else
            slot->tts_first_nonguaranteed = 0;
    }
 
    /*
     * And allow slot type specific initialization.
     */
    slot->tts_ops->init(slot);
 
    return slot;
}

References TupleTableSlotOps::base_slot_size, CurrentMemoryContext, fb(), TupleTableSlotOps::init, MAXALIGN, palloc0(), PinTupleDesc, TupleTableSlot::tts_first_nonguaranteed, TTS_FLAG_EMPTY, TTS_FLAG_FIXED, TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleTableSlot::type, and TYPEALIGN.

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

slot_deform_heap_tuple()

static pg_attribute_always_inline void slot_deform_heap_tuple ( TupleTableSlot *  slot, HeapTuple  tuple, uint32 *  offp, int  reqnatts, bool  support_cstring  )

static

Definition at line 1017 of file execTuples.c.

{
    CompactAttribute *cattrs;
    CompactAttribute *cattr;
    TupleDesc   tupleDesc = slot->tts_tupleDescriptor;
    HeapTupleHeader tup = tuple->t_data;
    size_t      attnum;
    int         firstNonCacheOffsetAttr;
    int         firstNonGuaranteedAttr;
    int         firstNullAttr;
    int         natts;
    Datum      *values;
    bool       *isnull;
    char       *tp;             /* ptr to tuple data */
    uint32      off;            /* offset in tuple data */
 
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupleDesc->firstNonCachedOffsetAttr >= 0);
 
    isnull = slot->tts_isnull;
 
    /*
     * Some callers may form and deform tuples prior to NOT NULL constraints
     * being checked.  Here we'd like to optimize the case where we only need
     * to fetch attributes before or up to the point where the attribute is
     * guaranteed to exist in the tuple.  We rely on the slot flag being set
     * correctly to only enable this optimization when it's valid to do so.
     * This optimization allows us to save fetching the number of attributes
     * from the tuple and saves the additional cost of handling non-byval
     * attrs.
     */
    firstNonGuaranteedAttr = Min(reqnatts, slot->tts_first_nonguaranteed);
 
    firstNonCacheOffsetAttr = tupleDesc->firstNonCachedOffsetAttr;
 
    if (HeapTupleHasNulls(tuple))
    {
        natts = HeapTupleHeaderGetNatts(tup);
        tp = (char *) tup + MAXALIGN(offsetof(HeapTupleHeaderData, t_bits) +
                                     BITMAPLEN(natts));
 
        natts = Min(natts, reqnatts);
        if (natts > firstNonGuaranteedAttr)
        {
            bits8      *bp = tup->t_bits;
 
            /* Find the first NULL attr */
            firstNullAttr = first_null_attr(bp, natts);
 
            /*
             * And populate the isnull array for all attributes being fetched
             * from the tuple.
             */
            populate_isnull_array(bp, natts, isnull);
        }
        else
        {
            /* Otherwise all required columns are guaranteed to exist */
            firstNullAttr = natts;
        }
    }
    else
    {
        tp = (char *) tup + MAXALIGN(offsetof(HeapTupleHeaderData, t_bits));
 
        /*
         * We only need to look at the tuple's natts if we need more than the
         * guaranteed number of columns
         */
        if (reqnatts > firstNonGuaranteedAttr)
            natts = Min(HeapTupleHeaderGetNatts(tup), reqnatts);
        else
        {
            /* No need to access the number of attributes in the tuple */
            natts = reqnatts;
        }
 
        /* All attrs can be fetched without checking for NULLs */
        firstNullAttr = natts;
    }
 
    attnum = slot->tts_nvalid;
    values = slot->tts_values;
    slot->tts_nvalid = reqnatts;
 
    /*
     * We store the tupleDesc's CompactAttribute array in 'cattrs' as gcc
     * seems to be unwilling to optimize accessing the CompactAttribute
     * element efficiently when accessing it via TupleDescCompactAttr().
     */
    cattrs = tupleDesc->compact_attrs;
 
    /* Ensure we calculated tp correctly */
    Assert(tp == (char *) tup + tup->t_hoff);
 
    if (attnum < firstNonGuaranteedAttr)
    {
        int         attlen;
 
        do
        {
            isnull[attnum] = false;
            cattr = &cattrs[attnum];
            attlen = cattr->attlen;
 
            /* We don't expect any non-byval types */
            pg_assume(attlen > 0);
            Assert(cattr->attbyval == true);
 
            off = cattr->attcacheoff;
            values[attnum] = fetch_att_noerr(tp + off, true, attlen);
            attnum++;
        } while (attnum < firstNonGuaranteedAttr);
 
        off += attlen;
 
        if (attnum == reqnatts)
            goto done;
    }
    else
    {
        /*
         * We may be incrementally deforming the tuple, so set 'off' to the
         * previously cached value.  This may be 0, if the slot has just
         * received a new tuple.
         */
        off = *offp;
 
        /* We expect *offp to be set to 0 when attnum == 0 */
        Assert(off == 0 || attnum > 0);
    }
 
    /* We can use attcacheoff up until the first NULL */
    firstNonCacheOffsetAttr = Min(firstNonCacheOffsetAttr, firstNullAttr);
 
    /*
     * Handle the portion of the tuple that we have cached the offset for up
     * to the first NULL attribute.  The offset is effectively fixed for
     * these, so we can use the CompactAttribute's attcacheoff.
     */
    if (attnum < firstNonCacheOffsetAttr)
    {
        int         attlen;
 
        do
        {
            isnull[attnum] = false;
            cattr = &cattrs[attnum];
            attlen = cattr->attlen;
            off = cattr->attcacheoff;
            values[attnum] = fetch_att_noerr(tp + off,
                                             cattr->attbyval,
                                             attlen);
            attnum++;
        } while (attnum < firstNonCacheOffsetAttr);
 
        /*
         * Point the offset after the end of the last attribute with a cached
         * offset.  We expect the final cached offset attribute to have a
         * fixed width, so just add the attlen to the attcacheoff
         */
        Assert(attlen > 0);
        off += attlen;
    }
 
    /*
     * Handle any portion of the tuple that doesn't have a fixed offset up
     * until the first NULL attribute.  This loop only differs from the one
     * after it by the NULL checks.
     */
    for (; attnum < firstNullAttr; attnum++)
    {
        int         attlen;
 
        isnull[attnum] = false;
        cattr = &cattrs[attnum];
        attlen = cattr->attlen;
 
        /*
         * Only emit the cstring-related code in align_fetch_then_add() when
         * cstring support is needed.  We assume support_cstring will be
         * passed as a const to allow the compiler to eliminate this branch.
         */
        if (!support_cstring)
            pg_assume(attlen > 0 || attlen == -1);
 
        /* align 'off', fetch the datum, and increment off beyond the datum */
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              attlen,
                                              cattr->attalignby);
    }
 
    /*
     * Now handle any remaining attributes in the tuple up to the requested
     * attnum.  This time, include NULL checks as we're now at the first NULL
     * attribute.
     */
    for (; attnum < natts; attnum++)
    {
        int         attlen;
 
        if (isnull[attnum])
        {
            values[attnum] = (Datum) 0;
            continue;
        }
 
        cattr = &cattrs[attnum];
        attlen = cattr->attlen;
 
        /* As above, only emit cstring code when needed. */
        if (!support_cstring)
            pg_assume(attlen > 0 || attlen == -1);
 
        /* align 'off', fetch the datum, and increment off beyond the datum */
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              attlen,
                                              cattr->attalignby);
    }
 
    /* Fetch any missing attrs and raise an error if reqnatts is invalid */
    if (unlikely(attnum < reqnatts))
    {
        /*
         * Cache the offset before calling the function to allow the compiler
         * to implement a tail-call optimization
         */
        *offp = off;
        slot_getmissingattrs(slot, attnum, reqnatts);
        return;
    }
done:
 
    /* Save current offset for next execution */
    *offp = off;
}

References align_fetch_then_add(), Assert, attlen, attnum, BITMAPLEN(), fb(), fetch_att_noerr(), first_null_attr(), HeapTupleHasNulls(), HeapTupleHeaderGetNatts, MAXALIGN, Min, pg_assume, populate_isnull_array(), slot_getmissingattrs(), HeapTupleData::t_data, TupleTableSlot::tts_first_nonguaranteed, TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, unlikely, and values.

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

slot_getmissingattrs()

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

Definition at line 2134 of file execTuples.c.

{
    AttrMissing *attrmiss = NULL;
 
    /* Check for invalid attnums */
    if (unlikely(lastAttNum > slot->tts_tupleDescriptor->natts))
        elog(ERROR, "invalid attribute number %d", lastAttNum);
 
    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 */
        for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
        {
            slot->tts_values[attnum] = (Datum) 0;
            slot->tts_isnull[attnum] = true;
        }
    }
    else
    {
        /* use attrmiss to set the missing values */
        for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
        {
            slot->tts_values[attnum] = attrmiss[attnum].am_value;
            slot->tts_isnull[attnum] = !attrmiss[attnum].am_present;
        }
    }
}

References attnum, TupleDescData::constr, elog, ERROR, fb(), TupleConstr::missing, TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and unlikely.

Referenced by slot_deform_heap_tuple().

slot_getsomeattrs_int()

void slot_getsomeattrs_int	(	TupleTableSlot *	slot,
		int	attnum
	)

Definition at line 2170 of file execTuples.c.

{
    /* Check for caller errors */
    Assert(slot->tts_nvalid < attnum);  /* checked in slot_getsomeattrs */
    Assert(attnum > 0);
 
    /* Fetch as many attributes as possible from the underlying tuple. */
    slot->tts_ops->getsomeattrs(slot, attnum);
 
    /*
     * Avoid putting new code here as that would prevent the compiler from
     * using the sibling call optimization for the above function.
     */
}

References Assert, attnum, TupleTableSlotOps::getsomeattrs, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_ops.

tts_buffer_heap_clear()

static void tts_buffer_heap_clear ( TupleTableSlot *  slot )

static

Definition at line 721 of file execTuples.c.

{
    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;
}

References Assert, BufferIsValid(), fb(), heap_freetuple(), InvalidBuffer, ItemPointerSetInvalid(), ReleaseBuffer(), TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

tts_buffer_heap_copy_heap_tuple()

static HeapTuple tts_buffer_heap_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 918 of file execTuples.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    if (!bslot->base.tuple)
        tts_buffer_heap_materialize(slot);
 
    return heap_copytuple(bslot->base.tuple);
}

References Assert, fb(), heap_copytuple(), tts_buffer_heap_materialize(), and TTS_EMPTY.

tts_buffer_heap_copy_minimal_tuple()

static MinimalTuple tts_buffer_heap_copy_minimal_tuple ( TupleTableSlot *  slot, Size  extra  )

static

Definition at line 931 of file execTuples.c.

{
    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, extra);
}

References Assert, fb(), minimal_tuple_from_heap_tuple(), tts_buffer_heap_materialize(), and TTS_EMPTY.

tts_buffer_heap_copyslot()

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

static

Definition at line 863 of file execTuples.c.

{
    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;
    }
}

References Assert, BufferIsValid(), ExecClearTuple(), ExecCopySlotHeapTuple(), fb(), MemoryContextSwitchTo(), tts_buffer_heap_store_tuple(), TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_ops, and TTS_SHOULDFREE.

tts_buffer_heap_get_heap_tuple()

static HeapTuple tts_buffer_heap_get_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 905 of file execTuples.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    if (!bslot->base.tuple)
        tts_buffer_heap_materialize(slot);
 
    return bslot->base.tuple;
}

References Assert, fb(), tts_buffer_heap_materialize(), and TTS_EMPTY.

tts_buffer_heap_getsomeattrs()

static void tts_buffer_heap_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 751 of file execTuples.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    slot_deform_heap_tuple(slot, bslot->base.tuple, &bslot->base.off, natts, false);
}

References Assert, fb(), slot_deform_heap_tuple(), and TTS_EMPTY.

tts_buffer_heap_getsysattr()

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

static

Definition at line 761 of file execTuples.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    /*
     * In some code paths it's possible to get here with a non-materialized
     * slot, in which case we can't retrieve system columns.
     */
    if (!bslot->base.tuple)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot retrieve a system column in this context")));
 
    return heap_getsysattr(bslot->base.tuple, attnum,
                           slot->tts_tupleDescriptor, isnull);
}

References Assert, attnum, ereport, errcode(), errmsg, ERROR, fb(), heap_getsysattr(), TTS_EMPTY, and TupleTableSlot::tts_tupleDescriptor.

tts_buffer_heap_init()

static void tts_buffer_heap_init ( TupleTableSlot *  slot )

static

Definition at line 711 of file execTuples.c.

{
}

tts_buffer_heap_materialize()

static void tts_buffer_heap_materialize ( TupleTableSlot *  slot )

static

Definition at line 804 of file execTuples.c.

{
    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);
}

References Assert, BufferIsValid(), fb(), heap_copytuple(), heap_form_tuple(), InvalidBuffer, likely, MemoryContextSwitchTo(), ReleaseBuffer(), TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

tts_buffer_heap_release()

static void tts_buffer_heap_release ( TupleTableSlot *  slot )

static

Definition at line 716 of file execTuples.c.

{
}

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 944 of file execTuples.c.

{
    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);
    }
}

References Assert, BufferIsValid(), fb(), heap_freetuple(), IncrBufferRefCount(), ReleaseBuffer(), HeapTupleData::t_self, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

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

tts_buffer_is_current_xact_tuple()

static bool tts_buffer_is_current_xact_tuple ( TupleTableSlot *  slot )

static

Definition at line 781 of file execTuples.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    TransactionId xmin;
 
    Assert(!TTS_EMPTY(slot));
 
    /*
     * In some code paths it's possible to get here with a non-materialized
     * slot, in which case we can't check if tuple is created by the current
     * transaction.
     */
    if (!bslot->base.tuple)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("don't have a storage tuple in this context")));
 
    xmin = HeapTupleHeaderGetRawXmin(bslot->base.tuple->t_data);
 
    return TransactionIdIsCurrentTransactionId(xmin);
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), HeapTupleHeaderGetRawXmin(), TransactionIdIsCurrentTransactionId(), and TTS_EMPTY.

tts_heap_clear()

static void tts_heap_clear ( TupleTableSlot *  slot )

static

Definition at line 327 of file execTuples.c.

{
    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;
}

References fb(), heap_freetuple(), ItemPointerSetInvalid(), TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

Referenced by tts_heap_store_tuple().

tts_heap_copy_heap_tuple()

static HeapTuple tts_heap_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 464 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
    if (!hslot->tuple)
        tts_heap_materialize(slot);
 
    return heap_copytuple(hslot->tuple);
}

References Assert, fb(), heap_copytuple(), TTS_EMPTY, and tts_heap_materialize().

tts_heap_copy_minimal_tuple()

static MinimalTuple tts_heap_copy_minimal_tuple ( TupleTableSlot *  slot, Size  extra  )

static

Definition at line 476 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
 
    if (!hslot->tuple)
        tts_heap_materialize(slot);
 
    return minimal_tuple_from_heap_tuple(hslot->tuple, extra);
}

References fb(), minimal_tuple_from_heap_tuple(), and tts_heap_materialize().

tts_heap_copyslot()

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

static

Definition at line 439 of file execTuples.c.

{
    HeapTuple   tuple;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
    tuple = ExecCopySlotHeapTuple(srcslot);
    MemoryContextSwitchTo(oldcontext);
 
    ExecStoreHeapTuple(tuple, dstslot, true);
}

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

tts_heap_get_heap_tuple()

static HeapTuple tts_heap_get_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 452 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
    if (!hslot->tuple)
        tts_heap_materialize(slot);
 
    return hslot->tuple;
}

References Assert, fb(), TTS_EMPTY, and tts_heap_materialize().

tts_heap_getsomeattrs()

static void tts_heap_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 346 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    slot_deform_heap_tuple(slot, hslot->tuple, &hslot->off, natts, false);
}

References Assert, fb(), slot_deform_heap_tuple(), and TTS_EMPTY.

tts_heap_getsysattr()

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

static

Definition at line 356 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    /*
     * In some code paths it's possible to get here with a non-materialized
     * slot, in which case we can't retrieve system columns.
     */
    if (!hslot->tuple)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot retrieve a system column in this context")));
 
    return heap_getsysattr(hslot->tuple, attnum,
                           slot->tts_tupleDescriptor, isnull);
}

References Assert, attnum, ereport, errcode(), errmsg, ERROR, fb(), heap_getsysattr(), TTS_EMPTY, and TupleTableSlot::tts_tupleDescriptor.

tts_heap_init()

static void tts_heap_init ( TupleTableSlot *  slot )

static

Definition at line 317 of file execTuples.c.

{
}

tts_heap_is_current_xact_tuple()

static bool tts_heap_is_current_xact_tuple ( TupleTableSlot *  slot )

static

Definition at line 376 of file execTuples.c.

{
    HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
    TransactionId xmin;
 
    Assert(!TTS_EMPTY(slot));
 
    /*
     * In some code paths it's possible to get here with a non-materialized
     * slot, in which case we can't check if tuple is created by the current
     * transaction.
     */
    if (!hslot->tuple)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("don't have a storage tuple in this context")));
 
    xmin = HeapTupleHeaderGetRawXmin(hslot->tuple->t_data);
 
    return TransactionIdIsCurrentTransactionId(xmin);
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), HeapTupleHeaderGetRawXmin(), TransactionIdIsCurrentTransactionId(), and TTS_EMPTY.

tts_heap_materialize()

static void tts_heap_materialize ( TupleTableSlot *  slot )

static

Definition at line 399 of file execTuples.c.

{
    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_FLAG_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);
}

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

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

tts_heap_release()

static void tts_heap_release ( TupleTableSlot *  slot )

static

Definition at line 322 of file execTuples.c.

{
}

tts_heap_store_tuple()

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

static

Definition at line 487 of file execTuples.c.

{
    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;
}

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

Referenced by ExecStoreHeapTuple().

tts_minimal_clear()

static void tts_minimal_clear ( TupleTableSlot *  slot )

static

Definition at line 526 of file execTuples.c.

{
    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;
}

References fb(), heap_free_minimal_tuple(), ItemPointerSetInvalid(), TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

Referenced by tts_minimal_store_tuple().

tts_minimal_copy_heap_tuple()

static HeapTuple tts_minimal_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 660 of file execTuples.c.

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
 
    if (!mslot->mintuple)
        tts_minimal_materialize(slot);
 
    return heap_tuple_from_minimal_tuple(mslot->mintuple);
}

References fb(), heap_tuple_from_minimal_tuple(), and tts_minimal_materialize().

tts_minimal_copy_minimal_tuple()

static MinimalTuple tts_minimal_copy_minimal_tuple ( TupleTableSlot *  slot, Size  extra  )

static

Definition at line 671 of file execTuples.c.

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
 
    if (!mslot->mintuple)
        tts_minimal_materialize(slot);
 
    return heap_copy_minimal_tuple(mslot->mintuple, extra);
}

References fb(), heap_copy_minimal_tuple(), and tts_minimal_materialize().

tts_minimal_copyslot()

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

static

Definition at line 636 of file execTuples.c.

{
    MemoryContext oldcontext;
    MinimalTuple mintuple;
 
    oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
    mintuple = ExecCopySlotMinimalTuple(srcslot);
    MemoryContextSwitchTo(oldcontext);
 
    ExecStoreMinimalTuple(mintuple, dstslot, true);
}

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

tts_minimal_get_minimal_tuple()

static MinimalTuple tts_minimal_get_minimal_tuple ( TupleTableSlot *  slot )

static

Definition at line 649 of file execTuples.c.

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
 
    if (!mslot->mintuple)
        tts_minimal_materialize(slot);
 
    return mslot->mintuple;
}

References fb(), and tts_minimal_materialize().

tts_minimal_getsomeattrs()

static void tts_minimal_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 544 of file execTuples.c.

{
    MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
 
    Assert(!TTS_EMPTY(slot));
 
    slot_deform_heap_tuple(slot, mslot->tuple, &mslot->off, natts, true);
}

References Assert, fb(), slot_deform_heap_tuple(), and TTS_EMPTY.

tts_minimal_getsysattr()

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

static

Definition at line 558 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("cannot retrieve a system column in this context")));
 
    return 0;                   /* silence compiler warnings */
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), and TTS_EMPTY.

tts_minimal_init()

static void tts_minimal_init ( TupleTableSlot *  slot )

static

Definition at line 509 of file execTuples.c.

{
    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;
}

References fb().

tts_minimal_is_current_xact_tuple()

static bool tts_minimal_is_current_xact_tuple ( TupleTableSlot *  slot )

static

Definition at line 575 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("don't have transaction information for this type of tuple")));
 
    return false;               /* silence compiler warnings */
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), and TTS_EMPTY.

tts_minimal_materialize()

static void tts_minimal_materialize ( TupleTableSlot *  slot )

static

Definition at line 587 of file execTuples.c.

{
    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,
                                                  0);
    }
    else
    {
        /*
         * The minimal tuple contained in this slot is not allocated in the
         * memory context of the given slot (else it would have
         * TTS_FLAG_SHOULDFREE set).  Copy the minimal tuple into the given
         * slot's memory context.
         */
        mslot->mintuple = heap_copy_minimal_tuple(mslot->mintuple, 0);
    }
 
    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);
}

References Assert, fb(), heap_copy_minimal_tuple(), heap_form_minimal_tuple(), MemoryContextSwitchTo(), MINIMAL_TUPLE_OFFSET, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

tts_minimal_release()

static void tts_minimal_release ( TupleTableSlot *  slot )

static

Definition at line 521 of file execTuples.c.

{
}

tts_minimal_store_tuple()

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

static

Definition at line 682 of file execTuples.c.

{
    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;
}

References Assert, fb(), MINIMAL_TUPLE_OFFSET, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, tts_minimal_clear(), TupleTableSlot::tts_nvalid, and TTS_SHOULDFREE.

Referenced by ExecForceStoreMinimalTuple(), and ExecStoreMinimalTuple().

tts_virtual_clear()

static void tts_virtual_clear ( TupleTableSlot *  slot )

static

Definition at line 108 of file execTuples.c.

{
    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);
}

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

Referenced by tts_virtual_copyslot().

tts_virtual_copy_heap_tuple()

static HeapTuple tts_virtual_copy_heap_tuple ( TupleTableSlot *  slot )

static

Definition at line 291 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    return heap_form_tuple(slot->tts_tupleDescriptor,
                           slot->tts_values,
                           slot->tts_isnull);
}

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

tts_virtual_copy_minimal_tuple()

static MinimalTuple tts_virtual_copy_minimal_tuple ( TupleTableSlot *  slot, Size  extra  )

static

Definition at line 301 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    return heap_form_minimal_tuple(slot->tts_tupleDescriptor,
                                   slot->tts_values,
                                   slot->tts_isnull,
                                   extra);
}

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

tts_virtual_copyslot()

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

static

Definition at line 269 of file execTuples.c.

{
    TupleDesc   srcdesc = srcslot->tts_tupleDescriptor;
 
    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);
}

References fb(), slot_getallattrs(), TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_values, tts_virtual_clear(), and tts_virtual_materialize().

tts_virtual_getsomeattrs()

static void tts_virtual_getsomeattrs ( TupleTableSlot *  slot, int  natts  )

static

Definition at line 130 of file execTuples.c.

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

References elog, and ERROR.

tts_virtual_getsysattr()

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

static

Definition at line 141 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("cannot retrieve a system column in this context")));
 
    return 0;                   /* silence compiler warnings */
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), and TTS_EMPTY.

tts_virtual_init()

static void tts_virtual_init ( TupleTableSlot *  slot )

static

Definition at line 98 of file execTuples.c.

{
}

tts_virtual_is_current_xact_tuple()

static bool tts_virtual_is_current_xact_tuple ( TupleTableSlot *  slot )

static

Definition at line 157 of file execTuples.c.

{
    Assert(!TTS_EMPTY(slot));
 
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("don't have transaction information for this type of tuple")));
 
    return false;               /* silence compiler warnings */
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), and TTS_EMPTY.

tts_virtual_materialize()

static void tts_virtual_materialize ( TupleTableSlot *  slot )

static

Definition at line 176 of file execTuples.c.

{
    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++)
    {
        CompactAttribute *att = TupleDescCompactAttr(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_nominal_alignby(sz, att->attalignby);
            sz += EOH_get_flat_size(DatumGetEOHP(val));
        }
        else
        {
            sz = att_nominal_alignby(sz, att->attalignby);
            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++)
    {
        CompactAttribute *att = TupleDescCompactAttr(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_nominal_alignby(data,
                                                att->attalignby);
            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_nominal_alignby(data, att->attalignby);
            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;
        }
    }
}

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

Referenced by tts_virtual_copyslot().

tts_virtual_release()

static void tts_virtual_release ( TupleTableSlot *  slot )

static

Definition at line 103 of file execTuples.c.

{
}

TupleDescGetAttInMetadata()

AttInMetadata * TupleDescGetAttInMetadata

(

TupleDesc

tupdesc

)

Definition at line 2356 of file execTuples.c.

{
    int         natts = tupdesc->natts;
    int         i;
    Oid         atttypeid;
    Oid         attinfuncid;
    FmgrInfo   *attinfuncinfo;
    Oid        *attioparams;
    int32      *atttypmods;
    AttInMetadata *attinmeta;
 
    attinmeta = palloc_object(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;
}

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

Referenced by bt_metap(), bt_multi_page_stats(), bt_page_stats_internal(), build_pgstattuple_type(), connectby_text(), connectby_text_serial(), create_foreign_modify(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), hash_page_items(), libpqrcv_processTuples(), materializeQueryResult(), materializeResult(), pg_get_keywords(), pg_get_multixact_members(), 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().

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,
    .is_current_xact_tuple = tts_buffer_is_current_xact_tuple,
    .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 87 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,
    .is_current_xact_tuple = tts_heap_is_current_xact_tuple,
    .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 85 of file execTuples.c.

Referenced by CatalogIndexInsert(), CheckOpSlotCompatibility(), compute_expr_stats(), compute_index_stats(), copyTemplateDependencies(), DefineTSConfiguration(), EnumValuesCreate(), ExecInitForeignScan(), ExecuteCallStmt(), heapam_index_validate_scan(), init_tuple_slot(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), 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,
    .is_current_xact_tuple = tts_minimal_is_current_xact_tuple,
    .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 86 of file execTuples.c.

Referenced by afterTriggerInvokeEvents(), build_pertrans_for_aggref(), BuildTupleHashTable(), check_pub_dead_tuple_retention(), check_publications(), check_publications_origin_sequences(), check_publications_origin_tables(), copy_sequences(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMemoize(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), find_hash_columns(), gather_merge_setup(), hashagg_recompile_expressions(), hypothetical_dense_rank_final(), init_execution_state(), ordered_set_startup(), RunFromStore(), slot_compile_deform(), and validate_remote_info().

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,
    .is_current_xact_tuple = tts_virtual_is_current_xact_tuple,
    .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 84 of file execTuples.c.

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