PostgreSQL Source Code git master
Macros | Functions
fe-print.c File Reference
#include "postgres_fe.h"
#include <signal.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/termios.h>
#include "common/int.h"
#include "libpq-fe.h"
#include "libpq-int.h"
Include dependency graph for fe-print.c:

Go to the source code of this file.

Macros

#define DEFAULT_FIELD_SEP   " "
 

Functions

static bool do_field (const PQprintOpt *po, const PGresult *res, const int i, const int j, const int fs_len, char **fields, const int nFields, const char **fieldNames, unsigned char *fieldNotNum, int *fieldMax, const int fieldMaxLen, FILE *fout)
 
static char * do_header (FILE *fout, const PQprintOpt *po, const int nFields, int *fieldMax, const char **fieldNames, unsigned char *fieldNotNum, const int fs_len, const PGresult *res)
 
static void output_row (FILE *fout, const PQprintOpt *po, const int nFields, char **fields, unsigned char *fieldNotNum, int *fieldMax, char *border, const int row_index)
 
static void fill (int length, int max, char filler, FILE *fp)
 
void PQprint (FILE *fout, const PGresult *res, const PQprintOpt *po)
 
void PQdisplayTuples (const PGresult *res, FILE *fp, int fillAlign, const char *fieldSep, int printHeader, int quiet)
 
void PQprintTuples (const PGresult *res, FILE *fout, int PrintAttNames, int TerseOutput, int colWidth)
 

Macro Definition Documentation

◆ DEFAULT_FIELD_SEP

#define DEFAULT_FIELD_SEP   " "

Function Documentation

◆ do_field()

static bool do_field ( const PQprintOpt *  po,
const PGresult *  res,
const int  i,
const int  j,
const int  fs_len,
char **  fields,
const int  nFields,
const char **  fieldNames,
unsigned char *  fieldNotNum,
int *  fieldMax,
const int  fieldMaxLen,
FILE *  fout 
)
static

Definition at line 341 of file fe-print.c.

347{
348 const char *pval,
349 *p;
350 int plen;
351 bool skipit;
352
353 plen = PQgetlength(res, i, j);
354 pval = PQgetvalue(res, i, j);
355
356 if (plen < 1 || !pval || !*pval)
357 {
358 if (po->align || po->expanded)
359 skipit = true;
360 else
361 {
362 skipit = false;
363 goto efield;
364 }
365 }
366 else
367 skipit = false;
368
369 if (!skipit)
370 {
371 if (po->align && !fieldNotNum[j])
372 {
373 /* Detect whether field contains non-numeric data */
374 char ch = '0';
375
376 for (p = pval; *p; p += PQmblenBounded(p, res->client_encoding))
377 {
378 ch = *p;
379 if (!((ch >= '0' && ch <= '9') ||
380 ch == '.' ||
381 ch == 'E' ||
382 ch == 'e' ||
383 ch == ' ' ||
384 ch == '-'))
385 {
386 fieldNotNum[j] = 1;
387 break;
388 }
389 }
390
391 /*
392 * Above loop will believe E in first column is numeric; also, we
393 * insist on a digit in the last column for a numeric. This test
394 * is still not bulletproof but it handles most cases.
395 */
396 if (*pval == 'E' || *pval == 'e' ||
397 !(ch >= '0' && ch <= '9'))
398 fieldNotNum[j] = 1;
399 }
400
401 if (!po->expanded && (po->align || po->html3))
402 {
403 if (plen > fieldMax[j])
404 fieldMax[j] = plen;
405 if (!(fields[i * nFields + j] = (char *) malloc((size_t) plen + 1)))
406 {
407 fprintf(stderr, libpq_gettext("out of memory\n"));
408 return false;
409 }
410 strcpy(fields[i * nFields + j], pval);
411 }
412 else
413 {
414 if (po->expanded)
415 {
416 if (po->html3)
417 fprintf(fout,
418 "<tr><td align=\"left\"><b>%s</b></td>"
419 "<td align=\"%s\">%s</td></tr>\n",
420 fieldNames[j],
421 fieldNotNum[j] ? "left" : "right",
422 pval);
423 else
424 {
425 if (po->align)
426 fprintf(fout,
427 "%-*s%s %s\n",
428 fieldMaxLen - fs_len, fieldNames[j],
429 po->fieldSep,
430 pval);
431 else
432 fprintf(fout,
433 "%s%s%s\n",
434 fieldNames[j], po->fieldSep, pval);
435 }
436 }
437 else
438 {
439 if (!po->html3)
440 {
441 fputs(pval, fout);
442 efield:
443 if ((j + 1) < nFields)
444 fputs(po->fieldSep, fout);
445 else
446 fputc('\n', fout);
447 }
448 }
449 }
450 }
451 return true;
452}
fprintf
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
PQmblenBounded
int PQmblenBounded(const char *s, int encoding)
Definition: fe-misc.c:1266
malloc
#define malloc(a)
Definition: header.h:50
j
int j
Definition: isn.c:78
i
int i
Definition: isn.c:77
PQgetvalue
#define PQgetvalue
Definition: libpq-be-fe.h:253
PQgetlength
#define PQgetlength
Definition: libpq-be-fe.h:254
libpq_gettext
#define libpq_gettext(x)
Definition: oauth-utils.h:86
_PQprintOpt::align
pqbool align
Definition: libpq-fe.h:250
_PQprintOpt::html3
pqbool html3
Definition: libpq-fe.h:252
_PQprintOpt::expanded
pqbool expanded
Definition: libpq-fe.h:253
_PQprintOpt::fieldSep
char * fieldSep
Definition: libpq-fe.h:255
pg_result::client_encoding
int client_encoding
Definition: libpq-int.h:186

References _PQprintOpt::align, pg_result::client_encoding, _PQprintOpt::expanded, _PQprintOpt::fieldSep, fprintf, _PQprintOpt::html3, i, j, libpq_gettext, malloc, PQgetlength, PQgetvalue, and PQmblenBounded().

Referenced by PQprint().

◆ do_header()

static char * do_header ( FILE *  fout,
const PQprintOpt *  po,
const int  nFields,
int *  fieldMax,
const char **  fieldNames,
unsigned char *  fieldNotNum,
const int  fs_len,
const PGresult *  res 
)
static

Definition at line 456 of file fe-print.c.

459{
460 int j; /* for loop index */
461 char *border = NULL;
462
463 if (po->html3)
464 fputs("<tr>", fout);
465 else
466 {
467 size_t tot = 0;
468 int n = 0;
469 char *p = NULL;
470
471 /* Calculate the border size, checking for overflow. */
472 for (; n < nFields; n++)
473 {
474 /* Field plus separator, plus 2 extra '-' in standard format. */
475 if (pg_add_size_overflow(tot, fieldMax[n], &tot) ||
476 pg_add_size_overflow(tot, fs_len, &tot) ||
477 (po->standard && pg_add_size_overflow(tot, 2, &tot)))
478 goto overflow;
479 }
480 if (po->standard)
481 {
482 /* An extra separator at the front and back. */
483 if (pg_add_size_overflow(tot, fs_len, &tot) ||
484 pg_add_size_overflow(tot, fs_len, &tot) ||
485 pg_add_size_overflow(tot, 2, &tot))
486 goto overflow;
487 }
488 if (pg_add_size_overflow(tot, 1, &tot)) /* terminator */
489 goto overflow;
490
491 border = malloc(tot);
492 if (!border)
493 {
494 fprintf(stderr, libpq_gettext("out of memory\n"));
495 return NULL;
496 }
497 p = border;
498 if (po->standard)
499 {
500 char *fs = po->fieldSep;
501
502 while (*fs++)
503 *p++ = '+';
504 }
505 for (j = 0; j < nFields; j++)
506 {
507 int len;
508
509 for (len = fieldMax[j] + (po->standard ? 2 : 0); len--; *p++ = '-');
510 if (po->standard || (j + 1) < nFields)
511 {
512 char *fs = po->fieldSep;
513
514 while (*fs++)
515 *p++ = '+';
516 }
517 }
518 *p = '\0';
519 if (po->standard)
520 fprintf(fout, "%s\n", border);
521 }
522 if (po->standard)
523 fputs(po->fieldSep, fout);
524 for (j = 0; j < nFields; j++)
525 {
526 const char *s = PQfname(res, j);
527
528 if (po->html3)
529 {
530 fprintf(fout, "<th align=\"%s\">%s</th>",
531 fieldNotNum[j] ? "left" : "right", fieldNames[j]);
532 }
533 else
534 {
535 int n = strlen(s);
536
537 if (n > fieldMax[j])
538 fieldMax[j] = n;
539 if (po->standard)
540 fprintf(fout,
541 fieldNotNum[j] ? " %-*s " : " %*s ",
542 fieldMax[j], s);
543 else
544 fprintf(fout, fieldNotNum[j] ? "%-*s" : "%*s", fieldMax[j], s);
545 if (po->standard || (j + 1) < nFields)
546 fputs(po->fieldSep, fout);
547 }
548 }
549 if (po->html3)
550 fputs("</tr>\n", fout);
551 else
552 fprintf(fout, "\n%s\n", border);
553 return border;
554
555overflow:
556 fprintf(stderr, libpq_gettext("header size exceeds the maximum allowed\n"));
557 return NULL;
558}
pg_add_size_overflow
static bool pg_add_size_overflow(size_t a, size_t b, size_t *result)
Definition: int.h:608
PQfname
#define PQfname
Definition: libpq-be-fe.h:256
len
const void size_t len
Definition: pg_crc32c_sse42.c:28
_PQprintOpt::standard
pqbool standard
Definition: libpq-fe.h:251

References _PQprintOpt::fieldSep, fprintf, _PQprintOpt::html3, j, len, libpq_gettext, malloc, pg_add_size_overflow(), PQfname, and _PQprintOpt::standard.

Referenced by PQprint().

◆ fill()

static void fill ( int  length,
int  max,
char  filler,
FILE *  fp 
)
static

Definition at line 786 of file fe-print.c.

787{
788 int count;
789
790 count = max - length;
791 while (count-- >= 0)
792 putc(filler, fp);
793}

Referenced by PQdisplayTuples().

◆ output_row()

static void output_row ( FILE *  fout,
const PQprintOpt *  po,
const int  nFields,
char **  fields,
unsigned char *  fieldNotNum,
int *  fieldMax,
char *  border,
const int  row_index 
)
static

Definition at line 562 of file fe-print.c.

565{
566 int field_index; /* for loop index */
567
568 if (po->html3)
569 fputs("<tr>", fout);
570 else if (po->standard)
571 fputs(po->fieldSep, fout);
572 for (field_index = 0; field_index < nFields; field_index++)
573 {
574 char *p = fields[row_index * nFields + field_index];
575
576 if (po->html3)
577 fprintf(fout, "<td align=\"%s\">%s</td>",
578 fieldNotNum[field_index] ? "left" : "right", p ? p : "");
579 else
580 {
581 fprintf(fout,
582 fieldNotNum[field_index] ?
583 (po->standard ? " %-*s " : "%-*s") :
584 (po->standard ? " %*s " : "%*s"),
585 fieldMax[field_index],
586 p ? p : "");
587 if (po->standard || field_index + 1 < nFields)
588 fputs(po->fieldSep, fout);
589 }
590 }
591 if (po->html3)
592 fputs("</tr>", fout);
593 else if (po->standard)
594 fprintf(fout, "\n%s", border);
595 fputc('\n', fout);
596}

References _PQprintOpt::fieldSep, fprintf, _PQprintOpt::html3, and _PQprintOpt::standard.

Referenced by PQprint().

◆ PQdisplayTuples()

void PQdisplayTuples ( const PGresult *  res,
FILE *  fp,
int  fillAlign,
const char *  fieldSep,
int  printHeader,
int  quiet 
)

Definition at line 605 of file fe-print.c.

612{
613#define DEFAULT_FIELD_SEP " "
614
615 int i,
616 j;
617 int nFields;
618 int nTuples;
619 int *fLength = NULL;
620
621 if (fieldSep == NULL)
622 fieldSep = DEFAULT_FIELD_SEP;
623
624 /* Get some useful info about the results */
625 nFields = PQnfields(res);
626 nTuples = PQntuples(res);
627
628 if (fp == NULL)
629 fp = stdout;
630
631 /* Figure the field lengths to align to */
632 /* will be somewhat time consuming for very large results */
633 if (fillAlign)
634 {
635 fLength = (int *) malloc(nFields * sizeof(int));
636 if (!fLength)
637 {
638 fprintf(stderr, libpq_gettext("out of memory\n"));
639 return;
640 }
641
642 for (j = 0; j < nFields; j++)
643 {
644 fLength[j] = strlen(PQfname(res, j));
645 for (i = 0; i < nTuples; i++)
646 {
647 int flen = PQgetlength(res, i, j);
648
649 if (flen > fLength[j])
650 fLength[j] = flen;
651 }
652 }
653 }
654
655 if (printHeader)
656 {
657 /* first, print out the attribute names */
658 for (i = 0; i < nFields; i++)
659 {
660 fputs(PQfname(res, i), fp);
661 if (fillAlign)
662 fill(strlen(PQfname(res, i)), fLength[i], ' ', fp);
663 fputs(fieldSep, fp);
664 }
665 fprintf(fp, "\n");
666
667 /* Underline the attribute names */
668 for (i = 0; i < nFields; i++)
669 {
670 if (fillAlign)
671 fill(0, fLength[i], '-', fp);
672 fputs(fieldSep, fp);
673 }
674 fprintf(fp, "\n");
675 }
676
677 /* next, print out the instances */
678 for (i = 0; i < nTuples; i++)
679 {
680 for (j = 0; j < nFields; j++)
681 {
682 fprintf(fp, "%s", PQgetvalue(res, i, j));
683 if (fillAlign)
684 fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp);
685 fputs(fieldSep, fp);
686 }
687 fprintf(fp, "\n");
688 }
689
690 if (!quiet)
691 fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
692 (PQntuples(res) == 1) ? "" : "s");
693
694 fflush(fp);
695
696 free(fLength);
697}
fill
static void fill(int length, int max, char filler, FILE *fp)
Definition: fe-print.c:786
DEFAULT_FIELD_SEP
#define DEFAULT_FIELD_SEP
free
#define free(a)
Definition: header.h:65
PQnfields
#define PQnfields
Definition: libpq-be-fe.h:252
PQntuples
#define PQntuples
Definition: libpq-be-fe.h:251
generate_unaccent_rules.stdout
stdout
Definition: generate_unaccent_rules.py:35

References DEFAULT_FIELD_SEP, fill(), fprintf, free, i, j, libpq_gettext, malloc, PQfname, PQgetlength, PQgetvalue, PQnfields, PQntuples, and generate_unaccent_rules::stdout.

◆ PQprint()

void PQprint ( FILE *  fout,
const PGresult *  res,
const PQprintOpt *  po 
)

Definition at line 69 of file fe-print.c.

70{
71 int nFields;
72
73 nFields = PQnfields(res);
74
75 if (nFields > 0)
76 { /* only print rows with at least 1 field. */
77 int i,
78 j;
79 int nTups;
80 int *fieldMax = NULL; /* in case we don't use them */
81 unsigned char *fieldNotNum = NULL;
82 char *border = NULL;
83 char **fields = NULL;
84 const char **fieldNames = NULL;
85 int fieldMaxLen = 0;
86 int numFieldName;
87 int fs_len = strlen(po->fieldSep);
88 int total_line_length = 0;
89 bool usePipe = false;
90 char *pagerenv;
91
92#if !defined(WIN32)
93 sigset_t osigset;
94 bool sigpipe_masked = false;
95 bool sigpipe_pending;
96#endif
97
98#ifdef TIOCGWINSZ
99 struct winsize screen_size;
100#else
101 struct winsize
102 {
103 int ws_row;
104 int ws_col;
105 } screen_size;
106#endif
107
108 /*
109 * Quick sanity check on po->fieldSep, since we make heavy use of int
110 * math throughout.
111 */
112 if (fs_len < strlen(po->fieldSep))
113 {
114 fprintf(stderr, libpq_gettext("overlong field separator\n"));
115 goto exit;
116 }
117
118 nTups = PQntuples(res);
119 fieldNames = (const char **) calloc(nFields, sizeof(char *));
120 fieldNotNum = (unsigned char *) calloc(nFields, 1);
121 fieldMax = (int *) calloc(nFields, sizeof(int));
122 if (!fieldNames || !fieldNotNum || !fieldMax)
123 {
124 fprintf(stderr, libpq_gettext("out of memory\n"));
125 goto exit;
126 }
127 for (numFieldName = 0;
128 po->fieldName && po->fieldName[numFieldName];
129 numFieldName++)
130 ;
131 for (j = 0; j < nFields; j++)
132 {
133 int len;
134 const char *s = (j < numFieldName && po->fieldName[j][0]) ?
135 po->fieldName[j] : PQfname(res, j);
136
137 fieldNames[j] = s;
138 len = s ? strlen(s) : 0;
139 fieldMax[j] = len;
140 len += fs_len;
141 if (len > fieldMaxLen)
142 fieldMaxLen = len;
143 total_line_length += len;
144 }
145
146 total_line_length += nFields * strlen(po->fieldSep) + 1;
147
148 if (fout == NULL)
149 fout = stdout;
150 if (po->pager && fout == stdout && isatty(fileno(stdin)) &&
151 isatty(fileno(stdout)))
152 {
153 /*
154 * If we think there'll be more than one screen of output, try to
155 * pipe to the pager program.
156 */
157#ifdef TIOCGWINSZ
158 if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
159 screen_size.ws_col == 0 ||
160 screen_size.ws_row == 0)
161 {
162 screen_size.ws_row = 24;
163 screen_size.ws_col = 80;
164 }
165#else
166 screen_size.ws_row = 24;
167 screen_size.ws_col = 80;
168#endif
169
170 /*
171 * Since this function is no longer used by psql, we don't examine
172 * PSQL_PAGER. It's possible that the hypothetical external users
173 * of the function would like that to happen, but in the name of
174 * backwards compatibility, we'll stick to just examining PAGER.
175 */
176 pagerenv = getenv("PAGER");
177 /* if PAGER is unset, empty or all-white-space, don't use pager */
178 if (pagerenv != NULL &&
179 strspn(pagerenv, " \t\r\n") != strlen(pagerenv) &&
180 !po->html3 &&
181 ((po->expanded &&
182 nTups * (nFields + 1) >= screen_size.ws_row) ||
183 (!po->expanded &&
184 nTups * (total_line_length / screen_size.ws_col + 1) *
185 (1 + (po->standard != 0)) >= screen_size.ws_row -
186 (po->header != 0) *
187 (total_line_length / screen_size.ws_col + 1) * 2
188 - (po->header != 0) * 2 /* row count and newline */
189 )))
190 {
191 fflush(NULL);
192 fout = popen(pagerenv, "w");
193 if (fout)
194 {
195 usePipe = true;
196#ifndef WIN32
197 if (pq_block_sigpipe(&osigset, &sigpipe_pending) == 0)
198 sigpipe_masked = true;
199#endif /* WIN32 */
200 }
201 else
202 fout = stdout;
203 }
204 }
205
206 if (!po->expanded && (po->align || po->html3))
207 {
208 fields = (char **) calloc((size_t) nTups + 1,
209 nFields * sizeof(char *));
210 if (!fields)
211 {
212 fprintf(stderr, libpq_gettext("out of memory\n"));
213 goto exit;
214 }
215 }
216 else if (po->header && !po->html3)
217 {
218 if (po->expanded)
219 {
220 if (po->align)
221 fprintf(fout, libpq_gettext("%-*s%s Value\n"),
222 fieldMaxLen - fs_len, libpq_gettext("Field"), po->fieldSep);
223 else
224 fprintf(fout, libpq_gettext("%s%sValue\n"), libpq_gettext("Field"), po->fieldSep);
225 }
226 else
227 {
228 int len = 0;
229
230 for (j = 0; j < nFields; j++)
231 {
232 const char *s = fieldNames[j];
233
234 fputs(s, fout);
235 len += strlen(s) + fs_len;
236 if ((j + 1) < nFields)
237 fputs(po->fieldSep, fout);
238 }
239 fputc('\n', fout);
240 for (len -= fs_len; len--; fputc('-', fout));
241 fputc('\n', fout);
242 }
243 }
244 if (po->expanded && po->html3)
245 {
246 if (po->caption)
247 fprintf(fout, "<center><h2>%s</h2></center>\n", po->caption);
248 else
249 fprintf(fout,
250 "<center><h2>"
251 "Query retrieved %d rows * %d fields"
252 "</h2></center>\n",
253 nTups, nFields);
254 }
255 for (i = 0; i < nTups; i++)
256 {
257 if (po->expanded)
258 {
259 if (po->html3)
260 fprintf(fout,
261 "<table %s><caption align=\"top\">%d</caption>\n",
262 po->tableOpt ? po->tableOpt : "", i);
263 else
264 fprintf(fout, libpq_gettext("-- RECORD %d --\n"), i);
265 }
266 for (j = 0; j < nFields; j++)
267 {
268 if (!do_field(po, res, i, j, fs_len, fields, nFields,
269 fieldNames, fieldNotNum,
270 fieldMax, fieldMaxLen, fout))
271 goto exit;
272 }
273 if (po->html3 && po->expanded)
274 fputs("</table>\n", fout);
275 }
276 if (!po->expanded && (po->align || po->html3))
277 {
278 if (po->html3)
279 {
280 if (po->header)
281 {
282 if (po->caption)
283 fprintf(fout,
284 "<table %s><caption align=\"top\">%s</caption>\n",
285 po->tableOpt ? po->tableOpt : "",
286 po->caption);
287 else
288 fprintf(fout,
289 "<table %s><caption align=\"top\">"
290 "Retrieved %d rows * %d fields"
291 "</caption>\n",
292 po->tableOpt ? po->tableOpt : "", nTups, nFields);
293 }
294 else
295 fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
296 }
297 if (po->header)
298 border = do_header(fout, po, nFields, fieldMax, fieldNames,
299 fieldNotNum, fs_len, res);
300 for (i = 0; i < nTups; i++)
301 output_row(fout, po, nFields, fields,
302 fieldNotNum, fieldMax, border, i);
303 }
304 if (po->header && !po->html3)
305 fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
306 (PQntuples(res) == 1) ? "" : "s");
307 if (po->html3 && !po->expanded)
308 fputs("</table>\n", fout);
309
310exit:
311 free(fieldMax);
312 free(fieldNotNum);
313 free(border);
314 if (fields)
315 {
316 /* if calloc succeeded, this shouldn't overflow size_t */
317 size_t numfields = ((size_t) nTups + 1) * (size_t) nFields;
318
319 while (numfields-- > 0)
320 free(fields[numfields]);
321 free(fields);
322 }
323 free(fieldNames);
324 if (usePipe)
325 {
326#ifdef WIN32
327 _pclose(fout);
328#else
329 pclose(fout);
330
331 /* we can't easily verify if EPIPE occurred, so say it did */
332 if (sigpipe_masked)
333 pq_reset_sigpipe(&osigset, sigpipe_pending, true);
334#endif /* WIN32 */
335 }
336 }
337}
do_header
static char * do_header(FILE *fout, const PQprintOpt *po, const int nFields, int *fieldMax, const char **fieldNames, unsigned char *fieldNotNum, const int fs_len, const PGresult *res)
Definition: fe-print.c:456
do_field
static bool do_field(const PQprintOpt *po, const PGresult *res, const int i, const int j, const int fs_len, char **fields, const int nFields, const char **fieldNames, unsigned char *fieldNotNum, int *fieldMax, const int fieldMaxLen, FILE *fout)
Definition: fe-print.c:341
output_row
static void output_row(FILE *fout, const PQprintOpt *po, const int nFields, char **fields, unsigned char *fieldNotNum, int *fieldMax, char *border, const int row_index)
Definition: fe-print.c:562
calloc
#define calloc(a, b)
Definition: header.h:55
pq_reset_sigpipe
void pq_reset_sigpipe(sigset_t *osigset, bool sigpipe_pending, bool got_epipe)
Definition: oauth-utils.c:208
pq_block_sigpipe
int pq_block_sigpipe(sigset_t *osigset, bool *sigpipe_pending)
Definition: oauth-utils.c:172
_PQprintOpt::pager
pqbool pager
Definition: libpq-fe.h:254
_PQprintOpt::caption
char * caption
Definition: libpq-fe.h:257
_PQprintOpt::header
pqbool header
Definition: libpq-fe.h:249
_PQprintOpt::fieldName
char ** fieldName
Definition: libpq-fe.h:258
_PQprintOpt::tableOpt
char * tableOpt
Definition: libpq-fe.h:256

References _PQprintOpt::align, calloc, _PQprintOpt::caption, do_field(), do_header(), _PQprintOpt::expanded, _PQprintOpt::fieldName, _PQprintOpt::fieldSep, fprintf, free, _PQprintOpt::header, _PQprintOpt::html3, i, j, len, libpq_gettext, output_row(), _PQprintOpt::pager, pq_block_sigpipe(), pq_reset_sigpipe(), PQfname, PQnfields, PQntuples, _PQprintOpt::standard, generate_unaccent_rules::stdout, and _PQprintOpt::tableOpt.

Referenced by printResultSet().

◆ PQprintTuples()

void PQprintTuples ( const PGresult *  res,
FILE *  fout,
int  PrintAttNames,
int  TerseOutput,
int  colWidth 
)

Definition at line 702 of file fe-print.c.

708{
709 int nFields;
710 int nTups;
711 int i,
712 j;
713 char formatString[80];
714 char *tborder = NULL;
715
716 nFields = PQnfields(res);
717 nTups = PQntuples(res);
718
719 if (colWidth > 0)
720 sprintf(formatString, "%%s %%-%ds", colWidth);
721 else
722 sprintf(formatString, "%%s %%s");
723
724 if (nFields > 0)
725 { /* only print rows with at least 1 field. */
726
727 if (!TerseOutput)
728 {
729 int width;
730
731 width = nFields * 14;
732 tborder = (char *) malloc(width + 1);
733 if (!tborder)
734 {
735 fprintf(stderr, libpq_gettext("out of memory\n"));
736 return;
737 }
738 for (i = 0; i < width; i++)
739 tborder[i] = '-';
740 tborder[width] = '\0';
741 fprintf(fout, "%s\n", tborder);
742 }
743
744 for (i = 0; i < nFields; i++)
745 {
746 if (PrintAttNames)
747 {
748 fprintf(fout, formatString,
749 TerseOutput ? "" : "|",
750 PQfname(res, i));
751 }
752 }
753
754 if (PrintAttNames)
755 {
756 if (TerseOutput)
757 fprintf(fout, "\n");
758 else
759 fprintf(fout, "|\n%s\n", tborder);
760 }
761
762 for (i = 0; i < nTups; i++)
763 {
764 for (j = 0; j < nFields; j++)
765 {
766 const char *pval = PQgetvalue(res, i, j);
767
768 fprintf(fout, formatString,
769 TerseOutput ? "" : "|",
770 pval ? pval : "");
771 }
772 if (TerseOutput)
773 fprintf(fout, "\n");
774 else
775 fprintf(fout, "|\n%s\n", tborder);
776 }
777 }
778
779 free(tborder);
780}
sprintf
#define sprintf
Definition: port.h:262

References fprintf, free, i, j, libpq_gettext, malloc, PQfname, PQgetvalue, PQnfields, PQntuples, and sprintf.