PostgreSQL Source Code: src/backend/access/common/printtup.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /