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-2025, 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 "libpq/pqformat.h"
      24             : #include "libpq/protocol.h"
      25             : #include "utils/builtins.h"
      26             : #include "varatt.h"
      27             : 
      28             : /*
      29             :  * At startup time, send a RowDescription message.
      30             :  */
      31             : void
      32        4442 : printsimple_startup(DestReceiver *self, int operation, TupleDesc tupdesc)
      33             : {
      34             :     StringInfoData buf;
      35             :     int         i;
      36             : 
      37        4442 :     pq_beginmessage(&buf, PqMsg_RowDescription);
      38        4442 :     pq_sendint16(&buf, tupdesc->natts);
      39             : 
      40       17192 :     for (i = 0; i < tupdesc->natts; ++i)
      41             :     {
      42       12750 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      43             : 
      44       12750 :         pq_sendstring(&buf, NameStr(attr->attname));
      45       12750 :         pq_sendint32(&buf, 0);  /* table oid */
      46       12750 :         pq_sendint16(&buf, 0);  /* attnum */
      47       12750 :         pq_sendint32(&buf, (int) attr->atttypid);
      48       12750 :         pq_sendint16(&buf, attr->attlen);
      49       12750 :         pq_sendint32(&buf, attr->atttypmod);
      50       12750 :         pq_sendint16(&buf, 0);  /* format code */
      51             :     }
      52             : 
      53        4442 :     pq_endmessage(&buf);
      54        4442 : }
      55             : 
      56             : /*
      57             :  * For each tuple, send a DataRow message.
      58             :  */
      59             : bool
      60        6110 : printsimple(TupleTableSlot *slot, DestReceiver *self)
      61             : {
      62        6110 :     TupleDesc   tupdesc = slot->tts_tupleDescriptor;
      63             :     StringInfoData buf;
      64             :     int         i;
      65             : 
      66             :     /* Make sure the tuple is fully deconstructed */
      67        6110 :     slot_getallattrs(slot);
      68             : 
      69             :     /* Prepare and send message */
      70        6110 :     pq_beginmessage(&buf, PqMsg_DataRow);
      71        6110 :     pq_sendint16(&buf, tupdesc->natts);
      72             : 
      73       23890 :     for (i = 0; i < tupdesc->natts; ++i)
      74             :     {
      75       17780 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      76             :         Datum       value;
      77             : 
      78       17780 :         if (slot->tts_isnull[i])
      79             :         {
      80        2734 :             pq_sendint32(&buf, -1);
      81        2734 :             continue;
      82             :         }
      83             : 
      84       15046 :         value = slot->tts_values[i];
      85             : 
      86             :         /*
      87             :          * We can't call the regular type output functions here because we
      88             :          * might not have catalog access.  Instead, we must hard-wire
      89             :          * knowledge of the required types.
      90             :          */
      91       15046 :         switch (attr->atttypid)
      92             :         {
      93       12538 :             case TEXTOID:
      94             :                 {
      95       12538 :                     text       *t = DatumGetTextPP(value);
      96             : 
      97       12538 :                     pq_sendcountedtext(&buf,
      98       12538 :                                        VARDATA_ANY(t),
      99       12538 :                                        VARSIZE_ANY_EXHDR(t));
     100             :                 }
     101       12538 :                 break;
     102             : 
     103           0 :             case INT4OID:
     104             :                 {
     105           0 :                     int32       num = DatumGetInt32(value);
     106             :                     char        str[12];    /* sign, 10 digits and '\0' */
     107             :                     int         len;
     108             : 
     109           0 :                     len = pg_ltoa(num, str);
     110           0 :                     pq_sendcountedtext(&buf, str, len);
     111             :                 }
     112           0 :                 break;
     113             : 
     114        2436 :             case INT8OID:
     115             :                 {
     116        2436 :                     int64       num = DatumGetInt64(value);
     117             :                     char        str[MAXINT8LEN + 1];
     118             :                     int         len;
     119             : 
     120        2436 :                     len = pg_lltoa(num, str);
     121        2436 :                     pq_sendcountedtext(&buf, str, len);
     122             :                 }
     123        2436 :                 break;
     124             : 
     125          72 :             case OIDOID:
     126             :                 {
     127          72 :                     Oid         num = DatumGetObjectId(value);
     128             :                     char        str[10];    /* 10 digits */
     129             :                     int         len;
     130             : 
     131          72 :                     len = pg_ultoa_n(num, str);
     132          72 :                     pq_sendcountedtext(&buf, str, len);
     133             :                 }
     134          72 :                 break;
     135             : 
     136           0 :             default:
     137           0 :                 elog(ERROR, "unsupported type OID: %u", attr->atttypid);
     138             :         }
     139             :     }
     140             : 
     141        6110 :     pq_endmessage(&buf);
     142             : 
     143        6110 :     return true;
     144             : }