LCOV - code coverage report
Current view: top level - src/interfaces/libpq - fe-print.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 0 331 0.0 %
Date: 2019-11-13 22:07:24 Functions: 0 7 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * fe-print.c
       4             :  *    functions for pretty-printing query results
       5             :  *
       6             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * These functions were formerly part of fe-exec.c, but they
      10             :  * didn't really belong there.
      11             :  *
      12             :  * IDENTIFICATION
      13             :  *    src/interfaces/libpq/fe-print.c
      14             :  *
      15             :  *-------------------------------------------------------------------------
      16             :  */
      17             : #include "postgres_fe.h"
      18             : 
      19             : #include <signal.h>
      20             : 
      21             : #ifdef WIN32
      22             : #include "win32.h"
      23             : #else
      24             : #include <unistd.h>
      25             : #include <sys/ioctl.h>
      26             : #endif
      27             : 
      28             : #ifdef HAVE_TERMIOS_H
      29             : #include <termios.h>
      30             : #else
      31             : #ifndef WIN32
      32             : #include <sys/termios.h>
      33             : #endif
      34             : #endif
      35             : 
      36             : #include "libpq-fe.h"
      37             : #include "libpq-int.h"
      38             : 
      39             : 
      40             : static void do_field(const PQprintOpt *po, const PGresult *res,
      41             :                      const int i, const int j, const int fs_len,
      42             :                      char **fields,
      43             :                      const int nFields, const char **fieldNames,
      44             :                      unsigned char *fieldNotNum, int *fieldMax,
      45             :                      const int fieldMaxLen, FILE *fout);
      46             : static char *do_header(FILE *fout, const PQprintOpt *po, const int nFields,
      47             :                        int *fieldMax, const char **fieldNames, unsigned char *fieldNotNum,
      48             :                        const int fs_len, const PGresult *res);
      49             : static void output_row(FILE *fout, const PQprintOpt *po, const int nFields, char **fields,
      50             :                        unsigned char *fieldNotNum, int *fieldMax, char *border,
      51             :                        const int row_index);
      52             : static void fill(int length, int max, char filler, FILE *fp);
      53             : 
      54             : /*
      55             :  * PQprint()
      56             :  *
      57             :  * Format results of a query for printing.
      58             :  *
      59             :  * PQprintOpt is a typedef (structure) that contains
      60             :  * various flags and options. consult libpq-fe.h for
      61             :  * details
      62             :  *
      63             :  * This function should probably be removed sometime since psql
      64             :  * doesn't use it anymore. It is unclear to what extent this is used
      65             :  * by external clients, however.
      66             :  */
      67             : void
      68           0 : PQprint(FILE *fout, const PGresult *res, const PQprintOpt *po)
      69             : {
      70             :     int         nFields;
      71             : 
      72           0 :     nFields = PQnfields(res);
      73             : 
      74           0 :     if (nFields > 0)
      75             :     {                           /* only print rows with at least 1 field.  */
      76             :         int         i,
      77             :                     j;
      78             :         int         nTups;
      79           0 :         int        *fieldMax = NULL;    /* in case we don't use them */
      80           0 :         unsigned char *fieldNotNum = NULL;
      81           0 :         char       *border = NULL;
      82           0 :         char      **fields = NULL;
      83             :         const char **fieldNames;
      84           0 :         int         fieldMaxLen = 0;
      85             :         int         numFieldName;
      86           0 :         int         fs_len = strlen(po->fieldSep);
      87           0 :         int         total_line_length = 0;
      88           0 :         int         usePipe = 0;
      89             :         char       *pagerenv;
      90             : 
      91             : #if defined(ENABLE_THREAD_SAFETY) && !defined(WIN32)
      92             :         sigset_t    osigset;
      93           0 :         bool        sigpipe_masked = false;
      94             :         bool        sigpipe_pending;
      95             : #endif
      96             : #if !defined(ENABLE_THREAD_SAFETY) && !defined(WIN32)
      97             :         pqsigfunc   oldsigpipehandler = NULL;
      98             : #endif
      99             : 
     100             : #ifdef TIOCGWINSZ
     101             :         struct winsize screen_size;
     102             : #else
     103             :         struct winsize
     104             :         {
     105             :             int         ws_row;
     106             :             int         ws_col;
     107             :         }           screen_size;
     108             : #endif
     109             : 
     110           0 :         nTups = PQntuples(res);
     111           0 :         if (!(fieldNames = (const char **) calloc(nFields, sizeof(char *))))
     112             :         {
     113           0 :             fprintf(stderr, libpq_gettext("out of memory\n"));
     114           0 :             abort();
     115             :         }
     116           0 :         if (!(fieldNotNum = (unsigned char *) calloc(nFields, 1)))
     117             :         {
     118           0 :             fprintf(stderr, libpq_gettext("out of memory\n"));
     119           0 :             abort();
     120             :         }
     121           0 :         if (!(fieldMax = (int *) calloc(nFields, sizeof(int))))
     122             :         {
     123           0 :             fprintf(stderr, libpq_gettext("out of memory\n"));
     124           0 :             abort();
     125             :         }
     126           0 :         for (numFieldName = 0;
     127           0 :              po->fieldName && po->fieldName[numFieldName];
     128           0 :              numFieldName++)
     129             :             ;
     130           0 :         for (j = 0; j < nFields; j++)
     131             :         {
     132             :             int         len;
     133           0 :             const char *s = (j < numFieldName && po->fieldName[j][0]) ?
     134           0 :             po->fieldName[j] : PQfname(res, j);
     135             : 
     136           0 :             fieldNames[j] = s;
     137           0 :             len = s ? strlen(s) : 0;
     138           0 :             fieldMax[j] = len;
     139           0 :             len += fs_len;
     140           0 :             if (len > fieldMaxLen)
     141           0 :                 fieldMaxLen = len;
     142           0 :             total_line_length += len;
     143             :         }
     144             : 
     145           0 :         total_line_length += nFields * strlen(po->fieldSep) + 1;
     146             : 
     147           0 :         if (fout == NULL)
     148           0 :             fout = stdout;
     149           0 :         if (po->pager && fout == stdout && isatty(fileno(stdin)) &&
     150           0 :             isatty(fileno(stdout)))
     151             :         {
     152             :             /*
     153             :              * If we think there'll be more than one screen of output, try to
     154             :              * pipe to the pager program.
     155             :              */
     156             : #ifdef TIOCGWINSZ
     157           0 :             if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
     158           0 :                 screen_size.ws_col == 0 ||
     159           0 :                 screen_size.ws_row == 0)
     160             :             {
     161           0 :                 screen_size.ws_row = 24;
     162           0 :                 screen_size.ws_col = 80;
     163             :             }
     164             : #else
     165             :             screen_size.ws_row = 24;
     166             :             screen_size.ws_col = 80;
     167             : #endif
     168             : 
     169             :             /*
     170             :              * Since this function is no longer used by psql, we don't examine
     171             :              * PSQL_PAGER.  It's possible that the hypothetical external users
     172             :              * of the function would like that to happen, but in the name of
     173             :              * backwards compatibility, we'll stick to just examining PAGER.
     174             :              */
     175           0 :             pagerenv = getenv("PAGER");
     176             :             /* if PAGER is unset, empty or all-white-space, don't use pager */
     177           0 :             if (pagerenv != NULL &&
     178           0 :                 strspn(pagerenv, " \t\r\n") != strlen(pagerenv) &&
     179           0 :                 !po->html3 &&
     180           0 :                 ((po->expanded &&
     181           0 :                   nTups * (nFields + 1) >= screen_size.ws_row) ||
     182           0 :                  (!po->expanded &&
     183           0 :                   nTups * (total_line_length / screen_size.ws_col + 1) *
     184           0 :                   (1 + (po->standard != 0)) >= screen_size.ws_row -
     185           0 :                   (po->header != 0) *
     186           0 :                   (total_line_length / screen_size.ws_col + 1) * 2
     187           0 :                   - (po->header != 0) * 2    /* row count and newline */
     188             :                   )))
     189             :             {
     190           0 :                 fout = popen(pagerenv, "w");
     191           0 :                 if (fout)
     192             :                 {
     193           0 :                     usePipe = 1;
     194             : #ifndef WIN32
     195             : #ifdef ENABLE_THREAD_SAFETY
     196           0 :                     if (pq_block_sigpipe(&osigset, &sigpipe_pending) == 0)
     197           0 :                         sigpipe_masked = true;
     198             : #else
     199             :                     oldsigpipehandler = pqsignal(SIGPIPE, SIG_IGN);
     200             : #endif                          /* ENABLE_THREAD_SAFETY */
     201             : #endif                          /* WIN32 */
     202             :                 }
     203             :                 else
     204           0 :                     fout = stdout;
     205             :             }
     206             :         }
     207             : 
     208           0 :         if (!po->expanded && (po->align || po->html3))
     209             :         {
     210           0 :             if (!(fields = (char **) calloc(nFields * (nTups + 1), sizeof(char *))))
     211             :             {
     212           0 :                 fprintf(stderr, libpq_gettext("out of memory\n"));
     213           0 :                 abort();
     214             :             }
     215             :         }
     216           0 :         else if (po->header && !po->html3)
     217             :         {
     218           0 :             if (po->expanded)
     219             :             {
     220           0 :                 if (po->align)
     221           0 :                     fprintf(fout, libpq_gettext("%-*s%s Value\n"),
     222             :                             fieldMaxLen - fs_len, libpq_gettext("Field"), po->fieldSep);
     223             :                 else
     224           0 :                     fprintf(fout, libpq_gettext("%s%sValue\n"), libpq_gettext("Field"), po->fieldSep);
     225             :             }
     226             :             else
     227             :             {
     228           0 :                 int         len = 0;
     229             : 
     230           0 :                 for (j = 0; j < nFields; j++)
     231             :                 {
     232           0 :                     const char *s = fieldNames[j];
     233             : 
     234           0 :                     fputs(s, fout);
     235           0 :                     len += strlen(s) + fs_len;
     236           0 :                     if ((j + 1) < nFields)
     237           0 :                         fputs(po->fieldSep, fout);
     238             :                 }
     239           0 :                 fputc('\n', fout);
     240           0 :                 for (len -= fs_len; len--; fputc('-', fout));
     241           0 :                 fputc('\n', fout);
     242             :             }
     243             :         }
     244           0 :         if (po->expanded && po->html3)
     245             :         {
     246           0 :             if (po->caption)
     247           0 :                 fprintf(fout, "<center><h2>%s</h2></center>\n", po->caption);
     248             :             else
     249           0 :                 fprintf(fout,
     250             :                         "<center><h2>"
     251             :                         "Query retrieved %d rows * %d fields"
     252             :                         "</h2></center>\n",
     253             :                         nTups, nFields);
     254             :         }
     255           0 :         for (i = 0; i < nTups; i++)
     256             :         {
     257           0 :             if (po->expanded)
     258             :             {
     259           0 :                 if (po->html3)
     260           0 :                     fprintf(fout,
     261             :                             "<table %s><caption align=\"top\">%d</caption>\n",
     262           0 :                             po->tableOpt ? po->tableOpt : "", i);
     263             :                 else
     264           0 :                     fprintf(fout, libpq_gettext("-- RECORD %d --\n"), i);
     265             :             }
     266           0 :             for (j = 0; j < nFields; j++)
     267           0 :                 do_field(po, res, i, j, fs_len, fields, nFields,
     268             :                          fieldNames, fieldNotNum,
     269             :                          fieldMax, fieldMaxLen, fout);
     270           0 :             if (po->html3 && po->expanded)
     271           0 :                 fputs("</table>\n", fout);
     272             :         }
     273           0 :         if (!po->expanded && (po->align || po->html3))
     274             :         {
     275           0 :             if (po->html3)
     276             :             {
     277           0 :                 if (po->header)
     278             :                 {
     279           0 :                     if (po->caption)
     280           0 :                         fprintf(fout,
     281             :                                 "<table %s><caption align=\"top\">%s</caption>\n",
     282           0 :                                 po->tableOpt ? po->tableOpt : "",
     283             :                                 po->caption);
     284             :                     else
     285           0 :                         fprintf(fout,
     286             :                                 "<table %s><caption align=\"top\">"
     287             :                                 "Retrieved %d rows * %d fields"
     288             :                                 "</caption>\n",
     289           0 :                                 po->tableOpt ? po->tableOpt : "", nTups, nFields);
     290             :                 }
     291             :                 else
     292           0 :                     fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
     293             :             }
     294           0 :             if (po->header)
     295           0 :                 border = do_header(fout, po, nFields, fieldMax, fieldNames,
     296             :                                    fieldNotNum, fs_len, res);
     297           0 :             for (i = 0; i < nTups; i++)
     298           0 :                 output_row(fout, po, nFields, fields,
     299             :                            fieldNotNum, fieldMax, border, i);
     300           0 :             free(fields);
     301           0 :             if (border)
     302           0 :                 free(border);
     303             :         }
     304           0 :         if (po->header && !po->html3)
     305           0 :             fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
     306           0 :                     (PQntuples(res) == 1) ? "" : "s");
     307           0 :         if (po->html3 && !po->expanded)
     308           0 :             fputs("</table>\n", fout);
     309           0 :         free(fieldMax);
     310           0 :         free(fieldNotNum);
     311           0 :         free((void *) fieldNames);
     312           0 :         if (usePipe)
     313             :         {
     314             : #ifdef WIN32
     315             :             _pclose(fout);
     316             : #else
     317           0 :             pclose(fout);
     318             : 
     319             : #ifdef ENABLE_THREAD_SAFETY
     320             :             /* we can't easily verify if EPIPE occurred, so say it did */
     321           0 :             if (sigpipe_masked)
     322           0 :                 pq_reset_sigpipe(&osigset, sigpipe_pending, true);
     323             : #else
     324             :             pqsignal(SIGPIPE, oldsigpipehandler);
     325             : #endif                          /* ENABLE_THREAD_SAFETY */
     326             : #endif                          /* WIN32 */
     327             :         }
     328             :     }
     329           0 : }
     330             : 
     331             : 
     332             : static void
     333           0 : do_field(const PQprintOpt *po, const PGresult *res,
     334             :          const int i, const int j, const int fs_len,
     335             :          char **fields,
     336             :          const int nFields, char const **fieldNames,
     337             :          unsigned char *fieldNotNum, int *fieldMax,
     338             :          const int fieldMaxLen, FILE *fout)
     339             : {
     340             :     const char *pval,
     341             :                *p;
     342             :     int         plen;
     343             :     bool        skipit;
     344             : 
     345           0 :     plen = PQgetlength(res, i, j);
     346           0 :     pval = PQgetvalue(res, i, j);
     347             : 
     348           0 :     if (plen < 1 || !pval || !*pval)
     349             :     {
     350           0 :         if (po->align || po->expanded)
     351           0 :             skipit = true;
     352             :         else
     353             :         {
     354           0 :             skipit = false;
     355           0 :             goto efield;
     356             :         }
     357             :     }
     358             :     else
     359           0 :         skipit = false;
     360             : 
     361           0 :     if (!skipit)
     362             :     {
     363           0 :         if (po->align && !fieldNotNum[j])
     364             :         {
     365             :             /* Detect whether field contains non-numeric data */
     366           0 :             char        ch = '0';
     367             : 
     368           0 :             for (p = pval; *p; p += PQmblen(p, res->client_encoding))
     369             :             {
     370           0 :                 ch = *p;
     371           0 :                 if (!((ch >= '0' && ch <= '9') ||
     372           0 :                       ch == '.' ||
     373           0 :                       ch == 'E' ||
     374           0 :                       ch == 'e' ||
     375             :                       ch == ' ' ||
     376             :                       ch == '-'))
     377             :                 {
     378           0 :                     fieldNotNum[j] = 1;
     379           0 :                     break;
     380             :                 }
     381             :             }
     382             : 
     383             :             /*
     384             :              * Above loop will believe E in first column is numeric; also, we
     385             :              * insist on a digit in the last column for a numeric. This test
     386             :              * is still not bulletproof but it handles most cases.
     387             :              */
     388           0 :             if (*pval == 'E' || *pval == 'e' ||
     389           0 :                 !(ch >= '0' && ch <= '9'))
     390           0 :                 fieldNotNum[j] = 1;
     391             :         }
     392             : 
     393           0 :         if (!po->expanded && (po->align || po->html3))
     394             :         {
     395           0 :             if (plen > fieldMax[j])
     396           0 :                 fieldMax[j] = plen;
     397           0 :             if (!(fields[i * nFields + j] = (char *) malloc(plen + 1)))
     398             :             {
     399           0 :                 fprintf(stderr, libpq_gettext("out of memory\n"));
     400           0 :                 abort();
     401             :             }
     402           0 :             strcpy(fields[i * nFields + j], pval);
     403             :         }
     404             :         else
     405             :         {
     406           0 :             if (po->expanded)
     407             :             {
     408           0 :                 if (po->html3)
     409           0 :                     fprintf(fout,
     410             :                             "<tr><td align=\"left\"><b>%s</b></td>"
     411             :                             "<td align=\"%s\">%s</td></tr>\n",
     412           0 :                             fieldNames[j],
     413           0 :                             fieldNotNum[j] ? "left" : "right",
     414             :                             pval);
     415             :                 else
     416             :                 {
     417           0 :                     if (po->align)
     418           0 :                         fprintf(fout,
     419             :                                 "%-*s%s %s\n",
     420           0 :                                 fieldMaxLen - fs_len, fieldNames[j],
     421             :                                 po->fieldSep,
     422             :                                 pval);
     423             :                     else
     424           0 :                         fprintf(fout,
     425             :                                 "%s%s%s\n",
     426           0 :                                 fieldNames[j], po->fieldSep, pval);
     427             :                 }
     428             :             }
     429             :             else
     430             :             {
     431           0 :                 if (!po->html3)
     432             :                 {
     433           0 :                     fputs(pval, fout);
     434             :             efield:
     435           0 :                     if ((j + 1) < nFields)
     436           0 :                         fputs(po->fieldSep, fout);
     437             :                     else
     438           0 :                         fputc('\n', fout);
     439             :                 }
     440             :             }
     441             :         }
     442             :     }
     443           0 : }
     444             : 
     445             : 
     446             : static char *
     447           0 : do_header(FILE *fout, const PQprintOpt *po, const int nFields, int *fieldMax,
     448             :           const char **fieldNames, unsigned char *fieldNotNum,
     449             :           const int fs_len, const PGresult *res)
     450             : {
     451             :     int         j;              /* for loop index */
     452           0 :     char       *border = NULL;
     453             : 
     454           0 :     if (po->html3)
     455           0 :         fputs("<tr>", fout);
     456             :     else
     457             :     {
     458           0 :         int         tot = 0;
     459           0 :         int         n = 0;
     460           0 :         char       *p = NULL;
     461             : 
     462           0 :         for (; n < nFields; n++)
     463           0 :             tot += fieldMax[n] + fs_len + (po->standard ? 2 : 0);
     464           0 :         if (po->standard)
     465           0 :             tot += fs_len * 2 + 2;
     466           0 :         border = malloc(tot + 1);
     467           0 :         if (!border)
     468             :         {
     469           0 :             fprintf(stderr, libpq_gettext("out of memory\n"));
     470           0 :             abort();
     471             :         }
     472           0 :         p = border;
     473           0 :         if (po->standard)
     474             :         {
     475           0 :             char       *fs = po->fieldSep;
     476             : 
     477           0 :             while (*fs++)
     478           0 :                 *p++ = '+';
     479             :         }
     480           0 :         for (j = 0; j < nFields; j++)
     481             :         {
     482             :             int         len;
     483             : 
     484           0 :             for (len = fieldMax[j] + (po->standard ? 2 : 0); len--; *p++ = '-');
     485           0 :             if (po->standard || (j + 1) < nFields)
     486             :             {
     487           0 :                 char       *fs = po->fieldSep;
     488             : 
     489           0 :                 while (*fs++)
     490           0 :                     *p++ = '+';
     491             :             }
     492             :         }
     493           0 :         *p = '\0';
     494           0 :         if (po->standard)
     495           0 :             fprintf(fout, "%s\n", border);
     496             :     }
     497           0 :     if (po->standard)
     498           0 :         fputs(po->fieldSep, fout);
     499           0 :     for (j = 0; j < nFields; j++)
     500             :     {
     501           0 :         const char *s = PQfname(res, j);
     502             : 
     503           0 :         if (po->html3)
     504             :         {
     505           0 :             fprintf(fout, "<th align=\"%s\">%s</th>",
     506           0 :                     fieldNotNum[j] ? "left" : "right", fieldNames[j]);
     507             :         }
     508             :         else
     509             :         {
     510           0 :             int         n = strlen(s);
     511             : 
     512           0 :             if (n > fieldMax[j])
     513           0 :                 fieldMax[j] = n;
     514           0 :             if (po->standard)
     515           0 :                 fprintf(fout,
     516           0 :                         fieldNotNum[j] ? " %-*s " : " %*s ",
     517           0 :                         fieldMax[j], s);
     518             :             else
     519           0 :                 fprintf(fout, fieldNotNum[j] ? "%-*s" : "%*s", fieldMax[j], s);
     520           0 :             if (po->standard || (j + 1) < nFields)
     521           0 :                 fputs(po->fieldSep, fout);
     522             :         }
     523             :     }
     524           0 :     if (po->html3)
     525           0 :         fputs("</tr>\n", fout);
     526             :     else
     527           0 :         fprintf(fout, "\n%s\n", border);
     528           0 :     return border;
     529             : }
     530             : 
     531             : 
     532             : static void
     533           0 : output_row(FILE *fout, const PQprintOpt *po, const int nFields, char **fields,
     534             :            unsigned char *fieldNotNum, int *fieldMax, char *border,
     535             :            const int row_index)
     536             : {
     537             :     int         field_index;    /* for loop index */
     538             : 
     539           0 :     if (po->html3)
     540           0 :         fputs("<tr>", fout);
     541           0 :     else if (po->standard)
     542           0 :         fputs(po->fieldSep, fout);
     543           0 :     for (field_index = 0; field_index < nFields; field_index++)
     544             :     {
     545           0 :         char       *p = fields[row_index * nFields + field_index];
     546             : 
     547           0 :         if (po->html3)
     548           0 :             fprintf(fout, "<td align=\"%s\">%s</td>",
     549           0 :                     fieldNotNum[field_index] ? "left" : "right", p ? p : "");
     550             :         else
     551             :         {
     552           0 :             fprintf(fout,
     553           0 :                     fieldNotNum[field_index] ?
     554           0 :                     (po->standard ? " %-*s " : "%-*s") :
     555           0 :                     (po->standard ? " %*s " : "%*s"),
     556           0 :                     fieldMax[field_index],
     557             :                     p ? p : "");
     558           0 :             if (po->standard || field_index + 1 < nFields)
     559           0 :                 fputs(po->fieldSep, fout);
     560             :         }
     561           0 :         if (p)
     562           0 :             free(p);
     563             :     }
     564           0 :     if (po->html3)
     565           0 :         fputs("</tr>", fout);
     566           0 :     else if (po->standard)
     567           0 :         fprintf(fout, "\n%s", border);
     568           0 :     fputc('\n', fout);
     569           0 : }
     570             : 
     571             : 
     572             : 
     573             : /*
     574             :  * really old printing routines
     575             :  */
     576             : 
     577             : void
     578           0 : PQdisplayTuples(const PGresult *res,
     579             :                 FILE *fp,       /* where to send the output */
     580             :                 int fillAlign,  /* pad the fields with spaces */
     581             :                 const char *fieldSep,   /* field separator */
     582             :                 int printHeader,    /* display headers? */
     583             :                 int quiet
     584             : )
     585             : {
     586             : #define DEFAULT_FIELD_SEP " "
     587             : 
     588             :     int         i,
     589             :                 j;
     590             :     int         nFields;
     591             :     int         nTuples;
     592           0 :     int        *fLength = NULL;
     593             : 
     594           0 :     if (fieldSep == NULL)
     595           0 :         fieldSep = DEFAULT_FIELD_SEP;
     596             : 
     597             :     /* Get some useful info about the results */
     598           0 :     nFields = PQnfields(res);
     599           0 :     nTuples = PQntuples(res);
     600             : 
     601           0 :     if (fp == NULL)
     602           0 :         fp = stdout;
     603             : 
     604             :     /* Figure the field lengths to align to */
     605             :     /* will be somewhat time consuming for very large results */
     606           0 :     if (fillAlign)
     607             :     {
     608           0 :         fLength = (int *) malloc(nFields * sizeof(int));
     609           0 :         if (!fLength)
     610             :         {
     611           0 :             fprintf(stderr, libpq_gettext("out of memory\n"));
     612           0 :             abort();
     613             :         }
     614             : 
     615           0 :         for (j = 0; j < nFields; j++)
     616             :         {
     617           0 :             fLength[j] = strlen(PQfname(res, j));
     618           0 :             for (i = 0; i < nTuples; i++)
     619             :             {
     620           0 :                 int         flen = PQgetlength(res, i, j);
     621             : 
     622           0 :                 if (flen > fLength[j])
     623           0 :                     fLength[j] = flen;
     624             :             }
     625             :         }
     626             :     }
     627             : 
     628           0 :     if (printHeader)
     629             :     {
     630             :         /* first, print out the attribute names */
     631           0 :         for (i = 0; i < nFields; i++)
     632             :         {
     633           0 :             fputs(PQfname(res, i), fp);
     634           0 :             if (fillAlign)
     635           0 :                 fill(strlen(PQfname(res, i)), fLength[i], ' ', fp);
     636           0 :             fputs(fieldSep, fp);
     637             :         }
     638           0 :         fprintf(fp, "\n");
     639             : 
     640             :         /* Underline the attribute names */
     641           0 :         for (i = 0; i < nFields; i++)
     642             :         {
     643           0 :             if (fillAlign)
     644           0 :                 fill(0, fLength[i], '-', fp);
     645           0 :             fputs(fieldSep, fp);
     646             :         }
     647           0 :         fprintf(fp, "\n");
     648             :     }
     649             : 
     650             :     /* next, print out the instances */
     651           0 :     for (i = 0; i < nTuples; i++)
     652             :     {
     653           0 :         for (j = 0; j < nFields; j++)
     654             :         {
     655           0 :             fprintf(fp, "%s", PQgetvalue(res, i, j));
     656           0 :             if (fillAlign)
     657           0 :                 fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp);
     658           0 :             fputs(fieldSep, fp);
     659             :         }
     660           0 :         fprintf(fp, "\n");
     661             :     }
     662             : 
     663           0 :     if (!quiet)
     664           0 :         fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
     665           0 :                 (PQntuples(res) == 1) ? "" : "s");
     666             : 
     667           0 :     fflush(fp);
     668             : 
     669           0 :     if (fLength)
     670           0 :         free(fLength);
     671           0 : }
     672             : 
     673             : 
     674             : 
     675             : void
     676           0 : PQprintTuples(const PGresult *res,
     677             :               FILE *fout,       /* output stream */
     678             :               int PrintAttNames,    /* print attribute names or not */
     679             :               int TerseOutput,  /* delimiter bars or not? */
     680             :               int colWidth      /* width of column, if 0, use variable width */
     681             : )
     682             : {
     683             :     int         nFields;
     684             :     int         nTups;
     685             :     int         i,
     686             :                 j;
     687             :     char        formatString[80];
     688           0 :     char       *tborder = NULL;
     689             : 
     690           0 :     nFields = PQnfields(res);
     691           0 :     nTups = PQntuples(res);
     692             : 
     693           0 :     if (colWidth > 0)
     694           0 :         sprintf(formatString, "%%s %%-%ds", colWidth);
     695             :     else
     696           0 :         sprintf(formatString, "%%s %%s");
     697             : 
     698           0 :     if (nFields > 0)
     699             :     {                           /* only print rows with at least 1 field.  */
     700             : 
     701           0 :         if (!TerseOutput)
     702             :         {
     703             :             int         width;
     704             : 
     705           0 :             width = nFields * 14;
     706           0 :             tborder = (char *) malloc(width + 1);
     707           0 :             if (!tborder)
     708             :             {
     709           0 :                 fprintf(stderr, libpq_gettext("out of memory\n"));
     710           0 :                 abort();
     711             :             }
     712           0 :             for (i = 0; i < width; i++)
     713           0 :                 tborder[i] = '-';
     714           0 :             tborder[width] = '\0';
     715           0 :             fprintf(fout, "%s\n", tborder);
     716             :         }
     717             : 
     718           0 :         for (i = 0; i < nFields; i++)
     719             :         {
     720           0 :             if (PrintAttNames)
     721             :             {
     722           0 :                 fprintf(fout, formatString,
     723             :                         TerseOutput ? "" : "|",
     724             :                         PQfname(res, i));
     725             :             }
     726             :         }
     727             : 
     728           0 :         if (PrintAttNames)
     729             :         {
     730           0 :             if (TerseOutput)
     731           0 :                 fprintf(fout, "\n");
     732             :             else
     733           0 :                 fprintf(fout, "|\n%s\n", tborder);
     734             :         }
     735             : 
     736           0 :         for (i = 0; i < nTups; i++)
     737             :         {
     738           0 :             for (j = 0; j < nFields; j++)
     739             :             {
     740           0 :                 const char *pval = PQgetvalue(res, i, j);
     741             : 
     742           0 :                 fprintf(fout, formatString,
     743             :                         TerseOutput ? "" : "|",
     744             :                         pval ? pval : "");
     745             :             }
     746           0 :             if (TerseOutput)
     747           0 :                 fprintf(fout, "\n");
     748             :             else
     749           0 :                 fprintf(fout, "|\n%s\n", tborder);
     750             :         }
     751             :     }
     752             : 
     753           0 :     if (tborder)
     754           0 :         free(tborder);
     755           0 : }
     756             : 
     757             : 
     758             : /* simply send out max-length number of filler characters to fp */
     759             : 
     760             : static void
     761           0 : fill(int length, int max, char filler, FILE *fp)
     762             : {
     763             :     int         count;
     764             : 
     765           0 :     count = max - length;
     766           0 :     while (count-- >= 0)
     767           0 :         putc(filler, fp);
     768           0 : }

Generated by: LCOV version 1.13