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-2021, 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/libpq.h"
20 #include "libpq/pqformat.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 */
174  pq_beginmessage_reuse(buf, 'T');
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);
240  pq_writeint16(buf, format);
241  }
242 
243  pq_endmessage_reuse(buf);
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  */
300 static bool
302 {
303  TupleDesc typeinfo = slot->tts_tupleDescriptor;
304  DR_printtup *myState = (DR_printtup *) self;
305  MemoryContext oldcontext;
306  StringInfo buf = &myState->buf;
307  int natts = typeinfo->natts;
308  int i;
309 
310  /* Set or update my derived attribute info, if needed */
311  if (myState->attrinfo != typeinfo || myState->nattrs != natts)
312  printtup_prepare_info(myState, typeinfo, natts);
313 
314  /* Make sure the tuple is fully deconstructed */
315  slot_getallattrs(slot);
316 
317  /* Switch into per-row context so we can recover memory below */
318  oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
319 
320  /*
321  * Prepare a DataRow message (note buffer is in per-row context)
322  */
323  pq_beginmessage_reuse(buf, 'D');
324 
325  pq_sendint16(buf, natts);
326 
327  /*
328  * send the attributes of this tuple
329  */
330  for (i = 0; i < natts; ++i)
331  {
332  PrinttupAttrInfo *thisState = myState->myinfo + i;
333  Datum attr = slot->tts_values[i];
334 
335  if (slot->tts_isnull[i])
336  {
337  pq_sendint32(buf, -1);
338  continue;
339  }
340 
341  /*
342  * Here we catch undefined bytes in datums that are returned to the
343  * client without hitting disk; see comments at the related check in
344  * PageAddItem(). This test is most useful for uncompressed,
345  * non-external datums, but we're quite likely to see such here when
346  * testing new C functions.
347  */
348  if (thisState->typisvarlena)
350  VARSIZE_ANY(attr));
351 
352  if (thisState->format == 0)
353  {
354  /* Text output */
355  char *outputstr;
356 
357  outputstr = OutputFunctionCall(&thisState->finfo, attr);
358  pq_sendcountedtext(buf, outputstr, strlen(outputstr), false);
359  }
360  else
361  {
362  /* Binary output */
363  bytea *outputbytes;
364 
365  outputbytes = SendFunctionCall(&thisState->finfo, attr);
366  pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
367  pq_sendbytes(buf, VARDATA(outputbytes),
368  VARSIZE(outputbytes) - VARHDRSZ);
369  }
370  }
371 
372  pq_endmessage_reuse(buf);
373 
374  /* Return to caller's context, and flush row's temporary memory */
375  MemoryContextSwitchTo(oldcontext);
376  MemoryContextReset(myState->tmpcontext);
377 
378  return true;
379 }
380 
381 /* ----------------
382  * printtup_shutdown
383  * ----------------
384  */
385 static void
387 {
388  DR_printtup *myState = (DR_printtup *) self;
389 
390  if (myState->myinfo)
391  pfree(myState->myinfo);
392  myState->myinfo = NULL;
393 
394  myState->attrinfo = NULL;
395 
396  if (myState->buf.data)
397  pfree(myState->buf.data);
398  myState->buf.data = NULL;
399 
400  if (myState->tmpcontext)
402  myState->tmpcontext = NULL;
403 }
404 
405 /* ----------------
406  * printtup_destroy
407  * ----------------
408  */
409 static void
411 {
412  pfree(self);
413 }
414 
415 /* ----------------
416  * printatt
417  * ----------------
418  */
419 static void
420 printatt(unsigned attributeId,
421  Form_pg_attribute attributeP,
422  char *value)
423 {
424  printf("\t%2d: %s%s%s%s\t(typeid = %u, len = %d, typmod = %d, byval = %c)\n",
425  attributeId,
426  NameStr(attributeP->attname),
427  value != NULL ? " = \"" : "",
428  value != NULL ? value : "",
429  value != NULL ? "\"" : "",
430  (unsigned int) (attributeP->atttypid),
431  attributeP->attlen,
432  attributeP->atttypmod,
433  attributeP->attbyval ? 't' : 'f');
434 }
435 
436 /* ----------------
437  * debugStartup - prepare to print tuples for an interactive backend
438  * ----------------
439  */
440 void
441 debugStartup(DestReceiver *self, int operation, TupleDesc typeinfo)
442 {
443  int natts = typeinfo->natts;
444  int i;
445 
446  /*
447  * show the return type of the tuples
448  */
449  for (i = 0; i < natts; ++i)
450  printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), NULL);
451  printf("\t----\n");
452 }
453 
454 /* ----------------
455  * debugtup - print one tuple for an interactive backend
456  * ----------------
457  */
458 bool
460 {
461  TupleDesc typeinfo = slot->tts_tupleDescriptor;
462  int natts = typeinfo->natts;
463  int i;
464  Datum attr;
465  char *value;
466  bool isnull;
467  Oid typoutput;
468  bool typisvarlena;
469 
470  for (i = 0; i < natts; ++i)
471  {
472  attr = slot_getattr(slot, i + 1, &isnull);
473  if (isnull)
474  continue;
475  getTypeOutputInfo(TupleDescAttr(typeinfo, i)->atttypid,
476  &typoutput, &typisvarlena);
477 
478  value = OidOutputFunctionCall(typoutput, attr);
479 
480  printatt((unsigned) i + 1, TupleDescAttr(typeinfo, i), value);
481  }
482  printf("\t----\n");
483 
484  return true;
485 }
signed short int16
Definition: c.h:428
static void pq_sendint16(StringInfo buf, uint16 i)
Definition: pqformat.h:137
Definition: fmgr.h:56
void SetRemoteDestReceiverParams(DestReceiver *self, Portal portal)
Definition: printtup.c:100
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2485
static void pq_writestring(StringInfoData *pg_restrict buf, const char *pg_restrict str)
Definition: pqformat.h:109
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:218
#define AllocSetContextCreate
Definition: memutils.h:173
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2854
#define VARDATA(PTR)
Definition: postgres.h:315
static struct @142 value
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:322
CommandDest
Definition: dest.h:87
DestReceiver pub
Definition: printtup.c:56
#define VARSIZE(PTR)
Definition: postgres.h:316
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define VARHDRSZ
Definition: c.h:627
CommandDest mydest
Definition: dest.h:129
#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size)
Definition: memdebug.h:23
static void printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
Definition: printtup.c:250
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
int errcode(int sqlerrcode)
Definition: elog.c:698
Oid resorigtbl
Definition: primnodes.h:1449
Datum * tts_values
Definition: tuptable.h:126
#define printf(...)
Definition: port.h:222
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:143
unsigned int Oid
Definition: postgres_ext.h:31
signed int int32
Definition: c.h:429
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1573
#define NAMEDATALEN
static void pq_sendint32(StringInfo buf, uint32 i)
Definition: pqformat.h:145
void pfree(void *pointer)
Definition: mcxt.c:1169
TupleDesc attrinfo
Definition: printtup.c:59
static void pq_writeint16(StringInfoData *pg_restrict buf, uint16 i)
Definition: pqformat.h:61
#define ERROR
Definition: elog.h:46
Portal portal
Definition: printtup.c:57
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:126
PrinttupAttrInfo * myinfo
Definition: printtup.c:61
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:354
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:195
static char * buf
Definition: pg_test_fsync.c:68
bool * tts_isnull
Definition: tuptable.h:128
DestReceiver * printtup_create_DR(CommandDest dest)
Definition: printtup.c:71
static void pq_writeint32(StringInfoData *pg_restrict buf, uint32 i)
Definition: pqformat.h:75
void enlargeStringInfo(StringInfo str, int needed)
Definition: stringinfo.c:283
static ListCell * list_head(const List *l)
Definition: pg_list.h:125
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:203
bytea * SendFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1634
int nattrs
Definition: printtup.c:60
void pq_sendcountedtext(StringInfo buf, const char *str, int slen, bool countincludesself)
Definition: pqformat.c:142
MemoryContext CurrentMemoryContext
Definition: mcxt.c:42
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
MemoryContext tmpcontext
Definition: printtup.c:63
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
void getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena)
Definition: lsyscache.c:2920
static void printatt(unsigned attributeId, Form_pg_attribute attributeP, char *value)
Definition: printtup.c:420
void * palloc0(Size size)
Definition: mcxt.c:1093
bool sendDescrip
Definition: printtup.c:58
int16 * formats
Definition: portal.h:161
uintptr_t Datum
Definition: postgres.h:411
#define VARSIZE_ANY(PTR)
Definition: postgres.h:348
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:381
#define ereport(elevel,...)
Definition: elog.h:157
static void printtup_destroy(DestReceiver *self)
Definition: printtup.c:410
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
bool typisvarlena
Definition: printtup.c:49
static void printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: printtup.c:111
static bool printtup(TupleTableSlot *slot, DestReceiver *self)
Definition: printtup.c:301
bool debugtup(TupleTableSlot *slot, DestReceiver *self)
Definition: printtup.c:459
#define DatumGetPointer(X)
Definition: postgres.h:593
#define MAX_CONVERSION_GROWTH
Definition: pg_wchar.h:316
AttrNumber resorigcol
Definition: primnodes.h:1450
void pq_sendbytes(StringInfo buf, const char *data, int datalen)
Definition: pqformat.c:125
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1653
int errmsg(const char *fmt,...)
Definition: elog.c:909
int i
#define NameStr(name)
Definition: c.h:681
StringInfoData buf
Definition: printtup.c:62
Definition: c.h:621
static void printtup_shutdown(DestReceiver *self)
Definition: printtup.c:386
static char format
List * FetchPortalTargetList(Portal portal)
Definition: pquery.c:323
void debugStartup(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: printtup.c:441
void SendRowDescriptionMessage(StringInfo buf, TupleDesc typeinfo, List *targetlist, int16 *formats)
Definition: printtup.c:166
Definition: pg_list.h:50
void pq_endmessage_reuse(StringInfo buf)
Definition: pqformat.c:316
int16 AttrNumber
Definition: attnum.h:21
FmgrInfo finfo
Definition: printtup.c:51
void pq_beginmessage_reuse(StringInfo buf, char msgtype)
Definition: pqformat.c:108