explain_dr.c File Reference

#include "postgres.h"
#include "commands/explain.h"
#include "commands/explain_dr.h"
#include "commands/explain_state.h"
#include "libpq/pqformat.h"
#include "libpq/protocol.h"
#include "utils/lsyscache.h"

Include dependency graph for explain_dr.c:

Go to the source code of this file.

Data Structures
struct	SerializeDestReceiver

Typedefs
typedef struct SerializeDestReceiver	SerializeDestReceiver

Functions
static void	serialize_prepare_info (SerializeDestReceiver *receiver, TupleDesc typeinfo, int nattrs)
static bool	serializeAnalyzeReceive (TupleTableSlot *slot, DestReceiver *self)
static void	serializeAnalyzeStartup (DestReceiver *self, int operation, TupleDesc typeinfo)
static void	serializeAnalyzeShutdown (DestReceiver *self)
static void	serializeAnalyzeDestroy (DestReceiver *self)
DestReceiver *	CreateExplainSerializeDestReceiver (ExplainState *es)
SerializeMetrics	GetSerializationMetrics (DestReceiver *dest)

Typedef Documentation

SerializeDestReceiver

typedef struct SerializeDestReceiver SerializeDestReceiver

Function Documentation

CreateExplainSerializeDestReceiver()

DestReceiver * CreateExplainSerializeDestReceiver

(

ExplainState *

es

)

Definition at line 274 of file explain_dr.c.

{
    SerializeDestReceiver *self;
 
    self = (SerializeDestReceiver *) palloc0(sizeof(SerializeDestReceiver));
 
    self->pub.receiveSlot = serializeAnalyzeReceive;
    self->pub.rStartup = serializeAnalyzeStartup;
    self->pub.rShutdown = serializeAnalyzeShutdown;
    self->pub.rDestroy = serializeAnalyzeDestroy;
    self->pub.mydest = DestExplainSerialize;
 
    self->es = es;
 
    return (DestReceiver *) self;
}

References DestExplainSerialize, SerializeDestReceiver::es, _DestReceiver::mydest, palloc0(), SerializeDestReceiver::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, _DestReceiver::rStartup, serializeAnalyzeDestroy(), serializeAnalyzeReceive(), serializeAnalyzeShutdown(), and serializeAnalyzeStartup().

Referenced by CreateDestReceiver(), and ExplainOnePlan().

GetSerializationMetrics()

SerializeMetrics GetSerializationMetrics

(

DestReceiver *

dest

)

Definition at line 299 of file explain_dr.c.

{
    SerializeMetrics empty;
 
    if (dest->mydest == DestExplainSerialize)
        return ((SerializeDestReceiver *) dest)->metrics;
 
    memset(&empty, 0, sizeof(SerializeMetrics));
    INSTR_TIME_SET_ZERO(empty.timeSpent);
 
    return empty;
}

References generate_unaccent_rules::dest, DestExplainSerialize, INSTR_TIME_SET_ZERO, and SerializeMetrics::timeSpent.

Referenced by ExplainOnePlan().

serialize_prepare_info()

static void serialize_prepare_info ( SerializeDestReceiver *  receiver, TupleDesc  typeinfo, int  nattrs  )

static

Definition at line 52 of file explain_dr.c.

{
    /* get rid of any old data */
    if (receiver->finfos)
        pfree(receiver->finfos);
    receiver->finfos = NULL;
 
    receiver->attrinfo = typeinfo;
    receiver->nattrs = nattrs;
    if (nattrs <= 0)
        return;
 
    receiver->finfos = (FmgrInfo *) palloc0(nattrs * sizeof(FmgrInfo));
 
    for (int i = 0; i < nattrs; i++)
    {
        FmgrInfo   *finfo = receiver->finfos + i;
        Form_pg_attribute attr = TupleDescAttr(typeinfo, i);
        Oid         typoutput;
        Oid         typsend;
        bool        typisvarlena;
 
        if (receiver->format == 0)
        {
            /* wire protocol format text */
            getTypeOutputInfo(attr->atttypid,
                              &typoutput,
                              &typisvarlena);
            fmgr_info(typoutput, finfo);
        }
        else if (receiver->format == 1)
        {
            /* wire protocol format binary */
            getTypeBinaryOutputInfo(attr->atttypid,
                                    &typsend,
                                    &typisvarlena);
            fmgr_info(typsend, finfo);
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unsupported format code: %d", receiver->format)));
    }
}

References SerializeDestReceiver::attrinfo, ereport, errcode(), errmsg(), ERROR, SerializeDestReceiver::finfos, fmgr_info(), SerializeDestReceiver::format, getTypeBinaryOutputInfo(), getTypeOutputInfo(), i, SerializeDestReceiver::nattrs, palloc0(), pfree(), and TupleDescAttr().

Referenced by serializeAnalyzeReceive().

serializeAnalyzeDestroy()

static void serializeAnalyzeDestroy ( DestReceiver *  self )

static

Definition at line 265 of file explain_dr.c.

{
    pfree(self);
}

References pfree().

Referenced by CreateExplainSerializeDestReceiver().

serializeAnalyzeReceive()

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

static

Definition at line 105 of file explain_dr.c.

{
    TupleDesc   typeinfo = slot->tts_tupleDescriptor;
    SerializeDestReceiver *myState = (SerializeDestReceiver *) self;
    MemoryContext oldcontext;
    StringInfo  buf = &myState->buf;
    int         natts = typeinfo->natts;
    instr_time  start,
                end;
    BufferUsage instr_start;
 
    /* only measure time, buffers if requested */
    if (myState->es->timing)
        INSTR_TIME_SET_CURRENT(start);
    if (myState->es->buffers)
        instr_start = pgBufferUsage;
 
    /* Set or update my derived attribute info, if needed */
    if (myState->attrinfo != typeinfo || myState->nattrs != natts)
        serialize_prepare_info(myState, typeinfo, natts);
 
    /* Make sure the tuple is fully deconstructed */
    slot_getallattrs(slot);
 
    /* Switch into per-row context so we can recover memory below */
    oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
 
    /*
     * Prepare a DataRow message (note buffer is in per-query context)
     *
     * Note that we fill a StringInfo buffer the same as printtup() does, so
     * as to capture the costs of manipulating the strings accurately.
     */
    pq_beginmessage_reuse(buf, PqMsg_DataRow);
 
    pq_sendint16(buf, natts);
 
    /*
     * send the attributes of this tuple
     */
    for (int i = 0; i < natts; i++)
    {
        FmgrInfo   *finfo = myState->finfos + i;
        Datum       attr = slot->tts_values[i];
 
        if (slot->tts_isnull[i])
        {
            pq_sendint32(buf, -1);
            continue;
        }
 
        if (myState->format == 0)
        {
            /* Text output */
            char       *outputstr;
 
            outputstr = OutputFunctionCall(finfo, attr);
            pq_sendcountedtext(buf, outputstr, strlen(outputstr));
        }
        else
        {
            /* Binary output */
            bytea      *outputbytes;
 
            outputbytes = SendFunctionCall(finfo, attr);
            pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
            pq_sendbytes(buf, VARDATA(outputbytes),
                         VARSIZE(outputbytes) - VARHDRSZ);
        }
    }
 
    /*
     * We mustn't call pq_endmessage_reuse(), since that would actually send
     * the data to the client.  Just count the data, instead.  We can leave
     * the buffer alone; it'll be reset on the next iteration (as would also
     * happen in printtup()).
     */
    myState->metrics.bytesSent += buf->len;
 
    /* Return to caller's context, and flush row's temporary memory */
    MemoryContextSwitchTo(oldcontext);
    MemoryContextReset(myState->tmpcontext);
 
    /* Update timing data */
    if (myState->es->timing)
    {
        INSTR_TIME_SET_CURRENT(end);
        INSTR_TIME_ACCUM_DIFF(myState->metrics.timeSpent, end, start);
    }
 
    /* Update buffer metrics */
    if (myState->es->buffers)
        BufferUsageAccumDiff(&myState->metrics.bufferUsage,
                             &pgBufferUsage,
                             &instr_start);
 
    return true;
}

References SerializeDestReceiver::attrinfo, SerializeDestReceiver::buf, buf, ExplainState::buffers, SerializeMetrics::bufferUsage, BufferUsageAccumDiff(), SerializeMetrics::bytesSent, SerializeDestReceiver::es, SerializeDestReceiver::finfos, SerializeDestReceiver::format, i, INSTR_TIME_ACCUM_DIFF, INSTR_TIME_SET_CURRENT, MemoryContextReset(), MemoryContextSwitchTo(), SerializeDestReceiver::metrics, SerializeDestReceiver::nattrs, TupleDescData::natts, OutputFunctionCall(), pgBufferUsage, pq_beginmessage_reuse(), pq_sendbytes(), pq_sendcountedtext(), pq_sendint16(), pq_sendint32(), PqMsg_DataRow, SendFunctionCall(), serialize_prepare_info(), slot_getallattrs(), start, SerializeMetrics::timeSpent, ExplainState::timing, SerializeDestReceiver::tmpcontext, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by CreateExplainSerializeDestReceiver().

serializeAnalyzeShutdown()

static void serializeAnalyzeShutdown ( DestReceiver *  self )

static

Definition at line 244 of file explain_dr.c.

{
    SerializeDestReceiver *receiver = (SerializeDestReceiver *) self;
 
    if (receiver->finfos)
        pfree(receiver->finfos);
    receiver->finfos = NULL;
 
    if (receiver->buf.data)
        pfree(receiver->buf.data);
    receiver->buf.data = NULL;
 
    if (receiver->tmpcontext)
        MemoryContextDelete(receiver->tmpcontext);
    receiver->tmpcontext = NULL;
}

References SerializeDestReceiver::buf, StringInfoData::data, SerializeDestReceiver::finfos, MemoryContextDelete(), pfree(), and SerializeDestReceiver::tmpcontext.

Referenced by CreateExplainSerializeDestReceiver().

serializeAnalyzeStartup()

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

static

Definition at line 208 of file explain_dr.c.

{
    SerializeDestReceiver *receiver = (SerializeDestReceiver *) self;
 
    Assert(receiver->es != NULL);
 
    switch (receiver->es->serialize)
    {
        case EXPLAIN_SERIALIZE_NONE:
            Assert(false);
            break;
        case EXPLAIN_SERIALIZE_TEXT:
            receiver->format = 0;   /* wire protocol format text */
            break;
        case EXPLAIN_SERIALIZE_BINARY:
            receiver->format = 1;   /* wire protocol format binary */
            break;
    }
 
    /* Create per-row temporary memory context */
    receiver->tmpcontext = AllocSetContextCreate(CurrentMemoryContext,
                                                 "SerializeTupleReceive",
                                                 ALLOCSET_DEFAULT_SIZES);
 
    /* The output buffer is re-used across rows, as in printtup.c */
    initStringInfo(&receiver->buf);
 
    /* Initialize results counters */
    memset(&receiver->metrics, 0, sizeof(SerializeMetrics));
    INSTR_TIME_SET_ZERO(receiver->metrics.timeSpent);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), SerializeDestReceiver::buf, CurrentMemoryContext, SerializeDestReceiver::es, EXPLAIN_SERIALIZE_BINARY, EXPLAIN_SERIALIZE_NONE, EXPLAIN_SERIALIZE_TEXT, SerializeDestReceiver::format, initStringInfo(), INSTR_TIME_SET_ZERO, SerializeDestReceiver::metrics, ExplainState::serialize, SerializeMetrics::timeSpent, and SerializeDestReceiver::tmpcontext.

Referenced by CreateExplainSerializeDestReceiver().