LCOV - code coverage report
Current view: top level - src/backend/access/common - printsimple.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12devel Lines: 41 42 97.6 %
Date: 2018-09-20 15:21:09 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * printsimple.c
       4             :  *    Routines to print out tuples containing only a limited range of
       5             :  *    builtin types without catalog access.  This is intended for
       6             :  *    backends that don't have catalog access because they are not bound
       7             :  *    to a specific database, such as some walsender processes.  It
       8             :  *    doesn't handle standalone backends or protocol versions other than
       9             :  *    3.0, because we don't need such handling for current applications.
      10             :  *
      11             :  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
      12             :  * Portions Copyright (c) 1994, Regents of the University of California
      13             :  *
      14             :  * IDENTIFICATION
      15             :  *    src/backend/access/common/printsimple.c
      16             :  *
      17             :  *-------------------------------------------------------------------------
      18             :  */
      19             : #include "postgres.h"
      20             : 
      21             : #include "access/printsimple.h"
      22             : #include "catalog/pg_type.h"
      23             : #include "fmgr.h"
      24             : #include "libpq/pqformat.h"
      25             : #include "utils/builtins.h"
      26             : 
      27             : /*
      28             :  * At startup time, send a RowDescription message.
      29             :  */
      30             : void
      31         820 : printsimple_startup(DestReceiver *self, int operation, TupleDesc tupdesc)
      32             : {
      33             :     StringInfoData buf;
      34             :     int         i;
      35             : 
      36         820 :     pq_beginmessage(&buf, 'T'); /* RowDescription */
      37         820 :     pq_sendint16(&buf, tupdesc->natts);
      38             : 
      39        3164 :     for (i = 0; i < tupdesc->natts; ++i)
      40             :     {
      41        2344 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      42             : 
      43        2344 :         pq_sendstring(&buf, NameStr(attr->attname));
      44        2344 :         pq_sendint32(&buf, 0);  /* table oid */
      45        2344 :         pq_sendint16(&buf, 0);  /* attnum */
      46        2344 :         pq_sendint32(&buf, (int) attr->atttypid);
      47        2344 :         pq_sendint16(&buf, attr->attlen);
      48        2344 :         pq_sendint32(&buf, attr->atttypmod);
      49        2344 :         pq_sendint16(&buf, 0);  /* format code */
      50             :     }
      51             : 
      52         820 :     pq_endmessage(&buf);
      53         820 : }
      54             : 
      55             : /*
      56             :  * For each tuple, send a DataRow message.
      57             :  */
      58             : bool
      59         820 : printsimple(TupleTableSlot *slot, DestReceiver *self)
      60             : {
      61         820 :     TupleDesc   tupdesc = slot->tts_tupleDescriptor;
      62             :     StringInfoData buf;
      63             :     int         i;
      64             : 
      65             :     /* Make sure the tuple is fully deconstructed */
      66         820 :     slot_getallattrs(slot);
      67             : 
      68             :     /* Prepare and send message */
      69         820 :     pq_beginmessage(&buf, 'D');
      70         820 :     pq_sendint16(&buf, tupdesc->natts);
      71             : 
      72        3164 :     for (i = 0; i < tupdesc->natts; ++i)
      73             :     {
      74        2344 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      75             :         Datum       value;
      76             : 
      77        2344 :         if (slot->tts_isnull[i])
      78             :         {
      79         540 :             pq_sendint32(&buf, -1);
      80         540 :             continue;
      81             :         }
      82             : 
      83        1804 :         value = slot->tts_values[i];
      84             : 
      85             :         /*
      86             :          * We can't call the regular type output functions here because we
      87             :          * might not have catalog access.  Instead, we must hard-wire
      88             :          * knowledge of the required types.
      89             :          */
      90        1804 :         switch (attr->atttypid)
      91             :         {
      92             :             case TEXTOID:
      93             :                 {
      94        1470 :                     text       *t = DatumGetTextPP(value);
      95             : 
      96        5880 :                     pq_sendcountedtext(&buf,
      97        1470 :                                        VARDATA_ANY(t),
      98        4410 :                                        VARSIZE_ANY_EXHDR(t),
      99             :                                        false);
     100             :                 }
     101        1470 :                 break;
     102             : 
     103             :             case INT4OID:
     104             :                 {
     105         322 :                     int32       num = DatumGetInt32(value);
     106             :                     char        str[12];    /* sign, 10 digits and '\0' */
     107             : 
     108         322 :                     pg_ltoa(num, str);
     109         322 :                     pq_sendcountedtext(&buf, str, strlen(str), false);
     110             :                 }
     111         322 :                 break;
     112             : 
     113             :             case INT8OID:
     114             :                 {
     115          12 :                     int64       num = DatumGetInt64(value);
     116             :                     char        str[23];    /* sign, 21 digits and '\0' */
     117             : 
     118          12 :                     pg_lltoa(num, str);
     119          12 :                     pq_sendcountedtext(&buf, str, strlen(str), false);
     120             :                 }
     121          12 :                 break;
     122             : 
     123             :             default:
     124           0 :                 elog(ERROR, "unsupported type OID: %u", attr->atttypid);
     125             :         }
     126             :     }
     127             : 
     128         820 :     pq_endmessage(&buf);
     129             : 
     130         820 :     return true;
     131             : }

Generated by: LCOV version 1.13