/*-------------------------------------------------------------------------

 *

 * printtup.c

 *    Routines to print out tuples to the destination (both frontend

 *    clients and standalone backends are supported here).

 *

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * IDENTIFICATION

 *    src/backend/access/common/printtup.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/printtup.h"

#include "libpq/pqformat.h"

#include "libpq/protocol.h"

#include "tcop/pquery.h"

#include "utils/lsyscache.h"

#include "utils/memdebug.h"

#include "utils/memutils.h"

static void printtup_startup(DestReceiver *self, int operation,

               TupleDesc typeinfo);

static bool printtup(TupleTableSlot *slot, DestReceiver *self);

static void printtup_shutdown(DestReceiver *self);

static void printtup_destroy(DestReceiver *self);

/* ----------------------------------------------------------------

 *    printtup / debugtup support

 * ----------------------------------------------------------------

 */

/* ----------------

 *    Private state for a printtup destination object

 *

 * NOTE: finfo is the lookup info for either typoutput or typsend, whichever

 * we are using for this column.

 * ----------------

 */

typedef struct

{               /* Per-attribute information */

  Oid     typoutput;    /* Oid for the type's text output fn */

  Oid     typsend;    /* Oid for the type's binary output fn */

  bool    typisvarlena; /* is it varlena (ie possibly toastable)? */

  int16   format;     /* format code for this column */

  FmgrInfo  finfo;      /* Precomputed call info for output fn */

} PrinttupAttrInfo;

typedef struct

{

  DestReceiver pub;     /* publicly-known function pointers */

  Portal    portal;     /* the Portal we are printing from */

  bool    sendDescrip;  /* send RowDescription at startup? */

  TupleDesc attrinfo;   /* The attr info we are set up for */

  int     nattrs;

  PrinttupAttrInfo *myinfo; /* Cached info about each attr */

  StringInfoData buf;     /* output buffer (*not* in tmpcontext) */

  MemoryContext tmpcontext; /* Memory context for per-row workspace */

} DR_printtup;

/* ----------------

 *    Initialize: create a DestReceiver for printtup

 * ----------------

 */

DestReceiver *

printtup_create_DR(CommandDest dest)

{

  DR_printtup *self = (DR_printtup *) palloc0(sizeof(DR_printtup));

  self->pub.receiveSlot = printtup; /* might get changed later */

  self->pub.rStartup = printtup_startup;

  self->pub.rShutdown = printtup_shutdown;

  self->pub.rDestroy = printtup_destroy;

  self->pub.mydest = dest;

  /*

   * Send T message automatically if DestRemote, but not if

   * DestRemoteExecute

   */

  self->sendDescrip = (dest == DestRemote);

  self->attrinfo = NULL;

  self->nattrs = 0;

  self->myinfo = NULL;

  self->buf.data = NULL;

  self->tmpcontext = NULL;

  return (DestReceiver *) self;

}

/*

 * Set parameters for a DestRemote (or DestRemoteExecute) receiver

 */

void

SetRemoteDestReceiverParams(DestReceiver *self, Portal portal)

{

  DR_printtup *myState = (DR_printtup *) self;

  Assert(myState->pub.mydest == DestRemote ||

       myState->pub.mydest == DestRemoteExecute);

  myState->portal = portal;

}

static void

printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)

{

  DR_printtup *myState = (DR_printtup *) self;

  Portal    portal = myState->portal;

  /*

   * Create I/O buffer to be used for all messages.  This cannot be inside

   * tmpcontext, since we want to re-use it across rows.

   */

  initStringInfo(&myState->buf);

  /*

   * Create a temporary memory context that we can reset once per row to

   * recover palloc'd memory.  This avoids any problems with leaks inside

   * datatype output routines, and should be faster than retail pfree's

   * anyway.

   */

  myState->tmpcontext = AllocSetContextCreate(CurrentMemoryContext,

                        "printtup",

                        ALLOCSET_DEFAULT_SIZES);

  /*

   * If we are supposed to emit row descriptions, then send the tuple

   * descriptor of the tuples.

   */

  if (myState->sendDescrip)

    SendRowDescriptionMessage(&myState->buf,

                  typeinfo,

                  FetchPortalTargetList(portal),

                  portal->formats);

  /* ----------------

   * We could set up the derived attr info at this time, but we postpone it

   * until the first call of printtup, for 2 reasons:

   * 1. We don't waste time (compared to the old way) if there are no

   *    tuples at all to output.

   * 2. Checking in printtup allows us to handle the case that the tuples

   *    change type midway through (although this probably can't happen in

   *    the current executor).

   * ----------------

   */

}

/*

 * SendRowDescriptionMessage --- send a RowDescription message to the frontend

 *

 * Notes: the TupleDesc has typically been manufactured by ExecTypeFromTL()

 * or some similar function; it does not contain a full set of fields.

 * The targetlist will be NIL when executing a utility function that does

 * not have a plan.  If the targetlist isn't NIL then it is a Query node's

 * targetlist; it is up to us to ignore resjunk columns in it.  The formats[]

 * array pointer might be NULL (if we are doing Describe on a prepared stmt);

 * send zeroes for the format codes in that case.

 */

void

SendRowDescriptionMessage(StringInfo buf, TupleDesc typeinfo,

              List *targetlist, int16 *formats)

{

  int     natts = typeinfo->natts;

  int     i;

  ListCell   *tlist_item = list_head(targetlist);

  /* tuple descriptor message type */

  pq_beginmessage_reuse(buf, PqMsg_RowDescription);

  /* # of attrs in tuples */

  pq_sendint16(buf, natts);

  /*

   * Preallocate memory for the entire message to be sent. That allows to

   * use the significantly faster inline pqformat.h functions and to avoid

   * reallocations.

   *

   * Have to overestimate the size of the column-names, to account for

   * character set overhead.

   */

  enlargeStringInfo(buf, (NAMEDATALEN * MAX_CONVERSION_GROWTH /* attname */

              + sizeof(Oid) /* resorigtbl */

              + sizeof(AttrNumber)  /* resorigcol */

              + sizeof(Oid) /* atttypid */

              + sizeof(int16) /* attlen */

              + sizeof(int32) /* attypmod */

              + sizeof(int16) /* format */

              ) * natts);

  for (i = 0; i < natts; ++i)

  {

    Form_pg_attribute att = TupleDescAttr(typeinfo, i);

    Oid     atttypid = att->atttypid;

    int32   atttypmod = att->atttypmod;

    Oid     resorigtbl;

    AttrNumber  resorigcol;

    int16   format;

    /*

     * If column is a domain, send the base type and typmod instead.

     * Lookup before sending any ints, for efficiency.

     */

    atttypid = getBaseTypeAndTypmod(atttypid, &atttypmod);

    /* Do we have a non-resjunk tlist item? */

    while (tlist_item &&

         ((TargetEntry *) lfirst(tlist_item))->resjunk)

      tlist_item = lnext(targetlist, tlist_item);

    if (tlist_item)

    {

      TargetEntry *tle = (TargetEntry *) lfirst(tlist_item);

      resorigtbl = tle->resorigtbl;

      resorigcol = tle->resorigcol;

      tlist_item = lnext(targetlist, tlist_item);

    }

    else

    {

      /* No info available, so send zeroes */

      resorigtbl = 0;

      resorigcol = 0;

    }

    if (formats)

      format = formats[i];

    else

      format = 0;

    pq_writestring(buf, NameStr(att->attname));

    pq_writeint32(buf, resorigtbl);

    pq_writeint16(buf, resorigcol);

    pq_writeint32(buf, atttypid);

    pq_writeint16(buf, att->attlen);

    pq_writeint32(buf, atttypmod);

    pq_writeint16(buf, format);

  }

  pq_endmessage_reuse(buf);

}

/*

 * Get the lookup info that printtup() needs

 */

static void

printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)

{

  int16    *formats = myState->portal->formats;

  int     i;

  /* get rid of any old data */

  if (myState->myinfo)

    pfree(myState->myinfo);

  myState->myinfo = NULL;

  myState->attrinfo = typeinfo;

  myState->nattrs = numAttrs;

  if (numAttrs <= 0)

    return;

  myState->myinfo = (PrinttupAttrInfo *)

    palloc0(numAttrs * sizeof(PrinttupAttrInfo));

  for (i = 0; i < numAttrs; i++)

  {

    PrinttupAttrInfo *thisState = myState->myinfo + i;

    int16   format = (formats ? formats[i] : 0);

    Form_pg_attribute attr = TupleDescAttr(typeinfo, i);

    thisState->format = format;

    if (format == 0)

    {

      getTypeOutputInfo(attr->atttypid,

                &thisState->typoutput,

                &thisState->typisvarlena);

      fmgr_info(thisState->typoutput, &thisState->finfo);

    }

    else if (format == 1)

    {

      getTypeBinaryOutputInfo(attr->atttypid,

                  &thisState->typsend,

                  &thisState->typisvarlena);

      fmgr_info(thisState->typsend, &thisState->finfo);

    }

    else

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

           errmsg("unsupported format code: %d", format)));

  }

}

/* ----------------

 *    printtup --- send a tuple to the client

 *

 * Note: if you change this function, see also serializeAnalyzeReceive

 * in explain.c, which is meant to replicate the computations done here.

 * ----------------

 */

static bool

printtup(TupleTableSlot *slot, DestReceiver *self)

{

  TupleDesc typeinfo = slot->tts_tupleDescriptor;

  DR_printtup *myState = (DR_printtup *) self;

  MemoryContext oldcontext;

  StringInfo  buf = &myState->buf;

  int     natts = typeinfo->natts;

  int     i;

  /* Set or update my derived attribute info, if needed */

  if (myState->attrinfo != typeinfo || myState->nattrs != natts)

    printtup_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)

   */

  pq_beginmessage_reuse(buf, PqMsg_DataRow);

  pq_sendint16(buf, natts);

  /*

   * send the attributes of this tuple

   */

  for (i = 0; i < natts; ++i)

  {

    PrinttupAttrInfo *thisState = myState->myinfo + i;

    Datum   attr = slot->tts_values[i];

    if (slot->tts_isnull[i])

    {

      pq_sendint32(buf, -1);

      continue;

    }

    /*

     * Here we catch undefined bytes in datums that are returned to the

     * client without hitting disk; see comments at the related check in

     * PageAddItem().  This test is most useful for uncompressed,

     * non-external datums, but we're quite likely to see such here when

     * testing new C functions.

     */

    if (thisState->typisvarlena)

      VALGRIND_CHECK_MEM_IS_DEFINED(DatumGetPointer(attr),

                      VARSIZE_ANY(attr));

    if (thisState->format == 0)

    {

      /* Text output */

      char     *outputstr;

      outputstr = OutputFunctionCall(&thisState->finfo, attr);

      pq_sendcountedtext(buf, outputstr, strlen(outputstr));

    }

    else

    {

      /* Binary output */

      bytea    *outputbytes;

      outputbytes = SendFunctionCall(&thisState->finfo, attr);

      pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);

      pq_sendbytes(buf, VARDATA(outputbytes),

             VARSIZE(outputbytes) - VARHDRSZ);

    }

  }

  pq_endmessage_reuse(buf);

  /* Return to caller's context, and flush row's temporary memory */

  MemoryContextSwitchTo(oldcontext);

  MemoryContextReset(myState->tmpcontext);

  return true;

}

/* ----------------

 *    printtup_shutdown

 * ----------------

 */

static void

printtup_shutdown(DestReceiver *self)

{

  DR_printtup *myState = (DR_printtup *) self;

  if (myState->myinfo)

    pfree(myState->myinfo);

  myState->myinfo = NULL;

  myState->attrinfo = NULL;

  if (myState->buf.data)

    pfree(myState->buf.data);

  myState->buf.data = NULL;

  if (myState->tmpcontext)

    MemoryContextDelete(myState->tmpcontext);

  myState->tmpcontext = NULL;

}

/* ----------------

 *    printtup_destroy

 * ----------------

 */

static void

printtup_destroy(DestReceiver *self)

{

  pfree(self);

}

/* ----------------

 *    printatt

 * ----------------

 */

static void

printatt(unsigned attributeId,

     Form_pg_attribute attributeP,

     char *value)

{

  printf("\t%2d: %s%s%s%s\t(typeid = %u, len = %d, typmod = %d, byval = %c)\n",

       attributeId,

       NameStr(attributeP->attname),

       value != NULL ? " = \"" : "",

       value != NULL ? value : "",

       value != NULL ? "\"" : "",

       (unsigned int) (attributeP->atttypid),

       attributeP->attlen,

       attributeP->atttypmod,

       attributeP->attbyval ? 't' : 'f');

}

/* ----------------

 *    debugStartup - prepare to print tuples for an interactive backend

 * ----------------

 */

void

debugStartup(DestReceiver *self, int operation, TupleDesc typeinfo)

{

  int     natts = typeinfo->natts;

  int     i;

  /*

   * show the return type of the tuples

   */

  for (i = 0; i < natts; ++i)

    printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), NULL);

  printf("\t----\n");

}

/* ----------------

 *    debugtup - print one tuple for an interactive backend

 * ----------------

 */

bool

debugtup(TupleTableSlot *slot, DestReceiver *self)

{

  TupleDesc typeinfo = slot->tts_tupleDescriptor;

  int     natts = typeinfo->natts;

  int     i;

  Datum   attr;

  char     *value;

  bool    isnull;

  Oid     typoutput;

  bool    typisvarlena;

  for (i = 0; i < natts; ++i)

  {

    attr = slot_getattr(slot, i + 1, &isnull);

    if (isnull)

      continue;

    getTypeOutputInfo(TupleDescAttr(typeinfo, i)->atttypid,

              &typoutput, &typisvarlena);

    value = OidOutputFunctionCall(typoutput, attr);

    printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), value);

  }

  printf("\t----\n");

  return true;

}