PostgreSQL Source Code  git master
printtup.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * printtup.c
4  * Routines to print out tuples to the destination (both frontend
5  * clients and standalone backends are supported here).
6  *
7  *
8  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
9  * Portions Copyright (c) 1994, Regents of the University of California
10  *
11  * IDENTIFICATION
12  * src/backend/access/common/printtup.c
13  *
14  *-------------------------------------------------------------------------
15  */
16 #include "postgres.h"
17 
18 #include "access/printtup.h"
19 #include "libpq/pqformat.h"
20 #include "libpq/protocol.h"
21 #include "tcop/pquery.h"
22 #include "utils/lsyscache.h"
23 #include "utils/memdebug.h"
24 #include "utils/memutils.h"
25 
26 
27 static void printtup_startup(DestReceiver *self, int operation,
28  TupleDesc typeinfo);
29 static bool printtup(TupleTableSlot *slot, DestReceiver *self);
30 static void printtup_shutdown(DestReceiver *self);
31 static void printtup_destroy(DestReceiver *self);
32 
33 /* ----------------------------------------------------------------
34  * printtup / debugtup support
35  * ----------------------------------------------------------------
36  */
37 
38 /* ----------------
39  * Private state for a printtup destination object
40  *
41  * NOTE: finfo is the lookup info for either typoutput or typsend, whichever
42  * we are using for this column.
43  * ----------------
44  */
45 typedef struct
46 { /* Per-attribute information */
47  Oid typoutput; /* Oid for the type's text output fn */
48  Oid typsend; /* Oid for the type's binary output fn */
49  bool typisvarlena; /* is it varlena (ie possibly toastable)? */
50  int16 format; /* format code for this column */
51  FmgrInfo finfo; /* Precomputed call info for output fn */
53 
54 typedef struct
55 {
56  DestReceiver pub; /* publicly-known function pointers */
57  Portal portal; /* the Portal we are printing from */
58  bool sendDescrip; /* send RowDescription at startup? */
59  TupleDesc attrinfo; /* The attr info we are set up for */
60  int nattrs;
61  PrinttupAttrInfo *myinfo; /* Cached info about each attr */
62  StringInfoData buf; /* output buffer (*not* in tmpcontext) */
63  MemoryContext tmpcontext; /* Memory context for per-row workspace */
64 } DR_printtup;
65 
66 /* ----------------
67  * Initialize: create a DestReceiver for printtup
68  * ----------------
69  */
72 {
73  DR_printtup *self = (DR_printtup *) palloc0(sizeof(DR_printtup));
74 
75  self->pub.receiveSlot = printtup; /* might get changed later */
76  self->pub.rStartup = printtup_startup;
77  self->pub.rShutdown = printtup_shutdown;
78  self->pub.rDestroy = printtup_destroy;
79  self->pub.mydest = dest;
80 
81  /*
82  * Send T message automatically if DestRemote, but not if
83  * DestRemoteExecute
84  */
85  self->sendDescrip = (dest == DestRemote);
86 
87  self->attrinfo = NULL;
88  self->nattrs = 0;
89  self->myinfo = NULL;
90  self->buf.data = NULL;
91  self->tmpcontext = NULL;
92 
93  return (DestReceiver *) self;
94 }
95 
96 /*
97  * Set parameters for a DestRemote (or DestRemoteExecute) receiver
98  */
99 void
101 {
102  DR_printtup *myState = (DR_printtup *) self;
103 
104  Assert(myState->pub.mydest == DestRemote ||
105  myState->pub.mydest == DestRemoteExecute);
106 
107  myState->portal = portal;
108 }
109 
110 static void
111 printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
112 {
113  DR_printtup *myState = (DR_printtup *) self;
114  Portal portal = myState->portal;
115 
116  /*
117  * Create I/O buffer to be used for all messages. This cannot be inside
118  * tmpcontext, since we want to re-use it across rows.
119  */
120  initStringInfo(&myState->buf);
121 
122  /*
123  * Create a temporary memory context that we can reset once per row to
124  * recover palloc'd memory. This avoids any problems with leaks inside
125  * datatype output routines, and should be faster than retail pfree's
126  * anyway.
127  */
129  "printtup",
131 
132  /*
133  * If we are supposed to emit row descriptions, then send the tuple
134  * descriptor of the tuples.
135  */
136  if (myState->sendDescrip)
137  SendRowDescriptionMessage(&myState->buf,
138  typeinfo,
139  FetchPortalTargetList(portal),
140  portal->formats);
141 
142  /* ----------------
143  * We could set up the derived attr info at this time, but we postpone it
144  * until the first call of printtup, for 2 reasons:
145  * 1. We don't waste time (compared to the old way) if there are no
146  * tuples at all to output.
147  * 2. Checking in printtup allows us to handle the case that the tuples
148  * change type midway through (although this probably can't happen in
149  * the current executor).
150  * ----------------
151  */
152 }
153 
154 /*
155  * SendRowDescriptionMessage --- send a RowDescription message to the frontend
156  *
157  * Notes: the TupleDesc has typically been manufactured by ExecTypeFromTL()
158  * or some similar function; it does not contain a full set of fields.
159  * The targetlist will be NIL when executing a utility function that does
160  * not have a plan. If the targetlist isn't NIL then it is a Query node's
161  * targetlist; it is up to us to ignore resjunk columns in it. The formats[]
162  * array pointer might be NULL (if we are doing Describe on a prepared stmt);
163  * send zeroes for the format codes in that case.
164  */
165 void
167  List *targetlist, int16 *formats)
168 {
169  int natts = typeinfo->natts;
170  int i;
171  ListCell *tlist_item = list_head(targetlist);
172 
173  /* tuple descriptor message type */
175  /* # of attrs in tuples */
176  pq_sendint16(buf, natts);
177 
178  /*
179  * Preallocate memory for the entire message to be sent. That allows to
180  * use the significantly faster inline pqformat.h functions and to avoid
181  * reallocations.
182  *
183  * Have to overestimate the size of the column-names, to account for
184  * character set overhead.
185  */
187  + sizeof(Oid) /* resorigtbl */
188  + sizeof(AttrNumber) /* resorigcol */
189  + sizeof(Oid) /* atttypid */
190  + sizeof(int16) /* attlen */
191  + sizeof(int32) /* attypmod */
192  + sizeof(int16) /* format */
193  ) * natts);
194 
195  for (i = 0; i < natts; ++i)
196  {
197  Form_pg_attribute att = TupleDescAttr(typeinfo, i);
198  Oid atttypid = att->atttypid;
199  int32 atttypmod = att->atttypmod;
200  Oid resorigtbl;
201  AttrNumber resorigcol;
202  int16 format;
203 
204  /*
205  * If column is a domain, send the base type and typmod instead.
206  * Lookup before sending any ints, for efficiency.
207  */
208  atttypid = getBaseTypeAndTypmod(atttypid, &atttypmod);
209 
210  /* Do we have a non-resjunk tlist item? */
211  while (tlist_item &&
212  ((TargetEntry *) lfirst(tlist_item))->resjunk)
213  tlist_item = lnext(targetlist, tlist_item);
214  if (tlist_item)
215  {
216  TargetEntry *tle = (TargetEntry *) lfirst(tlist_item);
217 
218  resorigtbl = tle->resorigtbl;
219  resorigcol = tle->resorigcol;
220  tlist_item = lnext(targetlist, tlist_item);
221  }
222  else
223  {
224  /* No info available, so send zeroes */
225  resorigtbl = 0;
226  resorigcol = 0;
227  }
228 
229  if (formats)
230  format = formats[i];
231  else
232  format = 0;
233 
234  pq_writestring(buf, NameStr(att->attname));
235  pq_writeint32(buf, resorigtbl);
236  pq_writeint16(buf, resorigcol);
237  pq_writeint32(buf, atttypid);
238  pq_writeint16(buf, att->attlen);
239  pq_writeint32(buf, atttypmod);
241  }
242 
244 }
245 
246 /*
247  * Get the lookup info that printtup() needs
248  */
249 static void
250 printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
251 {
252  int16 *formats = myState->portal->formats;
253  int i;
254 
255  /* get rid of any old data */
256  if (myState->myinfo)
257  pfree(myState->myinfo);
258  myState->myinfo = NULL;
259 
260  myState->attrinfo = typeinfo;
261  myState->nattrs = numAttrs;
262  if (numAttrs <= 0)
263  return;
264 
265  myState->myinfo = (PrinttupAttrInfo *)
266  palloc0(numAttrs * sizeof(PrinttupAttrInfo));
267 
268  for (i = 0; i < numAttrs; i++)
269  {
270  PrinttupAttrInfo *thisState = myState->myinfo + i;
271  int16 format = (formats ? formats[i] : 0);
272  Form_pg_attribute attr = TupleDescAttr(typeinfo, i);
273 
274  thisState->format = format;
275  if (format == 0)
276  {
277  getTypeOutputInfo(attr->atttypid,
278  &thisState->typoutput,
279  &thisState->typisvarlena);
280  fmgr_info(thisState->typoutput, &thisState->finfo);
281  }
282  else if (format == 1)
283  {
284  getTypeBinaryOutputInfo(attr->atttypid,
285  &thisState->typsend,
286  &thisState->typisvarlena);
287  fmgr_info(thisState->typsend, &thisState->finfo);
288  }
289  else
290  ereport(ERROR,
291  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
292  errmsg("unsupported format code: %d", format)));
293  }
294 }
295 
296 /* ----------------
297  * printtup --- send a tuple to the client
298  *
299  * Note: if you change this function, see also serializeAnalyzeReceive
300  * in explain.c, which is meant to replicate the computations done here.
301  * ----------------
302  */
303 static bool
305 {
306  TupleDesc typeinfo = slot->tts_tupleDescriptor;
307  DR_printtup *myState = (DR_printtup *) self;
308  MemoryContext oldcontext;
309  StringInfo buf = &myState->buf;
310  int natts = typeinfo->natts;
311  int i;
312 
313  /* Set or update my derived attribute info, if needed */
314  if (myState->attrinfo != typeinfo || myState->nattrs != natts)
315  printtup_prepare_info(myState, typeinfo, natts);
316 
317  /* Make sure the tuple is fully deconstructed */
318  slot_getallattrs(slot);
319 
320  /* Switch into per-row context so we can recover memory below */
321  oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
322 
323  /*
324  * Prepare a DataRow message (note buffer is in per-query context)
325  */
327 
328  pq_sendint16(buf, natts);
329 
330  /*
331  * send the attributes of this tuple
332  */
333  for (i = 0; i < natts; ++i)
334  {
335  PrinttupAttrInfo *thisState = myState->myinfo + i;
336  Datum attr = slot->tts_values[i];
337 
338  if (slot->tts_isnull[i])
339  {
340  pq_sendint32(buf, -1);
341  continue;
342  }
343 
344  /*
345  * Here we catch undefined bytes in datums that are returned to the
346  * client without hitting disk; see comments at the related check in
347  * PageAddItem(). This test is most useful for uncompressed,
348  * non-external datums, but we're quite likely to see such here when
349  * testing new C functions.
350  */
351  if (thisState->typisvarlena)
353  VARSIZE_ANY(attr));
354 
355  if (thisState->format == 0)
356  {
357  /* Text output */
358  char *outputstr;
359 
360  outputstr = OutputFunctionCall(&thisState->finfo, attr);
361  pq_sendcountedtext(buf, outputstr, strlen(outputstr));
362  }
363  else
364  {
365  /* Binary output */
366  bytea *outputbytes;
367 
368  outputbytes = SendFunctionCall(&thisState->finfo, attr);
369  pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
370  pq_sendbytes(buf, VARDATA(outputbytes),
371  VARSIZE(outputbytes) - VARHDRSZ);
372  }
373  }
374 
376 
377  /* Return to caller's context, and flush row's temporary memory */
378  MemoryContextSwitchTo(oldcontext);
379  MemoryContextReset(myState->tmpcontext);
380 
381  return true;
382 }
383 
384 /* ----------------
385  * printtup_shutdown
386  * ----------------
387  */
388 static void
390 {
391  DR_printtup *myState = (DR_printtup *) self;
392 
393  if (myState->myinfo)
394  pfree(myState->myinfo);
395  myState->myinfo = NULL;
396 
397  myState->attrinfo = NULL;
398 
399  if (myState->buf.data)
400  pfree(myState->buf.data);
401  myState->buf.data = NULL;
402 
403  if (myState->tmpcontext)
405  myState->tmpcontext = NULL;
406 }
407 
408 /* ----------------
409  * printtup_destroy
410  * ----------------
411  */
412 static void
414 {
415  pfree(self);
416 }
417 
418 /* ----------------
419  * printatt
420  * ----------------
421  */
422 static void
423 printatt(unsigned attributeId,
424  Form_pg_attribute attributeP,
425  char *value)
426 {
427  printf("\t%2d: %s%s%s%s\t(typeid = %u, len = %d, typmod = %d, byval = %c)\n",
428  attributeId,
429  NameStr(attributeP->attname),
430  value != NULL ? " = \"" : "",
431  value != NULL ? value : "",
432  value != NULL ? "\"" : "",
433  (unsigned int) (attributeP->atttypid),
434  attributeP->attlen,
435  attributeP->atttypmod,
436  attributeP->attbyval ? 't' : 'f');
437 }
438 
439 /* ----------------
440  * debugStartup - prepare to print tuples for an interactive backend
441  * ----------------
442  */
443 void
444 debugStartup(DestReceiver *self, int operation, TupleDesc typeinfo)
445 {
446  int natts = typeinfo->natts;
447  int i;
448 
449  /*
450  * show the return type of the tuples
451  */
452  for (i = 0; i < natts; ++i)
453  printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), NULL);
454  printf("\t----\n");
455 }
456 
457 /* ----------------
458  * debugtup - print one tuple for an interactive backend
459  * ----------------
460  */
461 bool
463 {
464  TupleDesc typeinfo = slot->tts_tupleDescriptor;
465  int natts = typeinfo->natts;
466  int i;
467  Datum attr;
468  char *value;
469  bool isnull;
470  Oid typoutput;
471  bool typisvarlena;
472 
473  for (i = 0; i < natts; ++i)
474  {
475  attr = slot_getattr(slot, i + 1, &isnull);
476  if (isnull)
477  continue;
478  getTypeOutputInfo(TupleDescAttr(typeinfo, i)->atttypid,
479  &typoutput, &typisvarlena);
480 
481  value = OidOutputFunctionCall(typoutput, attr);
482 
483  printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), value);
484  }
485  printf("\t----\n");
486 
487  return true;
488 }
int16 AttrNumber
Definition: attnum.h:21
#define NameStr(name)
Definition: c.h:737
signed short int16
Definition: c.h:495
signed int int32
Definition: c.h:496
#define VARHDRSZ
Definition: c.h:683
#define Assert(condition)
Definition: c.h:849
CommandDest
Definition: dest.h:86
@ DestRemote
Definition: dest.h:89
@ DestRemoteExecute
Definition: dest.h:90
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1763
bytea * SendFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1744
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1683
static struct @160 value
int i
Definition: isn.c:72
void getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena)
Definition: lsyscache.c:2973
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2907
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2538
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size)
Definition: memdebug.h:23
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
static char format
#define NAMEDATALEN
#define lfirst(lc)
Definition: pg_list.h:172
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
static char * buf
Definition: pg_test_fsync.c:73
#define MAX_CONVERSION_GROWTH
Definition: pg_wchar.h:302
#define printf(...)
Definition: port.h:244
uintptr_t Datum
Definition: postgres.h:64
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
unsigned int Oid
Definition: postgres_ext.h:31
void pq_sendbytes(StringInfo buf, const void *data, int datalen)
Definition: pqformat.c:126
void pq_beginmessage_reuse(StringInfo buf, char msgtype)
Definition: pqformat.c:109
void pq_endmessage_reuse(StringInfo buf)
Definition: pqformat.c:314
void pq_sendcountedtext(StringInfo buf, const char *str, int slen)
Definition: pqformat.c:142
static void pq_sendint32(StringInfo buf, uint32 i)
Definition: pqformat.h:144
static void pq_writestring(StringInfoData *pg_restrict buf, const char *pg_restrict str)
Definition: pqformat.h:108
static void pq_writeint32(StringInfoData *pg_restrict buf, uint32 i)
Definition: pqformat.h:74
static void pq_sendint16(StringInfo buf, uint16 i)
Definition: pqformat.h:136
static void pq_writeint16(StringInfoData *pg_restrict buf, uint16 i)
Definition: pqformat.h:60
List * FetchPortalTargetList(Portal portal)
Definition: pquery.c:326
bool debugtup(TupleTableSlot *slot, DestReceiver *self)
Definition: printtup.c:462
static void printatt(unsigned attributeId, Form_pg_attribute attributeP, char *value)
Definition: printtup.c:423
void debugStartup(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: printtup.c:444
static void printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
Definition: printtup.c:250
static bool printtup(TupleTableSlot *slot, DestReceiver *self)
Definition: printtup.c:304
static void printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: printtup.c:111
void SetRemoteDestReceiverParams(DestReceiver *self, Portal portal)
Definition: printtup.c:100
void SendRowDescriptionMessage(StringInfo buf, TupleDesc typeinfo, List *targetlist, int16 *formats)
Definition: printtup.c:166
static void printtup_destroy(DestReceiver *self)
Definition: printtup.c:413
DestReceiver * printtup_create_DR(CommandDest dest)
Definition: printtup.c:71
static void printtup_shutdown(DestReceiver *self)
Definition: printtup.c:389
#define PqMsg_RowDescription
Definition: protocol.h:52
#define PqMsg_DataRow
Definition: protocol.h:43
MemoryContextSwitchTo(old_ctx)
void enlargeStringInfo(StringInfo str, int needed)
Definition: stringinfo.c:286
void initStringInfo(StringInfo str)
Definition: stringinfo.c:56
PrinttupAttrInfo * myinfo
Definition: printtup.c:61
StringInfoData buf
Definition: printtup.c:62
int nattrs
Definition: printtup.c:60
DestReceiver pub
Definition: printtup.c:56
bool sendDescrip
Definition: printtup.c:58
Portal portal
Definition: printtup.c:57
MemoryContext tmpcontext
Definition: printtup.c:63
TupleDesc attrinfo
Definition: printtup.c:59
Definition: fmgr.h:57
Definition: pg_list.h:54
int16 * formats
Definition: portal.h:162
bool typisvarlena
Definition: printtup.c:49
FmgrInfo finfo
Definition: printtup.c:51
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:123
bool * tts_isnull
Definition: tuptable.h:127
Datum * tts_values
Definition: tuptable.h:125
CommandDest mydest
Definition: dest.h:128
Definition: c.h:678
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:395
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:368
#define VARSIZE_ANY(PTR)
Definition: varatt.h:311
#define VARDATA(PTR)
Definition: varatt.h:278
#define VARSIZE(PTR)
Definition: varatt.h:279