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             : 
      27             : /*
      28             :  * At startup time, send a RowDescription message.
      29             :  */
      30             : void
      31        4380 : printsimple_startup(DestReceiver *self, int operation, TupleDesc tupdesc)
      32             : {
      33             :     StringInfoData buf;
      34             :     int         i;
      35             : 
      36        4380 :     pq_beginmessage(&buf, PqMsg_RowDescription);
      37        4380 :     pq_sendint16(&buf, tupdesc->natts);
      38             : 
      39       16900 :     for (i = 0; i < tupdesc->natts; ++i)
      40             :     {
      41       12520 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      42             : 
      43       12520 :         pq_sendstring(&buf, NameStr(attr->attname));
      44       12520 :         pq_sendint32(&buf, 0);  /* table oid */
      45       12520 :         pq_sendint16(&buf, 0);  /* attnum */
      46       12520 :         pq_sendint32(&buf, (int) attr->atttypid);
      47       12520 :         pq_sendint16(&buf, attr->attlen);
      48       12520 :         pq_sendint32(&buf, attr->atttypmod);
      49       12520 :         pq_sendint16(&buf, 0);  /* format code */
      50             :     }
      51             : 
      52        4380 :     pq_endmessage(&buf);
      53        4380 : }
      54             : 
      55             : /*
      56             :  * For each tuple, send a DataRow message.
      57             :  */
      58             : bool
      59        6032 : printsimple(TupleTableSlot *slot, DestReceiver *self)
      60             : {
      61        6032 :     TupleDesc   tupdesc = slot->tts_tupleDescriptor;
      62             :     StringInfoData buf;
      63             :     int         i;
      64             : 
      65             :     /* Make sure the tuple is fully deconstructed */
      66        6032 :     slot_getallattrs(slot);
      67             : 
      68             :     /* Prepare and send message */
      69        6032 :     pq_beginmessage(&buf, PqMsg_DataRow);
      70        6032 :     pq_sendint16(&buf, tupdesc->natts);
      71             : 
      72       23536 :     for (i = 0; i < tupdesc->natts; ++i)
      73             :     {
      74       17504 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
      75             :         Datum       value;
      76             : 
      77       17504 :         if (slot->tts_isnull[i])
      78             :         {
      79        2718 :             pq_sendint32(&buf, -1);
      80        2718 :             continue;
      81             :         }
      82             : 
      83       14786 :         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       14786 :         switch (attr->atttypid)
      91             :         {
      92       12322 :             case TEXTOID:
      93             :                 {
      94       12322 :                     text       *t = DatumGetTextPP(value);
      95             : 
      96       24644 :                     pq_sendcountedtext(&buf,
      97       12322 :                                        VARDATA_ANY(t),
      98       12322 :                                        VARSIZE_ANY_EXHDR(t));
      99             :                 }
     100       12322 :                 break;
     101             : 
     102           0 :             case INT4OID:
     103             :                 {
     104           0 :                     int32       num = DatumGetInt32(value);
     105             :                     char        str[12];    /* sign, 10 digits and '\0' */
     106             :                     int         len;
     107             : 
     108           0 :                     len = pg_ltoa(num, str);
     109           0 :                     pq_sendcountedtext(&buf, str, len);
     110             :                 }
     111           0 :                 break;
     112             : 
     113        2390 :             case INT8OID:
     114             :                 {
     115        2390 :                     int64       num = DatumGetInt64(value);
     116             :                     char        str[MAXINT8LEN + 1];
     117             :                     int         len;
     118             : 
     119        2390 :                     len = pg_lltoa(num, str);
     120        2390 :                     pq_sendcountedtext(&buf, str, len);
     121             :                 }
     122        2390 :                 break;
     123             : 
     124          74 :             case OIDOID:
     125             :                 {
     126          74 :                     Oid         num = ObjectIdGetDatum(value);
     127             :                     char        str[10];    /* 10 digits */
     128             :                     int         len;
     129             : 
     130          74 :                     len = pg_ultoa_n(num, str);
     131          74 :                     pq_sendcountedtext(&buf, str, len);
     132             :                 }
     133          74 :                 break;
     134             : 
     135           0 :             default:
     136           0 :                 elog(ERROR, "unsupported type OID: %u", attr->atttypid);
     137             :         }
     138             :     }
     139             : 
     140        6032 :     pq_endmessage(&buf);
     141             : 
     142        6032 :     return true;
     143             : }