Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * outfuncs.c
4 : * Output 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/outfuncs.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include <ctype.h>
18 :
19 : #include "access/attnum.h"
20 : #include "common/shortest_dec.h"
21 : #include "lib/stringinfo.h"
22 : #include "miscadmin.h"
23 : #include "nodes/bitmapset.h"
24 : #include "nodes/nodes.h"
25 : #include "nodes/pg_list.h"
26 : #include "utils/datum.h"
27 :
28 : /* State flag that determines how nodeToStringInternal() should treat location fields */
29 : static bool write_location_fields = false;
30 :
31 : static void outChar(StringInfo str, char c);
32 : static void outDouble(StringInfo str, double d);
33 :
34 :
35 : /*
36 : * Macros to simplify output of different kinds of fields. Use these
37 : * wherever possible to reduce the chance for silly typos. Note that these
38 : * hard-wire conventions about the names of the local variables in an Out
39 : * routine.
40 : */
41 :
42 : /* Write the label for the node type */
43 : #define WRITE_NODE_TYPE(nodelabel) \
44 : appendStringInfoString(str, nodelabel)
45 :
46 : /* Write an integer field (anything written as ":fldname %d") */
47 : #define WRITE_INT_FIELD(fldname) \
48 : appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
49 :
50 : /* Write an unsigned integer field (anything written as ":fldname %u") */
51 : #define WRITE_UINT_FIELD(fldname) \
52 : appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
53 :
54 : /* Write a signed integer field (anything written with INT64_FORMAT) */
55 : #define WRITE_INT64_FIELD(fldname) \
56 : appendStringInfo(str, \
57 : " :" CppAsString(fldname) " " INT64_FORMAT, \
58 : node->fldname)
59 :
60 : /* Write an unsigned integer field (anything written with UINT64_FORMAT) */
61 : #define WRITE_UINT64_FIELD(fldname) \
62 : appendStringInfo(str, " :" CppAsString(fldname) " " UINT64_FORMAT, \
63 : node->fldname)
64 :
65 : /* Write an OID field (don't hard-wire assumption that OID is same as uint) */
66 : #define WRITE_OID_FIELD(fldname) \
67 : appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
68 :
69 : /* Write a long-integer field */
70 : #define WRITE_LONG_FIELD(fldname) \
71 : appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
72 :
73 : /* Write a char field (ie, one ascii character) */
74 : #define WRITE_CHAR_FIELD(fldname) \
75 : (appendStringInfo(str, " :" CppAsString(fldname) " "), \
76 : outChar(str, node->fldname))
77 :
78 : /* Write an enumerated-type field as an integer code */
79 : #define WRITE_ENUM_FIELD(fldname, enumtype) \
80 : appendStringInfo(str, " :" CppAsString(fldname) " %d", \
81 : (int) node->fldname)
82 :
83 : /* Write a float field (actually, they're double) */
84 : #define WRITE_FLOAT_FIELD(fldname) \
85 : (appendStringInfo(str, " :" CppAsString(fldname) " "), \
86 : outDouble(str, node->fldname))
87 :
88 : /* Write a boolean field */
89 : #define WRITE_BOOL_FIELD(fldname) \
90 : appendStringInfo(str, " :" CppAsString(fldname) " %s", \
91 : booltostr(node->fldname))
92 :
93 : /* Write a character-string (possibly NULL) field */
94 : #define WRITE_STRING_FIELD(fldname) \
95 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
96 : outToken(str, node->fldname))
97 :
98 : /* Write a parse location field (actually same as INT case) */
99 : #define WRITE_LOCATION_FIELD(fldname) \
100 : appendStringInfo(str, " :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)
101 :
102 : /* Write a Node field */
103 : #define WRITE_NODE_FIELD(fldname) \
104 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
105 : outNode(str, node->fldname))
106 :
107 : /* Write a bitmapset field */
108 : #define WRITE_BITMAPSET_FIELD(fldname) \
109 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
110 : outBitmapset(str, node->fldname))
111 :
112 : /* Write a variable-length array (not a List) of Node pointers */
113 : #define WRITE_NODE_ARRAY(fldname, len) \
114 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
115 : writeNodeArray(str, (const Node * const *) node->fldname, len))
116 :
117 : /* Write a variable-length array of AttrNumber */
118 : #define WRITE_ATTRNUMBER_ARRAY(fldname, len) \
119 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
120 : writeAttrNumberCols(str, node->fldname, len))
121 :
122 : /* Write a variable-length array of Oid */
123 : #define WRITE_OID_ARRAY(fldname, len) \
124 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
125 : writeOidCols(str, node->fldname, len))
126 :
127 : /* Write a variable-length array of Index */
128 : #define WRITE_INDEX_ARRAY(fldname, len) \
129 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
130 : writeIndexCols(str, node->fldname, len))
131 :
132 : /* Write a variable-length array of int */
133 : #define WRITE_INT_ARRAY(fldname, len) \
134 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
135 : writeIntCols(str, node->fldname, len))
136 :
137 : /* Write a variable-length array of bool */
138 : #define WRITE_BOOL_ARRAY(fldname, len) \
139 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
140 : writeBoolCols(str, node->fldname, len))
141 :
142 : #define booltostr(x) ((x) ? "true" : "false")
143 :
144 :
145 : /*
146 : * outToken
147 : * Convert an ordinary string (eg, an identifier) into a form that
148 : * will be decoded back to a plain token by read.c's functions.
149 : *
150 : * If a null string pointer is given, it is encoded as '<>'.
151 : * An empty string is encoded as '""'. To avoid ambiguity, input
152 : * strings beginning with '<' or '"' receive a leading backslash.
153 : */
154 : void
155 49228602 : outToken(StringInfo str, const char *s)
156 : {
157 49228602 : if (s == NULL)
158 : {
159 10035742 : appendStringInfoString(str, "<>");
160 10035742 : return;
161 : }
162 39192860 : if (*s == '\0')
163 : {
164 156 : appendStringInfoString(str, "\"\"");
165 156 : return;
166 : }
167 :
168 : /*
169 : * Look for characters or patterns that are treated specially by read.c
170 : * (either in pg_strtok() or in nodeRead()), and therefore need a
171 : * protective backslash.
172 : */
173 : /* These characters only need to be quoted at the start of the string */
174 39192704 : if (*s == '<' ||
175 39124038 : *s == '"' ||
176 39117874 : isdigit((unsigned char) *s) ||
177 38926516 : ((*s == '+' || *s == '-') &&
178 31866 : (isdigit((unsigned char) s[1]) || s[1] == '.')))
179 271796 : appendStringInfoChar(str, '\\');
180 353329072 : while (*s)
181 : {
182 : /* These chars must be backslashed anywhere in the string */
183 314136368 : if (*s == ' ' || *s == '\n' || *s == '\t' ||
184 312758428 : *s == '(' || *s == ')' || *s == '{' || *s == '}' ||
185 312528350 : *s == '\\')
186 1619424 : appendStringInfoChar(str, '\\');
187 314136368 : appendStringInfoChar(str, *s++);
188 : }
189 : }
190 :
191 : /*
192 : * Convert one char. Goes through outToken() so that special characters are
193 : * escaped.
194 : */
195 : static void
196 3016966 : outChar(StringInfo str, char c)
197 : {
198 : char in[2];
199 :
200 : /* Traditionally, we've represented \0 as <>, so keep doing that */
201 3016966 : if (c == '\0')
202 : {
203 917922 : appendStringInfoString(str, "<>");
204 917922 : return;
205 : }
206 :
207 2099044 : in[0] = c;
208 2099044 : in[1] = '\0';
209 :
210 2099044 : outToken(str, in);
211 : }
212 :
213 : /*
214 : * Convert a double value, attempting to ensure the value is preserved exactly.
215 : */
216 : static void
217 3573888 : outDouble(StringInfo str, double d)
218 : {
219 : char buf[DOUBLE_SHORTEST_DECIMAL_LEN];
220 :
221 3573888 : double_to_shortest_decimal_buf(d, buf);
222 3573888 : appendStringInfoString(str, buf);
223 3573888 : }
224 :
225 : /*
226 : * common implementation for scalar-array-writing functions
227 : *
228 : * The data format is either "<>" for a NULL pointer or "(item item item)".
229 : * fmtstr must include a leading space, and the rest of it must produce
230 : * something that will be seen as a single simple token by pg_strtok().
231 : * convfunc can be empty, or the name of a conversion macro or function.
232 : */
233 : #define WRITE_SCALAR_ARRAY(fnname, datatype, fmtstr, convfunc) \
234 : static void \
235 : fnname(StringInfo str, const datatype *arr, int len) \
236 : { \
237 : if (arr != NULL) \
238 : { \
239 : appendStringInfoChar(str, '('); \
240 : for (int i = 0; i < len; i++) \
241 : appendStringInfo(str, fmtstr, convfunc(arr[i])); \
242 : appendStringInfoChar(str, ')'); \
243 : } \
244 : else \
245 : appendStringInfoString(str, "<>"); \
246 : }
247 :
248 477818 : WRITE_SCALAR_ARRAY(writeAttrNumberCols, AttrNumber, " %d",)
249 645938 : WRITE_SCALAR_ARRAY(writeOidCols, Oid, " %u",)
250 0 : WRITE_SCALAR_ARRAY(writeIndexCols, Index, " %u",)
251 14622 : WRITE_SCALAR_ARRAY(writeIntCols, int, " %d",)
252 245596 : WRITE_SCALAR_ARRAY(writeBoolCols, bool, " %s", booltostr)
253 :
254 : /*
255 : * Print an array (not a List) of Node pointers.
256 : *
257 : * The decoration is identical to that of scalar arrays, but we can't
258 : * quite use appendStringInfo() in the loop.
259 : */
260 : static void
261 0 : writeNodeArray(StringInfo str, const Node *const *arr, int len)
262 : {
263 0 : if (arr != NULL)
264 : {
265 0 : appendStringInfoChar(str, '(');
266 0 : for (int i = 0; i < len; i++)
267 : {
268 0 : appendStringInfoChar(str, ' ');
269 0 : outNode(str, arr[i]);
270 : }
271 0 : appendStringInfoChar(str, ')');
272 : }
273 : else
274 0 : appendStringInfoString(str, "<>");
275 0 : }
276 :
277 : /*
278 : * Print a List.
279 : */
280 : static void
281 18378834 : _outList(StringInfo str, const List *node)
282 : {
283 : const ListCell *lc;
284 :
285 18378834 : appendStringInfoChar(str, '(');
286 :
287 18378834 : if (IsA(node, IntList))
288 493196 : appendStringInfoChar(str, 'i');
289 17885638 : else if (IsA(node, OidList))
290 704836 : appendStringInfoChar(str, 'o');
291 17180802 : else if (IsA(node, XidList))
292 0 : appendStringInfoChar(str, 'x');
293 :
294 78260720 : foreach(lc, node)
295 : {
296 : /*
297 : * For the sake of backward compatibility, we emit a slightly
298 : * different whitespace format for lists of nodes vs. other types of
299 : * lists. XXX: is this necessary?
300 : */
301 59881886 : if (IsA(node, List))
302 : {
303 54109398 : outNode(str, lfirst(lc));
304 54109398 : if (lnext(node, lc))
305 36928596 : appendStringInfoChar(str, ' ');
306 : }
307 5772488 : else if (IsA(node, IntList))
308 4371040 : appendStringInfo(str, " %d", lfirst_int(lc));
309 1401448 : else if (IsA(node, OidList))
310 1401448 : appendStringInfo(str, " %u", lfirst_oid(lc));
311 0 : else if (IsA(node, XidList))
312 0 : appendStringInfo(str, " %u", lfirst_xid(lc));
313 : else
314 0 : elog(ERROR, "unrecognized list node type: %d",
315 : (int) node->type);
316 : }
317 :
318 18378834 : appendStringInfoChar(str, ')');
319 18378834 : }
320 :
321 : /*
322 : * outBitmapset -
323 : * converts a bitmap set of integers
324 : *
325 : * Note: the output format is "(b int int ...)", similar to an integer List.
326 : *
327 : * We export this function for use by extensions that define extensible nodes.
328 : * That's somewhat historical, though, because calling outNode() will work.
329 : */
330 : void
331 18929900 : outBitmapset(StringInfo str, const Bitmapset *bms)
332 : {
333 : int x;
334 :
335 18929900 : appendStringInfoChar(str, '(');
336 18929900 : appendStringInfoChar(str, 'b');
337 18929900 : x = -1;
338 24355372 : while ((x = bms_next_member(bms, x)) >= 0)
339 5425472 : appendStringInfo(str, " %d", x);
340 18929900 : appendStringInfoChar(str, ')');
341 18929900 : }
342 :
343 : /*
344 : * Print the value of a Datum given its type.
345 : */
346 : void
347 2459698 : outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
348 : {
349 : Size length,
350 : i;
351 : char *s;
352 :
353 2459698 : length = datumGetSize(value, typbyval, typlen);
354 :
355 2459698 : if (typbyval)
356 : {
357 1583084 : s = (char *) (&value);
358 1583084 : appendStringInfo(str, "%u [ ", (unsigned int) length);
359 14247756 : for (i = 0; i < (Size) sizeof(Datum); i++)
360 12664672 : appendStringInfo(str, "%d ", (int) (s[i]));
361 1583084 : appendStringInfoChar(str, ']');
362 : }
363 : else
364 : {
365 876614 : s = (char *) DatumGetPointer(value);
366 876614 : if (!PointerIsValid(s))
367 0 : appendStringInfoString(str, "0 [ ]");
368 : else
369 : {
370 876614 : appendStringInfo(str, "%u [ ", (unsigned int) length);
371 117734432 : for (i = 0; i < length; i++)
372 116857818 : appendStringInfo(str, "%d ", (int) (s[i]));
373 876614 : appendStringInfoChar(str, ']');
374 : }
375 : }
376 2459698 : }
377 :
378 :
379 : #include "outfuncs.funcs.c"
380 :
381 :
382 : /*
383 : * Support functions for nodes with custom_read_write attribute or
384 : * special_read_write attribute
385 : */
386 :
387 : static void
388 2669562 : _outConst(StringInfo str, const Const *node)
389 : {
390 2669562 : WRITE_NODE_TYPE("CONST");
391 :
392 2669562 : WRITE_OID_FIELD(consttype);
393 2669562 : WRITE_INT_FIELD(consttypmod);
394 2669562 : WRITE_OID_FIELD(constcollid);
395 2669562 : WRITE_INT_FIELD(constlen);
396 2669562 : WRITE_BOOL_FIELD(constbyval);
397 2669562 : WRITE_BOOL_FIELD(constisnull);
398 2669562 : WRITE_LOCATION_FIELD(location);
399 :
400 2669562 : appendStringInfoString(str, " :constvalue ");
401 2669562 : if (node->constisnull)
402 209856 : appendStringInfoString(str, "<>");
403 : else
404 2459706 : outDatum(str, node->constvalue, node->constlen, node->constbyval);
405 2669562 : }
406 :
407 : static void
408 381912 : _outBoolExpr(StringInfo str, const BoolExpr *node)
409 : {
410 381912 : char *opstr = NULL;
411 :
412 381912 : WRITE_NODE_TYPE("BOOLEXPR");
413 :
414 : /* do-it-yourself enum representation */
415 381912 : switch (node->boolop)
416 : {
417 288760 : case AND_EXPR:
418 288760 : opstr = "and";
419 288760 : break;
420 44378 : case OR_EXPR:
421 44378 : opstr = "or";
422 44378 : break;
423 48774 : case NOT_EXPR:
424 48774 : opstr = "not";
425 48774 : break;
426 : }
427 381912 : appendStringInfoString(str, " :boolop ");
428 381912 : outToken(str, opstr);
429 :
430 381912 : WRITE_NODE_FIELD(args);
431 381912 : WRITE_LOCATION_FIELD(location);
432 381912 : }
433 :
434 : static void
435 0 : _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
436 : {
437 : int i;
438 :
439 0 : WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
440 :
441 0 : WRITE_UINT_FIELD(con_relid);
442 0 : WRITE_UINT_FIELD(ref_relid);
443 0 : WRITE_INT_FIELD(nkeys);
444 0 : WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
445 0 : WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
446 0 : WRITE_OID_ARRAY(conpfeqop, node->nkeys);
447 0 : WRITE_INT_FIELD(nmatched_ec);
448 0 : WRITE_INT_FIELD(nconst_ec);
449 0 : WRITE_INT_FIELD(nmatched_rcols);
450 0 : WRITE_INT_FIELD(nmatched_ri);
451 : /* for compactness, just print the number of matches per column: */
452 0 : appendStringInfoString(str, " :eclass");
453 0 : for (i = 0; i < node->nkeys; i++)
454 0 : appendStringInfo(str, " %d", (node->eclass[i] != NULL));
455 0 : appendStringInfoString(str, " :rinfos");
456 0 : for (i = 0; i < node->nkeys; i++)
457 0 : appendStringInfo(str, " %d", list_length(node->rinfos[i]));
458 0 : }
459 :
460 : static void
461 0 : _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
462 : {
463 : /*
464 : * To simplify reading, we just chase up to the topmost merged EC and
465 : * print that, without bothering to show the merge-ees separately.
466 : */
467 0 : while (node->ec_merged)
468 0 : node = node->ec_merged;
469 :
470 0 : WRITE_NODE_TYPE("EQUIVALENCECLASS");
471 :
472 0 : WRITE_NODE_FIELD(ec_opfamilies);
473 0 : WRITE_OID_FIELD(ec_collation);
474 0 : WRITE_INT_FIELD(ec_childmembers_size);
475 0 : WRITE_NODE_FIELD(ec_members);
476 0 : WRITE_NODE_ARRAY(ec_childmembers, node->ec_childmembers_size);
477 0 : WRITE_NODE_FIELD(ec_sources);
478 : /* Only ec_derives_list is written; hash is not serialized. */
479 0 : WRITE_NODE_FIELD(ec_derives_list);
480 0 : WRITE_BITMAPSET_FIELD(ec_relids);
481 0 : WRITE_BOOL_FIELD(ec_has_const);
482 0 : WRITE_BOOL_FIELD(ec_has_volatile);
483 0 : WRITE_BOOL_FIELD(ec_broken);
484 0 : WRITE_UINT_FIELD(ec_sortref);
485 0 : WRITE_UINT_FIELD(ec_min_security);
486 0 : WRITE_UINT_FIELD(ec_max_security);
487 0 : }
488 :
489 : static void
490 0 : _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
491 : {
492 : const ExtensibleNodeMethods *methods;
493 :
494 0 : methods = GetExtensibleNodeMethods(node->extnodename, false);
495 :
496 0 : WRITE_NODE_TYPE("EXTENSIBLENODE");
497 :
498 0 : WRITE_STRING_FIELD(extnodename);
499 :
500 : /* serialize the private fields */
501 0 : methods->nodeOut(str, node);
502 0 : }
503 :
504 : static void
505 1699314 : _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
506 : {
507 1699314 : WRITE_NODE_TYPE("RANGETBLENTRY");
508 :
509 1699314 : WRITE_NODE_FIELD(alias);
510 1699314 : WRITE_NODE_FIELD(eref);
511 1699314 : WRITE_ENUM_FIELD(rtekind, RTEKind);
512 :
513 1699314 : switch (node->rtekind)
514 : {
515 1020634 : case RTE_RELATION:
516 1020634 : WRITE_OID_FIELD(relid);
517 1020634 : WRITE_BOOL_FIELD(inh);
518 1020634 : WRITE_CHAR_FIELD(relkind);
519 1020634 : WRITE_INT_FIELD(rellockmode);
520 1020634 : WRITE_UINT_FIELD(perminfoindex);
521 1020634 : WRITE_NODE_FIELD(tablesample);
522 1020634 : break;
523 139656 : case RTE_SUBQUERY:
524 139656 : WRITE_NODE_FIELD(subquery);
525 139656 : WRITE_BOOL_FIELD(security_barrier);
526 : /* we re-use these RELATION fields, too: */
527 139656 : WRITE_OID_FIELD(relid);
528 139656 : WRITE_BOOL_FIELD(inh);
529 139656 : WRITE_CHAR_FIELD(relkind);
530 139656 : WRITE_INT_FIELD(rellockmode);
531 139656 : WRITE_UINT_FIELD(perminfoindex);
532 139656 : break;
533 190514 : case RTE_JOIN:
534 190514 : WRITE_ENUM_FIELD(jointype, JoinType);
535 190514 : WRITE_INT_FIELD(joinmergedcols);
536 190514 : WRITE_NODE_FIELD(joinaliasvars);
537 190514 : WRITE_NODE_FIELD(joinleftcols);
538 190514 : WRITE_NODE_FIELD(joinrightcols);
539 190514 : WRITE_NODE_FIELD(join_using_alias);
540 190514 : break;
541 107780 : case RTE_FUNCTION:
542 107780 : WRITE_NODE_FIELD(functions);
543 107780 : WRITE_BOOL_FIELD(funcordinality);
544 107780 : break;
545 1296 : case RTE_TABLEFUNC:
546 1296 : WRITE_NODE_FIELD(tablefunc);
547 1296 : break;
548 21400 : case RTE_VALUES:
549 21400 : WRITE_NODE_FIELD(values_lists);
550 21400 : WRITE_NODE_FIELD(coltypes);
551 21400 : WRITE_NODE_FIELD(coltypmods);
552 21400 : WRITE_NODE_FIELD(colcollations);
553 21400 : break;
554 11876 : case RTE_CTE:
555 11876 : WRITE_STRING_FIELD(ctename);
556 11876 : WRITE_UINT_FIELD(ctelevelsup);
557 11876 : WRITE_BOOL_FIELD(self_reference);
558 11876 : WRITE_NODE_FIELD(coltypes);
559 11876 : WRITE_NODE_FIELD(coltypmods);
560 11876 : WRITE_NODE_FIELD(colcollations);
561 11876 : break;
562 942 : case RTE_NAMEDTUPLESTORE:
563 942 : WRITE_STRING_FIELD(enrname);
564 942 : WRITE_FLOAT_FIELD(enrtuples);
565 942 : WRITE_NODE_FIELD(coltypes);
566 942 : WRITE_NODE_FIELD(coltypmods);
567 942 : WRITE_NODE_FIELD(colcollations);
568 : /* we re-use these RELATION fields, too: */
569 942 : WRITE_OID_FIELD(relid);
570 942 : break;
571 195828 : case RTE_RESULT:
572 : /* no extra fields */
573 195828 : break;
574 9388 : case RTE_GROUP:
575 9388 : WRITE_NODE_FIELD(groupexprs);
576 9388 : break;
577 0 : default:
578 0 : elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
579 : break;
580 : }
581 :
582 1699314 : WRITE_BOOL_FIELD(lateral);
583 1699314 : WRITE_BOOL_FIELD(inFromCl);
584 1699314 : WRITE_NODE_FIELD(securityQuals);
585 1699314 : }
586 :
587 : static void
588 670392 : _outA_Expr(StringInfo str, const A_Expr *node)
589 : {
590 670392 : WRITE_NODE_TYPE("A_EXPR");
591 :
592 670392 : switch (node->kind)
593 : {
594 619324 : case AEXPR_OP:
595 619324 : WRITE_NODE_FIELD(name);
596 619324 : break;
597 16934 : case AEXPR_OP_ANY:
598 16934 : appendStringInfoString(str, " ANY");
599 16934 : WRITE_NODE_FIELD(name);
600 16934 : break;
601 144 : case AEXPR_OP_ALL:
602 144 : appendStringInfoString(str, " ALL");
603 144 : WRITE_NODE_FIELD(name);
604 144 : break;
605 1254 : case AEXPR_DISTINCT:
606 1254 : appendStringInfoString(str, " DISTINCT");
607 1254 : WRITE_NODE_FIELD(name);
608 1254 : break;
609 74 : case AEXPR_NOT_DISTINCT:
610 74 : appendStringInfoString(str, " NOT_DISTINCT");
611 74 : WRITE_NODE_FIELD(name);
612 74 : break;
613 696 : case AEXPR_NULLIF:
614 696 : appendStringInfoString(str, " NULLIF");
615 696 : WRITE_NODE_FIELD(name);
616 696 : break;
617 28708 : case AEXPR_IN:
618 28708 : appendStringInfoString(str, " IN");
619 28708 : WRITE_NODE_FIELD(name);
620 28708 : break;
621 2342 : case AEXPR_LIKE:
622 2342 : appendStringInfoString(str, " LIKE");
623 2342 : WRITE_NODE_FIELD(name);
624 2342 : break;
625 204 : case AEXPR_ILIKE:
626 204 : appendStringInfoString(str, " ILIKE");
627 204 : WRITE_NODE_FIELD(name);
628 204 : break;
629 118 : case AEXPR_SIMILAR:
630 118 : appendStringInfoString(str, " SIMILAR");
631 118 : WRITE_NODE_FIELD(name);
632 118 : break;
633 558 : case AEXPR_BETWEEN:
634 558 : appendStringInfoString(str, " BETWEEN");
635 558 : WRITE_NODE_FIELD(name);
636 558 : break;
637 12 : case AEXPR_NOT_BETWEEN:
638 12 : appendStringInfoString(str, " NOT_BETWEEN");
639 12 : WRITE_NODE_FIELD(name);
640 12 : break;
641 12 : case AEXPR_BETWEEN_SYM:
642 12 : appendStringInfoString(str, " BETWEEN_SYM");
643 12 : WRITE_NODE_FIELD(name);
644 12 : break;
645 12 : case AEXPR_NOT_BETWEEN_SYM:
646 12 : appendStringInfoString(str, " NOT_BETWEEN_SYM");
647 12 : WRITE_NODE_FIELD(name);
648 12 : break;
649 0 : default:
650 0 : elog(ERROR, "unrecognized A_Expr_Kind: %d", (int) node->kind);
651 : break;
652 : }
653 :
654 670392 : WRITE_NODE_FIELD(lexpr);
655 670392 : WRITE_NODE_FIELD(rexpr);
656 670392 : WRITE_LOCATION_FIELD(rexpr_list_start);
657 670392 : WRITE_LOCATION_FIELD(rexpr_list_end);
658 670392 : WRITE_LOCATION_FIELD(location);
659 670392 : }
660 :
661 : static void
662 472898 : _outInteger(StringInfo str, const Integer *node)
663 : {
664 472898 : appendStringInfo(str, "%d", node->ival);
665 472898 : }
666 :
667 : static void
668 12046 : _outFloat(StringInfo str, const Float *node)
669 : {
670 : /*
671 : * We assume the value is a valid numeric literal and so does not need
672 : * quoting.
673 : */
674 12046 : appendStringInfoString(str, node->fval);
675 12046 : }
676 :
677 : static void
678 105232 : _outBoolean(StringInfo str, const Boolean *node)
679 : {
680 105232 : appendStringInfoString(str, node->boolval ? "true" : "false");
681 105232 : }
682 :
683 : static void
684 27815970 : _outString(StringInfo str, const String *node)
685 : {
686 : /*
687 : * We use outToken to provide escaping of the string's content, but we
688 : * don't want it to convert an empty string to '""', because we're putting
689 : * double quotes around the string already.
690 : */
691 27815970 : appendStringInfoChar(str, '"');
692 27815970 : if (node->sval[0] != '\0')
693 27783864 : outToken(str, node->sval);
694 27815970 : appendStringInfoChar(str, '"');
695 27815970 : }
696 :
697 : static void
698 4068 : _outBitString(StringInfo str, const BitString *node)
699 : {
700 : /*
701 : * The lexer will always produce a string starting with 'b' or 'x'. There
702 : * might be characters following that that need escaping, but outToken
703 : * won't escape the 'b' or 'x'. This is relied on by nodeTokenType.
704 : */
705 : Assert(node->bsval[0] == 'b' || node->bsval[0] == 'x');
706 4068 : outToken(str, node->bsval);
707 4068 : }
708 :
709 : static void
710 1462464 : _outA_Const(StringInfo str, const A_Const *node)
711 : {
712 1462464 : WRITE_NODE_TYPE("A_CONST");
713 :
714 1462464 : if (node->isnull)
715 87208 : appendStringInfoString(str, " NULL");
716 : else
717 : {
718 1375256 : appendStringInfoString(str, " :val ");
719 1375256 : outNode(str, &node->val);
720 : }
721 1462464 : WRITE_LOCATION_FIELD(location);
722 1462464 : }
723 :
724 :
725 : /*
726 : * outNode -
727 : * converts a Node into ascii string and append it to 'str'
728 : */
729 : void
730 148618362 : outNode(StringInfo str, const void *obj)
731 : {
732 : /* Guard against stack overflow due to overly complex expressions */
733 148618362 : check_stack_depth();
734 :
735 148618362 : if (obj == NULL)
736 53198004 : appendStringInfoString(str, "<>");
737 95420358 : else if (IsA(obj, List) || IsA(obj, IntList) || IsA(obj, OidList) ||
738 77041488 : IsA(obj, XidList))
739 18378870 : _outList(str, obj);
740 : /* nodeRead does not want to see { } around these! */
741 77041488 : else if (IsA(obj, Integer))
742 472898 : _outInteger(str, (Integer *) obj);
743 76568590 : else if (IsA(obj, Float))
744 12046 : _outFloat(str, (Float *) obj);
745 76556544 : else if (IsA(obj, Boolean))
746 105232 : _outBoolean(str, (Boolean *) obj);
747 76451312 : else if (IsA(obj, String))
748 27815970 : _outString(str, (String *) obj);
749 48635342 : else if (IsA(obj, BitString))
750 4068 : _outBitString(str, (BitString *) obj);
751 48631274 : else if (IsA(obj, Bitmapset))
752 0 : outBitmapset(str, (Bitmapset *) obj);
753 : else
754 : {
755 48631274 : appendStringInfoChar(str, '{');
756 48631274 : switch (nodeTag(obj))
757 : {
758 : #include "outfuncs.switch.c"
759 :
760 0 : default:
761 :
762 : /*
763 : * This should be an ERROR, but it's too useful to be able to
764 : * dump structures that outNode only understands part of.
765 : */
766 0 : elog(WARNING, "could not dump unrecognized node type: %d",
767 : (int) nodeTag(obj));
768 0 : break;
769 : }
770 48631274 : appendStringInfoChar(str, '}');
771 : }
772 148618362 : }
773 :
774 : /*
775 : * nodeToString -
776 : * returns the ascii representation of the Node as a palloc'd string
777 : *
778 : * write_loc_fields determines whether location fields are output with their
779 : * actual value rather than -1. The actual value can be useful for debugging,
780 : * but for most uses, the actual value is not useful, since the original query
781 : * string is no longer available.
782 : */
783 : static char *
784 2029618 : nodeToStringInternal(const void *obj, bool write_loc_fields)
785 : {
786 : StringInfoData str;
787 : bool save_write_location_fields;
788 :
789 2029618 : save_write_location_fields = write_location_fields;
790 2029618 : write_location_fields = write_loc_fields;
791 :
792 : /* see stringinfo.h for an explanation of this maneuver */
793 2029618 : initStringInfo(&str);
794 2029618 : outNode(&str, obj);
795 :
796 2029618 : write_location_fields = save_write_location_fields;
797 :
798 2029618 : return str.data;
799 : }
800 :
801 : /*
802 : * Externally visible entry points
803 : */
804 : char *
805 70238 : nodeToString(const void *obj)
806 : {
807 70238 : return nodeToStringInternal(obj, false);
808 : }
809 :
810 : char *
811 1959380 : nodeToStringWithLocations(const void *obj)
812 : {
813 1959380 : return nodeToStringInternal(obj, true);
814 : }
815 :
816 :
817 : /*
818 : * bmsToString -
819 : * returns the ascii representation of the Bitmapset as a palloc'd string
820 : */
821 : char *
822 0 : bmsToString(const Bitmapset *bms)
823 : {
824 : StringInfoData str;
825 :
826 : /* see stringinfo.h for an explanation of this maneuver */
827 0 : initStringInfo(&str);
828 0 : outBitmapset(&str, bms);
829 0 : return str.data;
830 : }
|
