tstoreReceiver.c File Reference

#include "postgres.h"
#include "access/detoast.h"
#include "access/tupconvert.h"
#include "executor/tstoreReceiver.h"

Include dependency graph for tstoreReceiver.c:

Go to the source code of this file.

Data Structures
struct	TStoreState

Functions
static bool	tstoreReceiveSlot_notoast (TupleTableSlot *slot, DestReceiver *self)
static bool	tstoreReceiveSlot_detoast (TupleTableSlot *slot, DestReceiver *self)
static bool	tstoreReceiveSlot_tupmap (TupleTableSlot *slot, DestReceiver *self)
static void	tstoreStartupReceiver (DestReceiver *self, int operation, TupleDesc typeinfo)
static void	tstoreShutdownReceiver (DestReceiver *self)
static void	tstoreDestroyReceiver (DestReceiver *self)
DestReceiver *	CreateTuplestoreDestReceiver (void)
void	SetTuplestoreDestReceiverParams (DestReceiver *self, Tuplestorestate *tStore, MemoryContext tContext, bool detoast, TupleDesc target_tupdesc, const char *map_failure_msg)

Function Documentation

CreateTuplestoreDestReceiver()

DestReceiver * CreateTuplestoreDestReceiver

(

void

)

Definition at line 238 of file tstoreReceiver.c.

{
    TStoreState *self = (TStoreState *) palloc0(sizeof(TStoreState));
 
    self->pub.receiveSlot = tstoreReceiveSlot_notoast;  /* might change */
    self->pub.rStartup = tstoreStartupReceiver;
    self->pub.rShutdown = tstoreShutdownReceiver;
    self->pub.rDestroy = tstoreDestroyReceiver;
    self->pub.mydest = DestTuplestore;
 
    /* private fields will be set by SetTuplestoreDestReceiverParams */
 
    return (DestReceiver *) self;
}

References DestTuplestore, _DestReceiver::mydest, palloc0(), TStoreState::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, _DestReceiver::rStartup, tstoreDestroyReceiver(), tstoreReceiveSlot_notoast(), tstoreShutdownReceiver(), and tstoreStartupReceiver().

Referenced by CreateDestReceiver().

SetTuplestoreDestReceiverParams()

void SetTuplestoreDestReceiverParams	(	DestReceiver *	self,
		Tuplestorestate *	tStore,
		MemoryContext	tContext,
		bool	detoast,
		TupleDesc	target_tupdesc,
		const char *	map_failure_msg
	)

Definition at line 266 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
 
    Assert(!(detoast && target_tupdesc));
 
    Assert(myState->pub.mydest == DestTuplestore);
    myState->tstore = tStore;
    myState->cxt = tContext;
    myState->detoast = detoast;
    myState->target_tupdesc = target_tupdesc;
    myState->map_failure_msg = map_failure_msg;
}

References Assert(), TStoreState::cxt, DestTuplestore, TStoreState::detoast, TStoreState::map_failure_msg, _DestReceiver::mydest, TStoreState::pub, TStoreState::target_tupdesc, and TStoreState::tstore.

Referenced by exec_stmt_return_query(), FillPortalStore(), and PersistHoldablePortal().

tstoreDestroyReceiver()

static void tstoreDestroyReceiver ( DestReceiver *  self )

static

Definition at line 229 of file tstoreReceiver.c.

{
    pfree(self);
}

References pfree().

Referenced by CreateTuplestoreDestReceiver().

tstoreReceiveSlot_detoast()

static bool tstoreReceiveSlot_detoast ( TupleTableSlot *  slot, DestReceiver *  self  )

static

Definition at line 136 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
    TupleDesc   typeinfo = slot->tts_tupleDescriptor;
    int         natts = typeinfo->natts;
    int         nfree;
    int         i;
    MemoryContext oldcxt;
 
    /* Make sure the tuple is fully deconstructed */
    slot_getallattrs(slot);
 
    /*
     * Fetch back any out-of-line datums.  We build the new datums array in
     * myState->outvalues[] (but we can re-use the slot's isnull array). Also,
     * remember the fetched values to free afterwards.
     */
    nfree = 0;
    for (i = 0; i < natts; i++)
    {
        Datum       val = slot->tts_values[i];
        CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
 
        if (!attr->attisdropped && attr->attlen == -1 && !slot->tts_isnull[i])
        {
            if (VARATT_IS_EXTERNAL(DatumGetPointer(val)))
            {
                val = PointerGetDatum(detoast_external_attr((struct varlena *)
                                                            DatumGetPointer(val)));
                myState->tofree[nfree++] = val;
            }
        }
 
        myState->outvalues[i] = val;
    }
 
    /*
     * Push the modified tuple into the tuplestore.
     */
    oldcxt = MemoryContextSwitchTo(myState->cxt);
    tuplestore_putvalues(myState->tstore, typeinfo,
                         myState->outvalues, slot->tts_isnull);
    MemoryContextSwitchTo(oldcxt);
 
    /* And release any temporary detoasted values */
    for (i = 0; i < nfree; i++)
        pfree(DatumGetPointer(myState->tofree[i]));
 
    return true;
}

References CompactAttribute::attisdropped, CompactAttribute::attlen, TStoreState::cxt, DatumGetPointer(), detoast_external_attr(), i, MemoryContextSwitchTo(), TupleDescData::natts, TStoreState::outvalues, pfree(), PointerGetDatum(), slot_getallattrs(), TStoreState::tofree, TStoreState::tstore, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescCompactAttr(), tuplestore_putvalues(), val, and VARATT_IS_EXTERNAL.

Referenced by tstoreStartupReceiver().

tstoreReceiveSlot_notoast()

static bool tstoreReceiveSlot_notoast ( TupleTableSlot *  slot, DestReceiver *  self  )

static

Definition at line 122 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
 
    tuplestore_puttupleslot(myState->tstore, slot);
 
    return true;
}

References TStoreState::tstore, and tuplestore_puttupleslot().

Referenced by CreateTuplestoreDestReceiver(), and tstoreStartupReceiver().

tstoreReceiveSlot_tupmap()

static bool tstoreReceiveSlot_tupmap ( TupleTableSlot *  slot, DestReceiver *  self  )

static

Definition at line 192 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
 
    execute_attr_map_slot(myState->tupmap->attrMap, slot, myState->mapslot);
    tuplestore_puttupleslot(myState->tstore, myState->mapslot);
 
    return true;
}

References TupleConversionMap::attrMap, execute_attr_map_slot(), TStoreState::mapslot, TStoreState::tstore, tuplestore_puttupleslot(), and TStoreState::tupmap.

Referenced by tstoreStartupReceiver().

tstoreShutdownReceiver()

static void tstoreShutdownReceiver ( DestReceiver *  self )

static

Definition at line 206 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
 
    /* Release workspace if any */
    if (myState->outvalues)
        pfree(myState->outvalues);
    myState->outvalues = NULL;
    if (myState->tofree)
        pfree(myState->tofree);
    myState->tofree = NULL;
    if (myState->tupmap)
        free_conversion_map(myState->tupmap);
    myState->tupmap = NULL;
    if (myState->mapslot)
        ExecDropSingleTupleTableSlot(myState->mapslot);
    myState->mapslot = NULL;
}

References ExecDropSingleTupleTableSlot(), free_conversion_map(), TStoreState::mapslot, TStoreState::outvalues, pfree(), TStoreState::tofree, and TStoreState::tupmap.

Referenced by CreateTuplestoreDestReceiver().

tstoreStartupReceiver()

static void tstoreStartupReceiver ( DestReceiver *  self, int  operation, TupleDesc  typeinfo  )

static

Definition at line 56 of file tstoreReceiver.c.

{
    TStoreState *myState = (TStoreState *) self;
    bool        needtoast = false;
    int         natts = typeinfo->natts;
    int         i;
 
    /* Check if any columns require detoast work */
    if (myState->detoast)
    {
        for (i = 0; i < natts; i++)
        {
            CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
 
            if (attr->attisdropped)
                continue;
            if (attr->attlen == -1)
            {
                needtoast = true;
                break;
            }
        }
    }
 
    /* Check if tuple conversion is needed */
    if (myState->target_tupdesc)
        myState->tupmap = convert_tuples_by_position(typeinfo,
                                                     myState->target_tupdesc,
                                                     myState->map_failure_msg);
    else
        myState->tupmap = NULL;
 
    /* Set up appropriate callback */
    if (needtoast)
    {
        Assert(!myState->tupmap);
        myState->pub.receiveSlot = tstoreReceiveSlot_detoast;
        /* Create workspace */
        myState->outvalues = (Datum *)
            MemoryContextAlloc(myState->cxt, natts * sizeof(Datum));
        myState->tofree = (Datum *)
            MemoryContextAlloc(myState->cxt, natts * sizeof(Datum));
        myState->mapslot = NULL;
    }
    else if (myState->tupmap)
    {
        myState->pub.receiveSlot = tstoreReceiveSlot_tupmap;
        myState->outvalues = NULL;
        myState->tofree = NULL;
        myState->mapslot = MakeSingleTupleTableSlot(myState->target_tupdesc,
                                                    &TTSOpsVirtual);
    }
    else
    {
        myState->pub.receiveSlot = tstoreReceiveSlot_notoast;
        myState->outvalues = NULL;
        myState->tofree = NULL;
        myState->mapslot = NULL;
    }
}

References Assert(), CompactAttribute::attisdropped, CompactAttribute::attlen, convert_tuples_by_position(), TStoreState::cxt, TStoreState::detoast, i, MakeSingleTupleTableSlot(), TStoreState::map_failure_msg, TStoreState::mapslot, MemoryContextAlloc(), TupleDescData::natts, TStoreState::outvalues, TStoreState::pub, _DestReceiver::receiveSlot, TStoreState::target_tupdesc, TStoreState::tofree, tstoreReceiveSlot_detoast(), tstoreReceiveSlot_notoast(), tstoreReceiveSlot_tupmap(), TTSOpsVirtual, TupleDescCompactAttr(), and TStoreState::tupmap.

Referenced by CreateTuplestoreDestReceiver().