LCOV - code coverage report
Current view: top level - src/backend/nodes - readfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18beta1 Lines: 226 255 88.6 %
Date: 2025-06-07 12:18:21 Functions: 13 15 86.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * readfuncs.c
       4             :  *    Reader functions for Postgres tree nodes.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/nodes/readfuncs.c
      12             :  *
      13             :  * NOTES
      14             :  *    Parse location fields are written out by outfuncs.c, but only for
      15             :  *    debugging use.  When reading a location field, we normally discard
      16             :  *    the stored value and set the location field to -1 (ie, "unknown").
      17             :  *    This is because nodes coming from a stored rule should not be thought
      18             :  *    to have a known location in the current query's text.
      19             :  *
      20             :  *    However, if restore_location_fields is true, we do restore location
      21             :  *    fields from the string.  This is currently intended only for use by the
      22             :  *    debug_write_read_parse_plan_trees test code, which doesn't want to cause
      23             :  *    any change in the node contents.
      24             :  *
      25             :  *-------------------------------------------------------------------------
      26             :  */
      27             : #include "postgres.h"
      28             : 
      29             : #include <math.h>
      30             : 
      31             : #include "miscadmin.h"
      32             : #include "nodes/bitmapset.h"
      33             : #include "nodes/readfuncs.h"
      34             : 
      35             : 
      36             : /*
      37             :  * Macros to simplify reading of different kinds of fields.  Use these
      38             :  * wherever possible to reduce the chance for silly typos.  Note that these
      39             :  * hard-wire conventions about the names of the local variables in a Read
      40             :  * routine.
      41             :  */
      42             : 
      43             : /* Macros for declaring appropriate local variables */
      44             : 
      45             : /* A few guys need only local_node */
      46             : #define READ_LOCALS_NO_FIELDS(nodeTypeName) \
      47             :     nodeTypeName *local_node = makeNode(nodeTypeName)
      48             : 
      49             : /* And a few guys need only the pg_strtok support fields */
      50             : #define READ_TEMP_LOCALS()  \
      51             :     const char *token;      \
      52             :     int         length
      53             : 
      54             : /* ... but most need both */
      55             : #define READ_LOCALS(nodeTypeName)           \
      56             :     READ_LOCALS_NO_FIELDS(nodeTypeName);    \
      57             :     READ_TEMP_LOCALS()
      58             : 
      59             : /* Read an integer field (anything written as ":fldname %d") */
      60             : #define READ_INT_FIELD(fldname) \
      61             :     token = pg_strtok(&length);     /* skip :fldname */ \
      62             :     token = pg_strtok(&length);     /* get field value */ \
      63             :     local_node->fldname = atoi(token)
      64             : 
      65             : /* Read an unsigned integer field (anything written as ":fldname %u") */
      66             : #define READ_UINT_FIELD(fldname) \
      67             :     token = pg_strtok(&length);     /* skip :fldname */ \
      68             :     token = pg_strtok(&length);     /* get field value */ \
      69             :     local_node->fldname = atoui(token)
      70             : 
      71             : /* Read a signed integer field (anything written using INT64_FORMAT) */
      72             : #define READ_INT64_FIELD(fldname) \
      73             :     token = pg_strtok(&length); /* skip :fldname */ \
      74             :     token = pg_strtok(&length); /* get field value */ \
      75             :     local_node->fldname = strtoi64(token, NULL, 10)
      76             : 
      77             : /* Read an unsigned integer field (anything written using UINT64_FORMAT) */
      78             : #define READ_UINT64_FIELD(fldname) \
      79             :     token = pg_strtok(&length);     /* skip :fldname */ \
      80             :     token = pg_strtok(&length);     /* get field value */ \
      81             :     local_node->fldname = strtou64(token, NULL, 10)
      82             : 
      83             : /* Read a long integer field (anything written as ":fldname %ld") */
      84             : #define READ_LONG_FIELD(fldname) \
      85             :     token = pg_strtok(&length);     /* skip :fldname */ \
      86             :     token = pg_strtok(&length);     /* get field value */ \
      87             :     local_node->fldname = atol(token)
      88             : 
      89             : /* Read an OID field (don't hard-wire assumption that OID is same as uint) */
      90             : #define READ_OID_FIELD(fldname) \
      91             :     token = pg_strtok(&length);     /* skip :fldname */ \
      92             :     token = pg_strtok(&length);     /* get field value */ \
      93             :     local_node->fldname = atooid(token)
      94             : 
      95             : /* Read a char field (ie, one ascii character) */
      96             : #define READ_CHAR_FIELD(fldname) \
      97             :     token = pg_strtok(&length);     /* skip :fldname */ \
      98             :     token = pg_strtok(&length);     /* get field value */ \
      99             :     /* avoid overhead of calling debackslash() for one char */ \
     100             :     local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0])
     101             : 
     102             : /* Read an enumerated-type field that was written as an integer code */
     103             : #define READ_ENUM_FIELD(fldname, enumtype) \
     104             :     token = pg_strtok(&length);     /* skip :fldname */ \
     105             :     token = pg_strtok(&length);     /* get field value */ \
     106             :     local_node->fldname = (enumtype) atoi(token)
     107             : 
     108             : /* Read a float field */
     109             : #define READ_FLOAT_FIELD(fldname) \
     110             :     token = pg_strtok(&length);     /* skip :fldname */ \
     111             :     token = pg_strtok(&length);     /* get field value */ \
     112             :     local_node->fldname = atof(token)
     113             : 
     114             : /* Read a boolean field */
     115             : #define READ_BOOL_FIELD(fldname) \
     116             :     token = pg_strtok(&length);     /* skip :fldname */ \
     117             :     token = pg_strtok(&length);     /* get field value */ \
     118             :     local_node->fldname = strtobool(token)
     119             : 
     120             : /* Read a character-string field */
     121             : #define READ_STRING_FIELD(fldname) \
     122             :     token = pg_strtok(&length);     /* skip :fldname */ \
     123             :     token = pg_strtok(&length);     /* get field value */ \
     124             :     local_node->fldname = nullable_string(token, length)
     125             : 
     126             : /* Read a parse location field (and possibly throw away the value) */
     127             : #ifdef DEBUG_NODE_TESTS_ENABLED
     128             : #define READ_LOCATION_FIELD(fldname) \
     129             :     token = pg_strtok(&length);     /* skip :fldname */ \
     130             :     token = pg_strtok(&length);     /* get field value */ \
     131             :     local_node->fldname = restore_location_fields ? atoi(token) : -1
     132             : #else
     133             : #define READ_LOCATION_FIELD(fldname) \
     134             :     token = pg_strtok(&length);     /* skip :fldname */ \
     135             :     token = pg_strtok(&length);     /* get field value */ \
     136             :     (void) token;               /* in case not used elsewhere */ \
     137             :     local_node->fldname = -1 /* set field to "unknown" */
     138             : #endif
     139             : 
     140             : /* Read a Node field */
     141             : #define READ_NODE_FIELD(fldname) \
     142             :     token = pg_strtok(&length);     /* skip :fldname */ \
     143             :     (void) token;               /* in case not used elsewhere */ \
     144             :     local_node->fldname = nodeRead(NULL, 0)
     145             : 
     146             : /* Read a bitmapset field */
     147             : #define READ_BITMAPSET_FIELD(fldname) \
     148             :     token = pg_strtok(&length);     /* skip :fldname */ \
     149             :     (void) token;               /* in case not used elsewhere */ \
     150             :     local_node->fldname = _readBitmapset()
     151             : 
     152             : /* Read an attribute number array */
     153             : #define READ_ATTRNUMBER_ARRAY(fldname, len) \
     154             :     token = pg_strtok(&length);     /* skip :fldname */ \
     155             :     local_node->fldname = readAttrNumberCols(len)
     156             : 
     157             : /* Read an oid array */
     158             : #define READ_OID_ARRAY(fldname, len) \
     159             :     token = pg_strtok(&length);     /* skip :fldname */ \
     160             :     local_node->fldname = readOidCols(len)
     161             : 
     162             : /* Read an int array */
     163             : #define READ_INT_ARRAY(fldname, len) \
     164             :     token = pg_strtok(&length);     /* skip :fldname */ \
     165             :     local_node->fldname = readIntCols(len)
     166             : 
     167             : /* Read a bool array */
     168             : #define READ_BOOL_ARRAY(fldname, len) \
     169             :     token = pg_strtok(&length);     /* skip :fldname */ \
     170             :     local_node->fldname = readBoolCols(len)
     171             : 
     172             : /* Routine exit */
     173             : #define READ_DONE() \
     174             :     return local_node
     175             : 
     176             : 
     177             : /*
     178             :  * NOTE: use atoi() to read values written with %d, or atoui() to read
     179             :  * values written with %u in outfuncs.c.  An exception is OID values,
     180             :  * for which use atooid().  (As of 7.1, outfuncs.c writes OIDs as %u,
     181             :  * but this will probably change in the future.)
     182             :  */
     183             : #define atoui(x)  ((unsigned int) strtoul((x), NULL, 10))
     184             : 
     185             : #define strtobool(x)  ((*(x) == 't') ? true : false)
     186             : 
     187             : static char *
     188    19268612 : nullable_string(const char *token, int length)
     189             : {
     190             :     /* outToken emits <> for NULL, and pg_strtok makes that an empty string */
     191    19268612 :     if (length == 0)
     192    10048570 :         return NULL;
     193             :     /* outToken emits "" for empty string */
     194     9220042 :     if (length == 2 && token[0] == '"' && token[1] == '"')
     195         156 :         return pstrdup("");
     196             :     /* otherwise, we must remove protective backslashes added by outToken */
     197     9219886 :     return debackslash(token, length);
     198             : }
     199             : 
     200             : 
     201             : /*
     202             :  * _readBitmapset
     203             :  *
     204             :  * Note: this code is used in contexts where we know that a Bitmapset
     205             :  * is expected.  There is equivalent code in nodeRead() that can read a
     206             :  * Bitmapset when we come across one in other contexts.
     207             :  */
     208             : static Bitmapset *
     209    19994206 : _readBitmapset(void)
     210             : {
     211    19994206 :     Bitmapset  *result = NULL;
     212             : 
     213             :     READ_TEMP_LOCALS();
     214             : 
     215    19994206 :     token = pg_strtok(&length);
     216    19994206 :     if (token == NULL)
     217           0 :         elog(ERROR, "incomplete Bitmapset structure");
     218    19994206 :     if (length != 1 || token[0] != '(')
     219           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     220             : 
     221    19994206 :     token = pg_strtok(&length);
     222    19994206 :     if (token == NULL)
     223           0 :         elog(ERROR, "incomplete Bitmapset structure");
     224    19994206 :     if (length != 1 || token[0] != 'b')
     225           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     226             : 
     227             :     for (;;)
     228     5662954 :     {
     229             :         int         val;
     230             :         char       *endptr;
     231             : 
     232    25657160 :         token = pg_strtok(&length);
     233    25657160 :         if (token == NULL)
     234           0 :             elog(ERROR, "unterminated Bitmapset structure");
     235    25657160 :         if (length == 1 && token[0] == ')')
     236    19994206 :             break;
     237     5662954 :         val = (int) strtol(token, &endptr, 10);
     238     5662954 :         if (endptr != token + length)
     239           0 :             elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
     240     5662954 :         result = bms_add_member(result, val);
     241             :     }
     242             : 
     243    19994206 :     return result;
     244             : }
     245             : 
     246             : /*
     247             :  * We export this function for use by extensions that define extensible nodes.
     248             :  * That's somewhat historical, though, because calling nodeRead() will work.
     249             :  */
     250             : Bitmapset *
     251           0 : readBitmapset(void)
     252             : {
     253           0 :     return _readBitmapset();
     254             : }
     255             : 
     256             : #include "readfuncs.funcs.c"
     257             : 
     258             : 
     259             : /*
     260             :  * Support functions for nodes with custom_read_write attribute or
     261             :  * special_read_write attribute
     262             :  */
     263             : 
     264             : static Const *
     265     3006874 : _readConst(void)
     266             : {
     267     3006874 :     READ_LOCALS(Const);
     268             : 
     269     3006874 :     READ_OID_FIELD(consttype);
     270     3006874 :     READ_INT_FIELD(consttypmod);
     271     3006874 :     READ_OID_FIELD(constcollid);
     272     3006874 :     READ_INT_FIELD(constlen);
     273     3006874 :     READ_BOOL_FIELD(constbyval);
     274     3006874 :     READ_BOOL_FIELD(constisnull);
     275     3006874 :     READ_LOCATION_FIELD(location);
     276             : 
     277     3006874 :     token = pg_strtok(&length); /* skip :constvalue */
     278     3006874 :     if (local_node->constisnull)
     279      253110 :         token = pg_strtok(&length); /* skip "<>" */
     280             :     else
     281     2753764 :         local_node->constvalue = readDatum(local_node->constbyval);
     282             : 
     283     3006874 :     READ_DONE();
     284             : }
     285             : 
     286             : static BoolExpr *
     287      396402 : _readBoolExpr(void)
     288             : {
     289      396402 :     READ_LOCALS(BoolExpr);
     290             : 
     291             :     /* do-it-yourself enum representation */
     292      396402 :     token = pg_strtok(&length); /* skip :boolop */
     293      396402 :     token = pg_strtok(&length); /* get field value */
     294      396402 :     if (length == 3 && strncmp(token, "and", 3) == 0)
     295      298754 :         local_node->boolop = AND_EXPR;
     296       97648 :     else if (length == 2 && strncmp(token, "or", 2) == 0)
     297       47844 :         local_node->boolop = OR_EXPR;
     298       49804 :     else if (length == 3 && strncmp(token, "not", 3) == 0)
     299       49804 :         local_node->boolop = NOT_EXPR;
     300             :     else
     301           0 :         elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
     302             : 
     303      396402 :     READ_NODE_FIELD(args);
     304      396402 :     READ_LOCATION_FIELD(location);
     305             : 
     306      396402 :     READ_DONE();
     307             : }
     308             : 
     309             : static A_Const *
     310     1447518 : _readA_Const(void)
     311             : {
     312     1447518 :     READ_LOCALS(A_Const);
     313             : 
     314             :     /* We expect either NULL or :val here */
     315     1447518 :     token = pg_strtok(&length);
     316     1447518 :     if (length == 4 && strncmp(token, "NULL", 4) == 0)
     317       84866 :         local_node->isnull = true;
     318             :     else
     319             :     {
     320     1362652 :         union ValUnion *tmp = nodeRead(NULL, 0);
     321             : 
     322             :         /* To forestall valgrind complaints, copy only the valid data */
     323     1362652 :         switch (nodeTag(tmp))
     324             :         {
     325      428282 :             case T_Integer:
     326      428282 :                 memcpy(&local_node->val, tmp, sizeof(Integer));
     327      428282 :                 break;
     328       11732 :             case T_Float:
     329       11732 :                 memcpy(&local_node->val, tmp, sizeof(Float));
     330       11732 :                 break;
     331       71284 :             case T_Boolean:
     332       71284 :                 memcpy(&local_node->val, tmp, sizeof(Boolean));
     333       71284 :                 break;
     334      847286 :             case T_String:
     335      847286 :                 memcpy(&local_node->val, tmp, sizeof(String));
     336      847286 :                 break;
     337        4068 :             case T_BitString:
     338        4068 :                 memcpy(&local_node->val, tmp, sizeof(BitString));
     339        4068 :                 break;
     340           0 :             default:
     341           0 :                 elog(ERROR, "unrecognized node type: %d",
     342             :                      (int) nodeTag(tmp));
     343             :                 break;
     344             :         }
     345             :     }
     346             : 
     347     1447518 :     READ_LOCATION_FIELD(location);
     348             : 
     349     1447518 :     READ_DONE();
     350             : }
     351             : 
     352             : static RangeTblEntry *
     353     1778298 : _readRangeTblEntry(void)
     354             : {
     355     1778298 :     READ_LOCALS(RangeTblEntry);
     356             : 
     357     1778298 :     READ_NODE_FIELD(alias);
     358     1778298 :     READ_NODE_FIELD(eref);
     359     1778298 :     READ_ENUM_FIELD(rtekind, RTEKind);
     360             : 
     361     1778298 :     switch (local_node->rtekind)
     362             :     {
     363     1068598 :         case RTE_RELATION:
     364     1068598 :             READ_OID_FIELD(relid);
     365     1068598 :             READ_BOOL_FIELD(inh);
     366     1068598 :             READ_CHAR_FIELD(relkind);
     367     1068598 :             READ_INT_FIELD(rellockmode);
     368     1068598 :             READ_UINT_FIELD(perminfoindex);
     369     1068598 :             READ_NODE_FIELD(tablesample);
     370     1068598 :             break;
     371      146922 :         case RTE_SUBQUERY:
     372      146922 :             READ_NODE_FIELD(subquery);
     373      146922 :             READ_BOOL_FIELD(security_barrier);
     374             :             /* we re-use these RELATION fields, too: */
     375      146922 :             READ_OID_FIELD(relid);
     376      146922 :             READ_BOOL_FIELD(inh);
     377      146922 :             READ_CHAR_FIELD(relkind);
     378      146922 :             READ_INT_FIELD(rellockmode);
     379      146922 :             READ_UINT_FIELD(perminfoindex);
     380      146922 :             break;
     381      204296 :         case RTE_JOIN:
     382      204296 :             READ_ENUM_FIELD(jointype, JoinType);
     383      204296 :             READ_INT_FIELD(joinmergedcols);
     384      204296 :             READ_NODE_FIELD(joinaliasvars);
     385      204296 :             READ_NODE_FIELD(joinleftcols);
     386      204296 :             READ_NODE_FIELD(joinrightcols);
     387      204296 :             READ_NODE_FIELD(join_using_alias);
     388      204296 :             break;
     389      115452 :         case RTE_FUNCTION:
     390      115452 :             READ_NODE_FIELD(functions);
     391      115452 :             READ_BOOL_FIELD(funcordinality);
     392      115452 :             break;
     393        1520 :         case RTE_TABLEFUNC:
     394        1520 :             READ_NODE_FIELD(tablefunc);
     395             :             /* The RTE must have a copy of the column type info, if any */
     396        1520 :             if (local_node->tablefunc)
     397             :             {
     398         894 :                 TableFunc  *tf = local_node->tablefunc;
     399             : 
     400         894 :                 local_node->coltypes = tf->coltypes;
     401         894 :                 local_node->coltypmods = tf->coltypmods;
     402         894 :                 local_node->colcollations = tf->colcollations;
     403             :             }
     404        1520 :             break;
     405       22492 :         case RTE_VALUES:
     406       22492 :             READ_NODE_FIELD(values_lists);
     407       22492 :             READ_NODE_FIELD(coltypes);
     408       22492 :             READ_NODE_FIELD(coltypmods);
     409       22492 :             READ_NODE_FIELD(colcollations);
     410       22492 :             break;
     411       12396 :         case RTE_CTE:
     412       12396 :             READ_STRING_FIELD(ctename);
     413       12396 :             READ_UINT_FIELD(ctelevelsup);
     414       12396 :             READ_BOOL_FIELD(self_reference);
     415       12396 :             READ_NODE_FIELD(coltypes);
     416       12396 :             READ_NODE_FIELD(coltypmods);
     417       12396 :             READ_NODE_FIELD(colcollations);
     418       12396 :             break;
     419         944 :         case RTE_NAMEDTUPLESTORE:
     420         944 :             READ_STRING_FIELD(enrname);
     421         944 :             READ_FLOAT_FIELD(enrtuples);
     422         944 :             READ_NODE_FIELD(coltypes);
     423         944 :             READ_NODE_FIELD(coltypmods);
     424         944 :             READ_NODE_FIELD(colcollations);
     425             :             /* we re-use these RELATION fields, too: */
     426         944 :             READ_OID_FIELD(relid);
     427         944 :             break;
     428      194826 :         case RTE_RESULT:
     429             :             /* no extra fields */
     430      194826 :             break;
     431       10852 :         case RTE_GROUP:
     432       10852 :             READ_NODE_FIELD(groupexprs);
     433       10852 :             break;
     434           0 :         default:
     435           0 :             elog(ERROR, "unrecognized RTE kind: %d",
     436             :                  (int) local_node->rtekind);
     437             :             break;
     438             :     }
     439             : 
     440     1778298 :     READ_BOOL_FIELD(lateral);
     441     1778298 :     READ_BOOL_FIELD(inFromCl);
     442     1778298 :     READ_NODE_FIELD(securityQuals);
     443             : 
     444     1778298 :     READ_DONE();
     445             : }
     446             : 
     447             : static A_Expr *
     448      661934 : _readA_Expr(void)
     449             : {
     450      661934 :     READ_LOCALS(A_Expr);
     451             : 
     452      661934 :     token = pg_strtok(&length);
     453             : 
     454      661934 :     if (length == 3 && strncmp(token, "ANY", 3) == 0)
     455             :     {
     456       16826 :         local_node->kind = AEXPR_OP_ANY;
     457       16826 :         READ_NODE_FIELD(name);
     458             :     }
     459      645108 :     else if (length == 3 && strncmp(token, "ALL", 3) == 0)
     460             :     {
     461         144 :         local_node->kind = AEXPR_OP_ALL;
     462         144 :         READ_NODE_FIELD(name);
     463             :     }
     464      644964 :     else if (length == 8 && strncmp(token, "DISTINCT", 8) == 0)
     465             :     {
     466        1256 :         local_node->kind = AEXPR_DISTINCT;
     467        1256 :         READ_NODE_FIELD(name);
     468             :     }
     469      643708 :     else if (length == 12 && strncmp(token, "NOT_DISTINCT", 12) == 0)
     470             :     {
     471          74 :         local_node->kind = AEXPR_NOT_DISTINCT;
     472          74 :         READ_NODE_FIELD(name);
     473             :     }
     474      643634 :     else if (length == 6 && strncmp(token, "NULLIF", 6) == 0)
     475             :     {
     476         688 :         local_node->kind = AEXPR_NULLIF;
     477         688 :         READ_NODE_FIELD(name);
     478             :     }
     479      642946 :     else if (length == 2 && strncmp(token, "IN", 2) == 0)
     480             :     {
     481       28058 :         local_node->kind = AEXPR_IN;
     482       28058 :         READ_NODE_FIELD(name);
     483             :     }
     484      614888 :     else if (length == 4 && strncmp(token, "LIKE", 4) == 0)
     485             :     {
     486        2338 :         local_node->kind = AEXPR_LIKE;
     487        2338 :         READ_NODE_FIELD(name);
     488             :     }
     489      612550 :     else if (length == 5 && strncmp(token, "ILIKE", 5) == 0)
     490             :     {
     491         202 :         local_node->kind = AEXPR_ILIKE;
     492         202 :         READ_NODE_FIELD(name);
     493             :     }
     494      612348 :     else if (length == 7 && strncmp(token, "SIMILAR", 7) == 0)
     495             :     {
     496         118 :         local_node->kind = AEXPR_SIMILAR;
     497         118 :         READ_NODE_FIELD(name);
     498             :     }
     499      612230 :     else if (length == 7 && strncmp(token, "BETWEEN", 7) == 0)
     500             :     {
     501         558 :         local_node->kind = AEXPR_BETWEEN;
     502         558 :         READ_NODE_FIELD(name);
     503             :     }
     504      611672 :     else if (length == 11 && strncmp(token, "NOT_BETWEEN", 11) == 0)
     505             :     {
     506          12 :         local_node->kind = AEXPR_NOT_BETWEEN;
     507          12 :         READ_NODE_FIELD(name);
     508             :     }
     509      611660 :     else if (length == 11 && strncmp(token, "BETWEEN_SYM", 11) == 0)
     510             :     {
     511          12 :         local_node->kind = AEXPR_BETWEEN_SYM;
     512          12 :         READ_NODE_FIELD(name);
     513             :     }
     514      611648 :     else if (length == 15 && strncmp(token, "NOT_BETWEEN_SYM", 15) == 0)
     515             :     {
     516          12 :         local_node->kind = AEXPR_NOT_BETWEEN_SYM;
     517          12 :         READ_NODE_FIELD(name);
     518             :     }
     519      611636 :     else if (length == 5 && strncmp(token, ":name", 5) == 0)
     520             :     {
     521      611636 :         local_node->kind = AEXPR_OP;
     522      611636 :         local_node->name = nodeRead(NULL, 0);
     523             :     }
     524             :     else
     525           0 :         elog(ERROR, "unrecognized A_Expr kind: \"%.*s\"", length, token);
     526             : 
     527      661934 :     READ_NODE_FIELD(lexpr);
     528      661934 :     READ_NODE_FIELD(rexpr);
     529      661934 :     READ_LOCATION_FIELD(location);
     530             : 
     531      661934 :     READ_DONE();
     532             : }
     533             : 
     534             : static ExtensibleNode *
     535           0 : _readExtensibleNode(void)
     536             : {
     537             :     const ExtensibleNodeMethods *methods;
     538             :     ExtensibleNode *local_node;
     539             :     const char *extnodename;
     540             : 
     541             :     READ_TEMP_LOCALS();
     542             : 
     543           0 :     token = pg_strtok(&length); /* skip :extnodename */
     544           0 :     token = pg_strtok(&length); /* get extnodename */
     545             : 
     546           0 :     extnodename = nullable_string(token, length);
     547           0 :     if (!extnodename)
     548           0 :         elog(ERROR, "extnodename has to be supplied");
     549           0 :     methods = GetExtensibleNodeMethods(extnodename, false);
     550             : 
     551           0 :     local_node = (ExtensibleNode *) newNode(methods->node_size,
     552             :                                             T_ExtensibleNode);
     553           0 :     local_node->extnodename = extnodename;
     554             : 
     555             :     /* deserialize the private fields */
     556           0 :     methods->nodeRead(local_node);
     557             : 
     558           0 :     READ_DONE();
     559             : }
     560             : 
     561             : 
     562             : /*
     563             :  * parseNodeString
     564             :  *
     565             :  * Given a character string representing a node tree, parseNodeString creates
     566             :  * the internal node structure.
     567             :  *
     568             :  * The string to be read must already have been loaded into pg_strtok().
     569             :  */
     570             : Node *
     571    50802792 : parseNodeString(void)
     572             : {
     573             :     READ_TEMP_LOCALS();
     574             : 
     575             :     /* Guard against stack overflow due to overly complex expressions */
     576    50802792 :     check_stack_depth();
     577             : 
     578    50802792 :     token = pg_strtok(&length);
     579             : 
     580             : #define MATCH(tokname, namelen) \
     581             :     (length == namelen && memcmp(token, tokname, namelen) == 0)
     582             : 
     583             : #include "readfuncs.switch.c"
     584             : 
     585           8 :     elog(ERROR, "badly formatted node string \"%.32s\"...", token);
     586             :     return NULL;                /* keep compiler quiet */
     587             : }
     588             : 
     589             : 
     590             : /*
     591             :  * readDatum
     592             :  *
     593             :  * Given a string representation of a constant, recreate the appropriate
     594             :  * Datum.  The string representation embeds length info, but not byValue,
     595             :  * so we must be told that.
     596             :  */
     597             : Datum
     598     2753768 : readDatum(bool typbyval)
     599             : {
     600             :     Size        length,
     601             :                 i;
     602             :     int         tokenLength;
     603             :     const char *token;
     604             :     Datum       res;
     605             :     char       *s;
     606             : 
     607             :     /*
     608             :      * read the actual length of the value
     609             :      */
     610     2753768 :     token = pg_strtok(&tokenLength);
     611     2753768 :     length = atoui(token);
     612             : 
     613     2753768 :     token = pg_strtok(&tokenLength);    /* read the '[' */
     614     2753768 :     if (token == NULL || token[0] != '[')
     615           0 :         elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
     616             :              token ? token : "[NULL]", length);
     617             : 
     618     2753768 :     if (typbyval)
     619             :     {
     620     1815238 :         if (length > (Size) sizeof(Datum))
     621           0 :             elog(ERROR, "byval datum but length = %zu", length);
     622     1815238 :         res = (Datum) 0;
     623     1815238 :         s = (char *) (&res);
     624    16337142 :         for (i = 0; i < (Size) sizeof(Datum); i++)
     625             :         {
     626    14521904 :             token = pg_strtok(&tokenLength);
     627    14521904 :             s[i] = (char) atoi(token);
     628             :         }
     629             :     }
     630      938530 :     else if (length <= 0)
     631           0 :         res = (Datum) NULL;
     632             :     else
     633             :     {
     634      938530 :         s = (char *) palloc(length);
     635   119697242 :         for (i = 0; i < length; i++)
     636             :         {
     637   118758712 :             token = pg_strtok(&tokenLength);
     638   118758712 :             s[i] = (char) atoi(token);
     639             :         }
     640      938530 :         res = PointerGetDatum(s);
     641             :     }
     642             : 
     643     2753768 :     token = pg_strtok(&tokenLength);    /* read the ']' */
     644     2753768 :     if (token == NULL || token[0] != ']')
     645           0 :         elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
     646             :              token ? token : "[NULL]", length);
     647             : 
     648     2753768 :     return res;
     649             : }
     650             : 
     651             : /*
     652             :  * common implementation for scalar-array-reading functions
     653             :  *
     654             :  * The data format is either "<>" for a NULL pointer (in which case numCols
     655             :  * is ignored) or "(item item item)" where the number of items must equal
     656             :  * numCols.  The convfunc must be okay with stopping at whitespace or a
     657             :  * right parenthesis, since pg_strtok won't null-terminate the token.
     658             :  */
     659             : #define READ_SCALAR_ARRAY(fnname, datatype, convfunc) \
     660             : datatype * \
     661             : fnname(int numCols) \
     662             : { \
     663             :     datatype   *vals; \
     664             :     READ_TEMP_LOCALS(); \
     665             :     token = pg_strtok(&length); \
     666             :     if (token == NULL) \
     667             :         elog(ERROR, "incomplete scalar array"); \
     668             :     if (length == 0) \
     669             :         return NULL;            /* it was "<>", so return NULL pointer */ \
     670             :     if (length != 1 || token[0] != '(') \
     671             :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \
     672             :     vals = (datatype *) palloc(numCols * sizeof(datatype)); \
     673             :     for (int i = 0; i < numCols; i++) \
     674             :     { \
     675             :         token = pg_strtok(&length); \
     676             :         if (token == NULL || token[0] == ')') \
     677             :             elog(ERROR, "incomplete scalar array"); \
     678             :         vals[i] = convfunc(token); \
     679             :     } \
     680             :     token = pg_strtok(&length); \
     681             :     if (token == NULL || length != 1 || token[0] != ')') \
     682             :         elog(ERROR, "incomplete scalar array"); \
     683             :     return vals; \
     684             : }
     685             : 
     686             : /*
     687             :  * Note: these functions are exported in nodes.h for possible use by
     688             :  * extensions, so don't mess too much with their names or API.
     689             :  */
     690      477458 : READ_SCALAR_ARRAY(readAttrNumberCols, int16, atoi)
     691      644268 : READ_SCALAR_ARRAY(readOidCols, Oid, atooid)
     692             : /* outfuncs.c has writeIndexCols, but we don't yet need that here */
     693             : /* READ_SCALAR_ARRAY(readIndexCols, Index, atoui) */
     694       16128 : READ_SCALAR_ARRAY(readIntCols, int, atoi)
     695      243572 : READ_SCALAR_ARRAY(readBoolCols, bool, strtobool)

Generated by: LCOV version 1.16