PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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
27static void printtup_startup(DestReceiver *self, int operation,
28 TupleDesc typeinfo);
29static bool printtup(TupleTableSlot *slot, DestReceiver *self);
30static void printtup_shutdown(DestReceiver *self);
31static 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 */
45typedef 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
54typedef 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 */
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 */
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 */
99void
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
110static void
111printtup_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)
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 */
165void
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;
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 */
249static void
250printtup_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
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 */
303static 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);
380
381 return true;
382}
383
384/* ----------------
385 * printtup_shutdown
386 * ----------------
387 */
388static 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 */
412static void
414{
415 pfree(self);
416}
417
418/* ----------------
419 * printatt
420 * ----------------
421 */
422static void
423printatt(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 */
443void
444debugStartup(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 */
461bool
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:700
#define VARHDRSZ
Definition: c.h:646
#define Assert(condition)
Definition: c.h:812
int16_t int16
Definition: c.h:480
int32_t int32
Definition: c.h:481
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 @161 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:200
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:72
#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
DestReceiver * printtup_create_DR(CommandDest dest)
Definition: printtup.c:71
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
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:161
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
void(* rStartup)(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: dest.h:121
void(* rShutdown)(DestReceiver *self)
Definition: dest.h:124
bool(* receiveSlot)(TupleTableSlot *slot, DestReceiver *self)
Definition: dest.h:118
void(* rDestroy)(DestReceiver *self)
Definition: dest.h:126
CommandDest mydest
Definition: dest.h:128
Definition: c.h:641
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:152
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