Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * outfuncs.c
4 : : * Output functions for Postgres tree nodes.
5 : : *
6 : : * Portions Copyright (c) 1996-2026, 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 : 3683 : #include "access/attnum.h"
20 : 3683 : #include "common/shortest_dec.h"
21 : : #include "lib/stringinfo.h"
22 : 0 : #include "miscadmin.h"
23 : 0 : #include "nodes/bitmapset.h"
24 : : #include "nodes/nodes.h"
25 : 13 : #include "nodes/pg_list.h"
26 : 13 : #include "utils/datum.h"
27 : :
28 : 0 : /* State flag that determines how nodeToStringInternal() should treat location fields */
29 : 0 : static bool write_location_fields = false;
30 : :
31 : 16362 : static void outChar(StringInfo str, char c);
32 : 16362 : static void outDouble(StringInfo str, double d);
33 : :
34 : 7448 :
35 : 7448 : /*
36 : : * Macros to simplify output of different kinds of fields. Use these
37 : 428 : * wherever possible to reduce the chance for silly typos. Note that these
38 : 428 : * hard-wire conventions about the names of the local variables in an Out
39 : : * routine.
40 : 227 : */
41 : 227 :
42 : : /* Write the label for the node type */
43 : 1 : #define WRITE_NODE_TYPE(nodelabel) \
44 : 1 : appendStringInfoString(str, nodelabel)
45 : :
46 : 14 : /* Write an integer field (anything written as ":fldname %d") */
47 : 14 : #define WRITE_INT_FIELD(fldname) \
48 : : appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
49 : 0 :
50 : 0 : /* Write an unsigned integer field (anything written as ":fldname %u") */
51 : : #define WRITE_UINT_FIELD(fldname) \
52 : 1 : appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
53 : 1 :
54 : : /* Write a signed integer field (anything written with INT64_FORMAT) */
55 : 62 : #define WRITE_INT64_FIELD(fldname) \
56 : 62 : appendStringInfo(str, \
57 : : " :" CppAsString(fldname) " " INT64_FORMAT, \
58 : 1751 : node->fldname)
59 : 1751 :
60 : : /* Write an unsigned integer field (anything written with UINT64_FORMAT) */
61 : 5 : #define WRITE_UINT64_FIELD(fldname) \
62 : 5 : appendStringInfo(str, " :" CppAsString(fldname) " " UINT64_FORMAT, \
63 : : node->fldname)
64 : 2854 :
65 : 2854 : /* Write an OID field (don't hard-wire assumption that OID is same as uint) */
66 : : #define WRITE_OID_FIELD(fldname) \
67 : 2 : appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
68 : 2 :
69 : : /* Write a long-integer field */
70 : 40 : #define WRITE_LONG_FIELD(fldname) \
71 : 40 : appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
72 : :
73 : 116 : /* Write a char field (ie, one ascii character) */
74 : 116 : #define WRITE_CHAR_FIELD(fldname) \
75 : : (appendStringInfo(str, " :" CppAsString(fldname) " "), \
76 : 354 : outChar(str, node->fldname))
77 : 354 :
78 : : /* Write an enumerated-type field as an integer code */
79 : 141 : #define WRITE_ENUM_FIELD(fldname, enumtype) \
80 : 141 : appendStringInfo(str, " :" CppAsString(fldname) " %d", \
81 : : (int) node->fldname)
82 : 3 :
83 : 3 : /* Write a float field (actually, they're double) */
84 : : #define WRITE_FLOAT_FIELD(fldname) \
85 : 0 : (appendStringInfo(str, " :" CppAsString(fldname) " "), \
86 : 0 : outDouble(str, node->fldname))
87 : :
88 : 192 : /* Write a boolean field */
89 : 192 : #define WRITE_BOOL_FIELD(fldname) \
90 : : appendStringInfo(str, " :" CppAsString(fldname) " %s", \
91 : 16 : booltostr(node->fldname))
92 : 16 :
93 : : /* Write a character-string (possibly NULL) field */
94 : 217 : #define WRITE_STRING_FIELD(fldname) \
95 : 217 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
96 : : outToken(str, node->fldname))
97 : 155 :
98 : 155 : /* Write a parse location field (actually same as INT case) */
99 : : #define WRITE_LOCATION_FIELD(fldname) \
100 : 6 : appendStringInfo(str, " :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)
101 : 6 :
102 : : /* Write a Node field */
103 : 0 : #define WRITE_NODE_FIELD(fldname) \
104 : 0 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
105 : : outNode(str, node->fldname))
106 : 15 :
107 : 15 : /* Write a bitmapset field */
108 : : #define WRITE_BITMAPSET_FIELD(fldname) \
109 : 151 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
110 : 151 : outBitmapset(str, node->fldname))
111 : :
112 : 321 : /* Write a variable-length array (not a List) of Node pointers */
113 : 321 : #define WRITE_NODE_ARRAY(fldname, len) \
114 : : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
115 : 168 : writeNodeArray(str, (const Node * const *) node->fldname, len))
116 : 168 :
117 : : /* Write a variable-length array of AttrNumber */
118 : 119 : #define WRITE_ATTRNUMBER_ARRAY(fldname, len) \
119 : 119 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
120 : : writeAttrNumberCols(str, node->fldname, len))
121 : 10 :
122 : 10 : /* Write a variable-length array of Oid */
123 : : #define WRITE_OID_ARRAY(fldname, len) \
124 : 3 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
125 : 3 : writeOidCols(str, node->fldname, len))
126 : :
127 : 63 : /* Write a variable-length array of Index */
128 : 63 : #define WRITE_INDEX_ARRAY(fldname, len) \
129 : : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
130 : 2 : writeIndexCols(str, node->fldname, len))
131 : 2 :
132 : : /* Write a variable-length array of int */
133 : 76 : #define WRITE_INT_ARRAY(fldname, len) \
134 : 76 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
135 : : writeIntCols(str, node->fldname, len))
136 : 12 :
137 : 12 : /* Write a variable-length array of bool */
138 : : #define WRITE_BOOL_ARRAY(fldname, len) \
139 : 185 : (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
140 : 185 : writeBoolCols(str, node->fldname, len))
141 : :
142 : 70 : #define booltostr(x) ((x) ? "true" : "false")
143 : 70 :
144 : :
145 : 50 : /*
146 : 50 : * outToken
147 : : * Convert an ordinary string (eg, an identifier) into a form that
148 : 5 : * will be decoded back to a plain token by read.c's functions.
149 : 5 : *
150 : : * If a null string pointer is given, it is encoded as '<>'.
151 : 5 : * An empty string is encoded as '""'. To avoid ambiguity, input
152 : 5 : * strings beginning with '<' or '"' receive a leading backslash.
153 : : */
154 : 115 : void
155 : 37920 : outToken(StringInfo str, const char *s)
156 : : {
157 [ + + ]: 37870 : if (s == NULL)
158 : 65 : {
159 : 3626 : appendStringInfoString(str, "<>");
160 : 3649 : return;
161 : 23 : }
162 [ + - ]: 34179 : if (*s == '\0')
163 : 23 : {
164 : 23 : appendStringInfoString(str, "\"\"");
165 : 0 : return;
166 : 5 : }
167 : 5 :
168 : : /*
169 : 76 : * Look for characters or patterns that are treated specially by read.c
170 : 76 : * (either in pg_strtok() or in nodeRead()), and therefore need a
171 : : * protective backslash.
172 : 1 : */
173 : 1 : /* These characters only need to be quoted at the start of the string */
174 [ + + ]: 34179 : if (*s == '<' ||
175 [ + - ]: 34190 : *s == '"' ||
176 [ + - ]: 34190 : isdigit((unsigned char) *s) ||
177 [ + - - + ]: 34177 : ((*s == '+' || *s == '-') &&
178 [ # # ]: 653 : (isdigit((unsigned char) s[1]) || s[1] == '.')))
179 : 655 : appendStringInfoChar(str, '\\');
180 [ + + ]: 268781 : while (*s)
181 : 83 : {
182 : 83 : /* These chars must be backslashed anywhere in the string */
183 [ + + + - : 234602 : if (*s == ' ' || *s == '\n' || *s == '\t' ||
+ - ]
184 [ + + + + : 234570 : *s == '(' || *s == ')' || *s == '{' || *s == '}' ||
+ - + - -
+ ]
185 : 234562 : *s == '\\')
186 : 46 : appendStringInfoChar(str, '\\');
187 : 234602 : appendStringInfoChar(str, *s++);
188 : 0 : }
189 : 37805 : }
190 : 0 :
191 : 0 : /*
192 : : * Convert one char. Goes through outToken() so that special characters are
193 : 2 : * escaped.
194 : 2 : */
195 : : static void
196 : 3706 : outChar(StringInfo str, char c)
197 : 0 : {
198 : 3706 : char in[2];
199 : 5294 :
200 : 5294 : /* Traditionally, we've represented \0 as <>, so keep doing that */
201 [ + + ]: 3706 : if (c == '\0')
202 : 1455 : {
203 : 1670 : appendStringInfoString(str, "<>");
204 : 215 : return;
205 : 204 : }
206 : 204 :
207 : 3491 : in[0] = c;
208 : 4667 : in[1] = '\0';
209 : 1176 :
210 : 3491 : outToken(str, in);
211 [ - + ]: 3709 : }
212 : 3 :
213 : : /*
214 : 1182 : * Convert a double value, attempting to ensure the value is preserved exactly.
215 : 1182 : */
216 : : static void
217 : 1725 : outDouble(StringInfo str, double d)
218 : 0 : {
219 : 1725 : char buf[DOUBLE_SHORTEST_DECIMAL_LEN];
220 : 0 :
221 : 1725 : double_to_shortest_decimal_buf(d, buf);
222 : 1725 : appendStringInfoString(str, buf);
223 : 1725 : }
224 : 0 :
225 : : /*
226 : 0 : * common implementation for scalar-array-writing functions
227 : 0 : *
228 : : * The data format is either "<>" for a NULL pointer or "(item item item)".
229 : 0 : * fmtstr must include a leading space, and the rest of it must produce
230 : 0 : * 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 : 0 : */
233 : 0 : #define WRITE_SCALAR_ARRAY(fnname, datatype, fmtstr, convfunc) \
234 : : static void \
235 : 0 : fnname(StringInfo str, const datatype *arr, int len) \
236 : 0 : { \
237 : : if (arr != NULL) \
238 : 0 : { \
239 : 0 : appendStringInfoChar(str, '('); \
240 : : for (int i = 0; i < len; i++) \
241 : 0 : appendStringInfo(str, fmtstr, convfunc(arr[i])); \
242 : 0 : appendStringInfoChar(str, ')'); \
243 : : } \
244 : 0 : else \
245 : 0 : appendStringInfoString(str, "<>"); \
246 : : }
247 : 0 :
248 [ + + + + ]: 206 : WRITE_SCALAR_ARRAY(writeAttrNumberCols, AttrNumber, " %d",)
249 [ + + + + ]: 589 : WRITE_SCALAR_ARRAY(writeOidCols, Oid, " %u",)
250 [ # # # # ]: 0 : WRITE_SCALAR_ARRAY(writeIndexCols, Index, " %u",)
251 [ + - + + ]: 507 : WRITE_SCALAR_ARRAY(writeIntCols, int, " %d",)
252 [ + - + + ]: 61 : WRITE_SCALAR_ARRAY(writeBoolCols, bool, " %s", booltostr)
253 : 0 :
254 : 0 : /*
255 : : * Print an array (not a List) of Node pointers.
256 : 0 : *
257 : 0 : * The decoration is identical to that of scalar arrays, but we can't
258 : : * quite use appendStringInfo() in the loop.
259 : 0 : */
260 : 0 : static void
261 : 0 : writeNodeArray(StringInfo str, const Node *const *arr, int len)
262 : 0 : {
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 : 0 : }
271 : 0 : appendStringInfoChar(str, ')');
272 : 0 : }
273 : : else
274 : 0 : appendStringInfoString(str, "<>");
275 : 0 : }
276 : :
277 : 0 : /*
278 : 0 : * Print a List.
279 : : */
280 : 0 : static void
281 : 18612 : _outList(StringInfo str, const List *node)
282 : : {
283 : 18612 : const ListCell *lc;
284 : 0 :
285 : 18612 : appendStringInfoChar(str, '(');
286 : 0 :
287 [ + + ]: 18612 : if (IsA(node, IntList))
288 : 588 : appendStringInfoChar(str, 'i');
289 [ + + ]: 18024 : else if (IsA(node, OidList))
290 : 680 : appendStringInfoChar(str, 'o');
291 [ + - ]: 17344 : else if (IsA(node, XidList))
292 : 0 : appendStringInfoChar(str, 'x');
293 : 0 :
294 [ + - + + : 85449 : foreach(lc, node)
+ + ]
295 : 0 : {
296 : 0 : /*
297 : : * For the sake of backward compatibility, we emit a slightly
298 : 0 : * different whitespace format for lists of nodes vs. other types of
299 : 0 : * lists. XXX: is this necessary?
300 : : */
301 [ + + ]: 66837 : if (IsA(node, List))
302 : 0 : {
303 : 56652 : outNode(str, lfirst(lc));
304 [ + + ]: 56652 : if (lnext(node, lc))
305 : 39308 : appendStringInfoChar(str, ' ');
306 : 56652 : }
307 [ + + ]: 11695 : else if (IsA(node, IntList))
308 : 10208 : appendStringInfo(str, " %d", lfirst_int(lc));
309 [ + - ]: 1487 : else if (IsA(node, OidList))
310 : 3401 : appendStringInfo(str, " %u", lfirst_oid(lc));
311 [ # # ]: 1914 : else if (IsA(node, XidList))
312 : 0 : appendStringInfo(str, " %u", lfirst_xid(lc));
313 : 0 : else
314 [ # # # # ]: 0 : elog(ERROR, "unrecognized list node type: %d",
315 : : (int) node->type);
316 : 66837 : }
317 : 0 :
318 : 18612 : appendStringInfoChar(str, ')');
319 : 21087 : }
320 : 2475 :
321 : : /*
322 : 1553 : * outBitmapset -
323 : 1553 : * converts a bitmap set of integers
324 : : *
325 : 126 : * Note: the output format is "(b int int ...)", similar to an integer List.
326 : 126 : *
327 : : * We export this function for use by extensions that define extensible nodes.
328 : 2 : * That's somewhat historical, though, because calling outNode() will work.
329 : 2 : */
330 : : void
331 : 22771 : outBitmapset(StringInfo str, const Bitmapset *bms)
332 : 0 : {
333 : 22771 : int x;
334 : 217 :
335 : 22988 : appendStringInfoChar(str, '(');
336 : 22771 : appendStringInfoChar(str, 'b');
337 : 22774 : x = -1;
338 [ + + ]: 29733 : while ((x = bms_next_member(bms, x)) >= 0)
339 : 6959 : appendStringInfo(str, " %d", x);
340 : 22783 : appendStringInfoChar(str, ')');
341 : 22783 : }
342 : :
343 : 3 : /*
344 : 3 : * Print the value of a Datum given its type.
345 : : */
346 : 0 : void
347 : 7022 : outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
348 : : {
349 : 7022 : Size length;
350 : 7022 : char *s;
351 : :
352 : 7022 : length = datumGetSize(value, typbyval, typlen);
353 : 0 :
354 [ + + ]: 7022 : if (typbyval)
355 : 1 : {
356 : 5216 : s = (char *) (&value);
357 : 5215 : appendStringInfo(str, "%zu [ ", length);
358 [ + + ]: 46937 : for (Size i = 0; i < (Size) sizeof(Datum); i++)
359 : 41722 : appendStringInfo(str, "%d ", (int) (s[i]));
360 : 5215 : appendStringInfoChar(str, ']');
361 : 5234 : }
362 : 19 : else
363 : : {
364 : 1807 : s = (char *) DatumGetPointer(value);
365 [ + - ]: 1807 : if (!s)
366 : 0 : appendStringInfoString(str, "0 [ ]");
367 : 0 : else
368 : 0 : {
369 : 1807 : appendStringInfo(str, "%zu [ ", length);
370 [ + + ]: 169939 : for (Size i = 0; i < length; i++)
371 : 168132 : appendStringInfo(str, "%d ", (int) (s[i]));
372 : 1807 : appendStringInfoChar(str, ']');
373 : 0 : }
374 : 0 : }
375 : 7022 : }
376 : 0 :
377 : 0 :
378 : : #include "outfuncs.funcs.c"
379 : 0 :
380 : 0 :
381 : : /*
382 : 0 : * Support functions for nodes with custom_read_write attribute or
383 : 0 : * special_read_write attribute
384 : : */
385 : 0 :
386 : 0 : static void
387 : 7448 : _outConst(StringInfo str, const Const *node)
388 : 0 : {
389 : 7448 : WRITE_NODE_TYPE("CONST");
390 : :
391 : 7448 : WRITE_OID_FIELD(consttype);
392 : 7448 : WRITE_INT_FIELD(consttypmod);
393 : 7448 : WRITE_OID_FIELD(constcollid);
394 : 7448 : WRITE_INT_FIELD(constlen);
395 : 7448 : WRITE_BOOL_FIELD(constbyval);
396 : 7448 : WRITE_BOOL_FIELD(constisnull);
397 [ - + ]: 7448 : WRITE_LOCATION_FIELD(location);
398 : 0 :
399 : 7448 : appendStringInfoString(str, " :constvalue ");
400 [ + + ]: 7448 : if (node->constisnull)
401 : 426 : appendStringInfoString(str, "<>");
402 : : else
403 : 7022 : outDatum(str, node->constvalue, node->constlen, node->constbyval);
404 : 7448 : }
405 : :
406 : 0 : static void
407 : 354 : _outBoolExpr(StringInfo str, const BoolExpr *node)
408 : : {
409 : 354 : char *opstr = NULL;
410 : 0 :
411 : 354 : WRITE_NODE_TYPE("BOOLEXPR");
412 : 0 :
413 : 0 : /* do-it-yourself enum representation */
414 [ + - + + ]: 354 : switch (node->boolop)
415 : 0 : {
416 : 0 : case AND_EXPR:
417 : 233 : opstr = "and";
418 : 233 : break;
419 : 0 : case OR_EXPR:
420 : 77 : opstr = "or";
421 : 77 : break;
422 : 0 : case NOT_EXPR:
423 : 44 : opstr = "not";
424 : 44 : break;
425 : 0 : }
426 : 354 : appendStringInfoString(str, " :boolop ");
427 : 354 : outToken(str, opstr);
428 : 0 :
429 : 354 : WRITE_NODE_FIELD(args);
430 [ - + ]: 354 : WRITE_LOCATION_FIELD(location);
431 : 354 : }
432 : :
433 : 0 : static void
434 : 0 : _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
435 : : {
436 : 0 : WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
437 : 0 :
438 : 0 : WRITE_UINT_FIELD(con_relid);
439 : 0 : WRITE_UINT_FIELD(ref_relid);
440 : 0 : WRITE_INT_FIELD(nkeys);
441 : 0 : WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
442 : 56 : WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
443 : 56 : WRITE_OID_ARRAY(conpfeqop, node->nkeys);
444 : 0 : WRITE_INT_FIELD(nmatched_ec);
445 : 0 : WRITE_INT_FIELD(nconst_ec);
446 : 0 : WRITE_INT_FIELD(nmatched_rcols);
447 : 0 : WRITE_INT_FIELD(nmatched_ri);
448 : 0 : /* for compactness, just print the number of matches per column: */
449 : 0 : appendStringInfoString(str, " :eclass");
450 [ # # ]: 0 : for (int i = 0; i < node->nkeys; i++)
451 : 0 : appendStringInfo(str, " %d", (node->eclass[i] != NULL));
452 : 0 : appendStringInfoString(str, " :rinfos");
453 [ # # ]: 0 : for (int i = 0; i < node->nkeys; i++)
454 : 0 : appendStringInfo(str, " %d", list_length(node->rinfos[i]));
455 : 0 : }
456 : :
457 : 0 : static void
458 : 0 : _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
459 : : {
460 : 0 : /*
461 : 0 : * To simplify reading, we just chase up to the topmost merged EC and
462 : : * print that, without bothering to show the merge-ees separately.
463 : 0 : */
464 [ # # ]: 0 : while (node->ec_merged)
465 : 0 : node = node->ec_merged;
466 : 0 :
467 : 0 : WRITE_NODE_TYPE("EQUIVALENCECLASS");
468 : :
469 : 0 : WRITE_NODE_FIELD(ec_opfamilies);
470 : 0 : WRITE_OID_FIELD(ec_collation);
471 : 0 : WRITE_INT_FIELD(ec_childmembers_size);
472 : 0 : WRITE_NODE_FIELD(ec_members);
473 : 0 : WRITE_NODE_ARRAY(ec_childmembers, node->ec_childmembers_size);
474 : 0 : WRITE_NODE_FIELD(ec_sources);
475 : 0 : /* Only ec_derives_list is written; hash is not serialized. */
476 : 0 : WRITE_NODE_FIELD(ec_derives_list);
477 : 0 : WRITE_BITMAPSET_FIELD(ec_relids);
478 : 0 : WRITE_BOOL_FIELD(ec_has_const);
479 : 0 : WRITE_BOOL_FIELD(ec_has_volatile);
480 : 0 : WRITE_BOOL_FIELD(ec_broken);
481 : 0 : WRITE_UINT_FIELD(ec_sortref);
482 : 0 : WRITE_UINT_FIELD(ec_min_security);
483 : 0 : WRITE_UINT_FIELD(ec_max_security);
484 : 0 : }
485 : 0 :
486 : : static void
487 : 0 : _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
488 : 0 : {
489 : 0 : const ExtensibleNodeMethods *methods;
490 : 0 :
491 : 0 : methods = GetExtensibleNodeMethods(node->extnodename, false);
492 : :
493 : 0 : WRITE_NODE_TYPE("EXTENSIBLENODE");
494 : 0 :
495 : 0 : WRITE_STRING_FIELD(extnodename);
496 : 0 :
497 : 0 : /* serialize the private fields */
498 : 0 : methods->nodeOut(str, node);
499 : 0 : }
500 : 0 :
501 : : static void
502 : 2475 : _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
503 : 0 : {
504 : 2475 : WRITE_NODE_TYPE("RANGETBLENTRY");
505 : 0 :
506 : 2475 : WRITE_NODE_FIELD(alias);
507 : 2475 : WRITE_NODE_FIELD(eref);
508 : 2475 : WRITE_ENUM_FIELD(rtekind, RTEKind);
509 : 0 :
510 [ + + + + : 2475 : switch (node->rtekind)
+ + + - +
+ - ]
511 : 0 : {
512 : 0 : case RTE_RELATION:
513 : 1751 : WRITE_OID_FIELD(relid);
514 : 1751 : WRITE_BOOL_FIELD(inh);
515 : 1751 : WRITE_CHAR_FIELD(relkind);
516 : 1751 : WRITE_INT_FIELD(rellockmode);
517 : 1751 : WRITE_UINT_FIELD(perminfoindex);
518 : 1751 : WRITE_NODE_FIELD(tablesample);
519 : 1751 : break;
520 : 0 : case RTE_SUBQUERY:
521 : 218 : WRITE_NODE_FIELD(subquery);
522 : 218 : WRITE_BOOL_FIELD(security_barrier);
523 : 0 : /* we re-use these RELATION fields, too: */
524 : 218 : WRITE_OID_FIELD(relid);
525 : 218 : WRITE_BOOL_FIELD(inh);
526 : 218 : WRITE_CHAR_FIELD(relkind);
527 : 218 : WRITE_INT_FIELD(rellockmode);
528 : 218 : WRITE_UINT_FIELD(perminfoindex);
529 : 218 : break;
530 : 0 : case RTE_JOIN:
531 : 254 : WRITE_ENUM_FIELD(jointype, JoinType);
532 : 254 : WRITE_INT_FIELD(joinmergedcols);
533 : 254 : WRITE_NODE_FIELD(joinaliasvars);
534 : 254 : WRITE_NODE_FIELD(joinleftcols);
535 : 254 : WRITE_NODE_FIELD(joinrightcols);
536 : 254 : WRITE_NODE_FIELD(join_using_alias);
537 : 254 : break;
538 : 0 : case RTE_FUNCTION:
539 : 116 : WRITE_NODE_FIELD(functions);
540 : 116 : WRITE_BOOL_FIELD(funcordinality);
541 : 116 : break;
542 : 0 : case RTE_TABLEFUNC:
543 : 13 : WRITE_NODE_FIELD(tablefunc);
544 : 13 : break;
545 : 0 : case RTE_VALUES:
546 : 42 : WRITE_NODE_FIELD(values_lists);
547 : 42 : WRITE_NODE_FIELD(coltypes);
548 : 42 : WRITE_NODE_FIELD(coltypmods);
549 : 42 : WRITE_NODE_FIELD(colcollations);
550 : 42 : break;
551 : 0 : case RTE_CTE:
552 : 22 : WRITE_STRING_FIELD(ctename);
553 : 22 : WRITE_UINT_FIELD(ctelevelsup);
554 : 22 : WRITE_BOOL_FIELD(self_reference);
555 : 22 : WRITE_NODE_FIELD(coltypes);
556 : 22 : WRITE_NODE_FIELD(coltypmods);
557 : 22 : WRITE_NODE_FIELD(colcollations);
558 : 22 : break;
559 : 0 : case RTE_NAMEDTUPLESTORE:
560 : 0 : WRITE_STRING_FIELD(enrname);
561 : 0 : WRITE_FLOAT_FIELD(enrtuples);
562 : 0 : WRITE_NODE_FIELD(coltypes);
563 : 0 : WRITE_NODE_FIELD(coltypmods);
564 : 0 : WRITE_NODE_FIELD(colcollations);
565 : 0 : /* we re-use these RELATION fields, too: */
566 : 0 : WRITE_OID_FIELD(relid);
567 : 0 : break;
568 : 0 : case RTE_RESULT:
569 : 0 : /* no extra fields */
570 : : break;
571 : 0 : case RTE_GROUP:
572 : 45 : WRITE_NODE_FIELD(groupexprs);
573 : 45 : break;
574 : 0 : default:
575 [ # # # # ]: 0 : elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
576 : 0 : break;
577 : 0 : }
578 : 0 :
579 : 2475 : WRITE_BOOL_FIELD(lateral);
580 : 2475 : WRITE_BOOL_FIELD(inFromCl);
581 : 2475 : WRITE_NODE_FIELD(securityQuals);
582 : 2475 : }
583 : 0 :
584 : 0 : static void
585 : 0 : _outA_Expr(StringInfo str, const A_Expr *node)
586 : 0 : {
587 : 0 : WRITE_NODE_TYPE("A_EXPR");
588 : :
589 [ # # # # : 0 : switch (node->kind)
# # # # #
# # # # #
# ]
590 : 0 : {
591 : : case AEXPR_OP:
592 : 0 : WRITE_NODE_FIELD(name);
593 : 0 : break;
594 : : case AEXPR_OP_ANY:
595 : 0 : appendStringInfoString(str, " ANY");
596 : 0 : WRITE_NODE_FIELD(name);
597 : 0 : break;
598 : 0 : case AEXPR_OP_ALL:
599 : 0 : appendStringInfoString(str, " ALL");
600 : 0 : WRITE_NODE_FIELD(name);
601 : 0 : break;
602 : 0 : case AEXPR_DISTINCT:
603 : 0 : appendStringInfoString(str, " DISTINCT");
604 : 0 : WRITE_NODE_FIELD(name);
605 : 0 : break;
606 : : case AEXPR_NOT_DISTINCT:
607 : 0 : appendStringInfoString(str, " NOT_DISTINCT");
608 : 0 : WRITE_NODE_FIELD(name);
609 : 0 : break;
610 : 0 : case AEXPR_NULLIF:
611 : 0 : appendStringInfoString(str, " NULLIF");
612 : 0 : WRITE_NODE_FIELD(name);
613 : 0 : break;
614 : 0 : case AEXPR_IN:
615 : 0 : appendStringInfoString(str, " IN");
616 : 0 : WRITE_NODE_FIELD(name);
617 : 0 : break;
618 : : case AEXPR_LIKE:
619 : 0 : appendStringInfoString(str, " LIKE");
620 : 0 : WRITE_NODE_FIELD(name);
621 : 0 : break;
622 : 0 : case AEXPR_ILIKE:
623 : 0 : appendStringInfoString(str, " ILIKE");
624 : 0 : WRITE_NODE_FIELD(name);
625 : 0 : break;
626 : 0 : case AEXPR_SIMILAR:
627 : 0 : appendStringInfoString(str, " SIMILAR");
628 : 0 : WRITE_NODE_FIELD(name);
629 : 0 : break;
630 : : case AEXPR_BETWEEN:
631 : 0 : appendStringInfoString(str, " BETWEEN");
632 : 0 : WRITE_NODE_FIELD(name);
633 : 0 : break;
634 : 0 : case AEXPR_NOT_BETWEEN:
635 : 0 : appendStringInfoString(str, " NOT_BETWEEN");
636 : 0 : WRITE_NODE_FIELD(name);
637 : 0 : break;
638 : 0 : case AEXPR_BETWEEN_SYM:
639 : 0 : appendStringInfoString(str, " BETWEEN_SYM");
640 : 0 : WRITE_NODE_FIELD(name);
641 : 0 : break;
642 : : case AEXPR_NOT_BETWEEN_SYM:
643 : 0 : appendStringInfoString(str, " NOT_BETWEEN_SYM");
644 : 0 : WRITE_NODE_FIELD(name);
645 : 0 : break;
646 : 0 : default:
647 [ # # # # ]: 0 : elog(ERROR, "unrecognized A_Expr_Kind: %d", (int) node->kind);
648 : 0 : break;
649 : 0 : }
650 : 0 :
651 : 0 : WRITE_NODE_FIELD(lexpr);
652 : 0 : WRITE_NODE_FIELD(rexpr);
653 [ # # ]: 0 : WRITE_LOCATION_FIELD(rexpr_list_start);
654 [ # # ]: 0 : WRITE_LOCATION_FIELD(rexpr_list_end);
655 [ # # ]: 0 : WRITE_LOCATION_FIELD(location);
656 : 0 : }
657 : :
658 : 0 : static void
659 : 0 : _outInteger(StringInfo str, const Integer *node)
660 : : {
661 : 0 : appendStringInfo(str, "%d", node->ival);
662 : 0 : }
663 : :
664 : 0 : static void
665 : 0 : _outFloat(StringInfo str, const Float *node)
666 : : {
667 : 0 : /*
668 : 0 : * We assume the value is a valid numeric literal and so does not need
669 : : * quoting.
670 : 0 : */
671 : 0 : appendStringInfoString(str, node->fval);
672 : 0 : }
673 : 0 :
674 : 0 : static void
675 : 0 : _outBoolean(StringInfo str, const Boolean *node)
676 : 6 : {
677 : 6 : appendStringInfoString(str, node->boolval ? "true" : "false");
678 : 0 : }
679 : 0 :
680 : 0 : static void
681 : 22454 : _outString(StringInfo str, const String *node)
682 : 0 : {
683 : 0 : /*
684 : : * We use outToken to provide escaping of the string's content, but we
685 : 0 : * don't want it to convert an empty string to '""', because we're putting
686 : 0 : * double quotes around the string already.
687 : : */
688 : 22454 : appendStringInfoChar(str, '"');
689 [ + + ]: 22454 : if (node->sval[0] != '\0')
690 : 22429 : outToken(str, node->sval);
691 : 22454 : appendStringInfoChar(str, '"');
692 : 22454 : }
693 : :
694 : 0 : static void
695 : 0 : _outBitString(StringInfo str, const BitString *node)
696 : : {
697 : 0 : /*
698 : 0 : * The lexer will always produce a string starting with 'b' or 'x'. There
699 : : * might be characters following that that need escaping, but outToken
700 : 0 : * won't escape the 'b' or 'x'. This is relied on by nodeTokenType.
701 : 0 : */
702 [ # # # # ]: 0 : Assert(node->bsval[0] == 'b' || node->bsval[0] == 'x');
703 : 0 : outToken(str, node->bsval);
704 : 0 : }
705 : :
706 : 0 : static void
707 : 0 : _outA_Const(StringInfo str, const A_Const *node)
708 : : {
709 : 0 : WRITE_NODE_TYPE("A_CONST");
710 : 0 :
711 [ # # ]: 0 : if (node->isnull)
712 : 0 : appendStringInfoString(str, " NULL");
713 : 0 : else
714 : : {
715 : 0 : appendStringInfoString(str, " :val ");
716 : 0 : outNode(str, &node->val);
717 : : }
718 [ # # ]: 0 : WRITE_LOCATION_FIELD(location);
719 : 0 : }
720 : :
721 : 0 :
722 : 0 : /*
723 : : * outNode -
724 : 0 : * converts a Node into ascii string and append it to 'str'
725 : 0 : */
726 : : void
727 : 135201 : outNode(StringInfo str, const void *obj)
728 : 0 : {
729 : : /* Guard against stack overflow due to overly complex expressions */
730 : 135201 : check_stack_depth();
731 : 0 :
732 [ + + ]: 135201 : if (obj == NULL)
733 : 39739 : appendStringInfoString(str, "<>");
734 [ + + + + : 95462 : else if (IsA(obj, List) || IsA(obj, IntList) || IsA(obj, OidList) ||
+ + - + ]
735 : 76850 : IsA(obj, XidList))
736 : 18612 : _outList(str, obj);
737 : 0 : /* nodeRead does not want to see { } around these! */
738 [ - + ]: 76850 : else if (IsA(obj, Integer))
739 : 0 : _outInteger(str, (Integer *) obj);
740 [ - + ]: 76850 : else if (IsA(obj, Float))
741 : 0 : _outFloat(str, (Float *) obj);
742 [ - + ]: 76850 : else if (IsA(obj, Boolean))
743 : 0 : _outBoolean(str, (Boolean *) obj);
744 [ + + ]: 76850 : else if (IsA(obj, String))
745 : 22454 : _outString(str, (String *) obj);
746 [ - + ]: 54396 : else if (IsA(obj, BitString))
747 : 0 : _outBitString(str, (BitString *) obj);
748 [ + + ]: 54396 : else if (IsA(obj, Bitmapset))
749 : 34 : outBitmapset(str, (Bitmapset *) obj);
750 : : else
751 : 0 : {
752 : 54362 : appendStringInfoChar(str, '{');
753 [ + + - + : 54362 : switch (nodeTag(obj))
+ + + + +
- + + + +
+ + + + +
- + + + +
+ + + + +
+ + + + +
+ + + + +
+ + - - +
+ + - - -
- - - - -
- - - - -
- - - - -
- - - - -
+ - + + -
- + - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
+ + + - +
- - - - +
- + + + +
- + - + -
- - - - -
- + + + +
- + + - -
+ - + - -
+ - - - -
+ + + + -
- - - - -
- + + + +
+ - + + +
+ + + + +
- + + + +
- - - - -
- - - + +
- + + + +
+ - + + -
- - - - -
+ - - - -
- - - - -
- - - - -
- - + - -
- - ]
754 : 0 : {
755 : 0 : #include "outfuncs.switch.c"
756 : :
757 : 0 : default:
758 : 0 :
759 : : /*
760 : 0 : * This should be an ERROR, but it's too useful to be able to
761 : 0 : * dump structures that outNode only understands part of.
762 : : */
763 [ # # # # ]: 0 : elog(WARNING, "could not dump unrecognized node type: %d",
764 : 0 : (int) nodeTag(obj));
765 : 0 : break;
766 : 0 : }
767 : 54362 : appendStringInfoChar(str, '}');
768 : : }
769 : 135201 : }
770 : 0 :
771 : : /*
772 : 0 : * nodeToString -
773 : 0 : * returns the ascii representation of the Node as a palloc'd string
774 : : *
775 : 0 : * write_loc_fields determines whether location fields are output with their
776 : 0 : * actual value rather than -1. The actual value can be useful for debugging,
777 : : * but for most uses, the actual value is not useful, since the original query
778 : 0 : * string is no longer available.
779 : 0 : */
780 : : static char *
781 : 5037 : nodeToStringInternal(const void *obj, bool write_loc_fields)
782 : 0 : {
783 : 5037 : StringInfoData str;
784 : 5037 : bool save_write_location_fields;
785 : 0 :
786 : 5037 : save_write_location_fields = write_location_fields;
787 : 5037 : write_location_fields = write_loc_fields;
788 : 0 :
789 : : /* see stringinfo.h for an explanation of this maneuver */
790 : 5037 : initStringInfo(&str);
791 : 5037 : outNode(&str, obj);
792 : :
793 : 5037 : write_location_fields = save_write_location_fields;
794 : 0 :
795 : 10074 : return str.data;
796 : 5037 : }
797 : 0 :
798 : : /*
799 : 0 : * Externally visible entry points
800 : 0 : */
801 : : char *
802 : 5037 : nodeToString(const void *obj)
803 : 0 : {
804 : 5037 : return nodeToStringInternal(obj, false);
805 : 0 : }
806 : 0 :
807 : : char *
808 : 0 : nodeToStringWithLocations(const void *obj)
809 : 0 : {
810 : 0 : return nodeToStringInternal(obj, true);
811 : 0 : }
812 : 0 :
813 : :
814 : 0 : /*
815 : 0 : * bmsToString -
816 : : * returns the ascii representation of the Bitmapset as a palloc'd string
817 : 0 : */
818 : 0 : char *
819 : 0 : bmsToString(const Bitmapset *bms)
820 : 0 : {
821 : 0 : StringInfoData str;
822 : :
823 : 0 : /* see stringinfo.h for an explanation of this maneuver */
824 : 0 : initStringInfo(&str);
825 : 0 : outBitmapset(&str, bms);
826 : 0 : return str.data;
827 : 0 : }
828 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
829 : 0 : /* (content generated from coverage data) */
830 : 0 : /* ... */
831 : : /* ... */
832 : 0 : /* ... */
833 : 0 : /* ... */
834 : : /* ... */
835 : 0 : /* ... */
836 : 0 : /* ... */
837 : : /* ... */
838 : 0 : /* ... */
839 : 0 : /* ... */
840 : : /* ... */
841 : 0 : /* ... */
842 : 0 : /* ... */
843 : : /* ... */
844 : 0 : /* ... */
845 : 0 : /* ... */
846 : : /* ... */
847 : 0 : /* ... */
848 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
849 : : /* (content generated from coverage data) */
850 : 0 : /* ... */
851 : 0 : /* ... */
852 : : /* ... */
853 : 0 : /* ... */
854 : 0 : /* ... */
855 : : /* ... */
856 : 0 : /* ... */
857 : 0 : /* ... */
858 : : /* ... */
859 : 0 : /* ... */
860 : 0 : /* ... */
861 : : /* ... */
862 : 0 : /* ... */
863 : 0 : /* ... */
864 : : /* ... */
865 : 0 : /* ... */
866 : 0 : /* ... */
867 : : /* ... */
868 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
869 : 0 : /* (content generated from coverage data) */
870 : : /* ... */
871 : 0 : /* ... */
872 : 0 : /* ... */
873 : : /* ... */
874 : 0 : /* ... */
875 : 0 : /* ... */
876 : : /* ... */
877 : 0 : /* ... */
878 : 0 : /* ... */
879 : : /* ... */
880 : 0 : /* ... */
881 : 0 : /* ... */
882 : : /* ... */
883 : 0 : /* ... */
884 : 0 : /* ... */
885 : : /* ... */
886 : 0 : /* ... */
887 : 0 : /* ... */
888 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
889 : 0 : /* (content generated from coverage data) */
890 : 0 : /* ... */
891 : : /* ... */
892 : 0 : /* ... */
893 : 0 : /* ... */
894 : : /* ... */
895 : 0 : /* ... */
896 : 0 : /* ... */
897 : : /* ... */
898 : 0 : /* ... */
899 : 0 : /* ... */
900 : : /* ... */
901 : 0 : /* ... */
902 : 0 : /* ... */
903 : : /* ... */
904 : 0 : /* ... */
905 : 0 : /* ... */
906 : : /* ... */
907 : 0 : /* ... */
908 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
909 : : /* (content generated from coverage data) */
910 : 0 : /* ... */
911 : 0 : /* ... */
912 : : /* ... */
913 : 0 : /* ... */
914 : 0 : /* ... */
915 : : /* ... */
916 : 0 : /* ... */
917 : 0 : /* ... */
918 : : /* ... */
919 : 0 : /* ... */
920 : 0 : /* ... */
921 : : /* ... */
922 : 0 : /* ... */
923 : 0 : /* ... */
924 : : /* ... */
925 : 0 : /* ... */
926 : 0 : /* ... */
927 : : /* ... */
928 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
929 : 0 : /* (content generated from coverage data) */
930 : : /* ... */
931 : 0 : /* ... */
932 : 0 : /* ... */
933 : : /* ... */
934 : 0 : /* ... */
935 : 0 : /* ... */
936 : : /* ... */
937 : 0 : /* ... */
938 : 0 : /* ... */
939 : : /* ... */
940 : 0 : /* ... */
941 : 0 : /* ... */
942 : : /* ... */
943 : 0 : /* ... */
944 : 0 : /* ... */
945 : : /* ... */
946 : 0 : /* ... */
947 : 0 : /* ... */
948 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
949 : 0 : /* (content generated from coverage data) */
950 : 0 : /* ... */
951 : : /* ... */
952 : 0 : /* ... */
953 : 0 : /* ... */
954 : : /* ... */
955 : 0 : /* ... */
956 : 0 : /* ... */
957 : : /* ... */
958 : 0 : /* ... */
959 : 0 : /* ... */
960 : : /* ... */
961 : 0 : /* ... */
962 : 0 : /* ... */
963 : : /* ... */
964 : 0 : /* ... */
965 : 0 : /* ... */
966 : : /* ... */
967 : 0 : /* ... */
968 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
969 : : /* (content generated from coverage data) */
970 : 0 : /* ... */
971 : 0 : /* ... */
972 : : /* ... */
973 : 0 : /* ... */
974 : 0 : /* ... */
975 : : /* ... */
976 : 0 : /* ... */
977 : 0 : /* ... */
978 : : /* ... */
979 : 0 : /* ... */
980 : 0 : /* ... */
981 : : /* ... */
982 : 0 : /* ... */
983 : 0 : /* ... */
984 : : /* ... */
985 : 0 : /* ... */
986 : 0 : /* ... */
987 : : /* ... */
988 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
989 : 0 : /* (content generated from coverage data) */
990 : : /* ... */
991 : 0 : /* ... */
992 : 0 : /* ... */
993 : : /* ... */
994 : 0 : /* ... */
995 : 0 : /* ... */
996 : : /* ... */
997 : 0 : /* ... */
998 : 0 : /* ... */
999 : : /* ... */
1000 : 0 : /* ... */
1001 : 0 : /* ... */
1002 : : /* ... */
1003 : 0 : /* ... */
1004 : 0 : /* ... */
1005 : : /* ... */
1006 : 0 : /* ... */
1007 : 0 : /* ... */
1008 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1009 : 0 : /* (content generated from coverage data) */
1010 : 0 : /* ... */
1011 : : /* ... */
1012 : 121 : /* ... */
1013 : 121 : /* ... */
1014 : : /* ... */
1015 : 16 : /* ... */
1016 : 16 : /* ... */
1017 : : /* ... */
1018 : 2 : /* ... */
1019 : 2 : /* ... */
1020 : : /* ... */
1021 : 0 : /* ... */
1022 : 0 : /* ... */
1023 : : /* ... */
1024 : 31 : /* ... */
1025 : 31 : /* ... */
1026 : : /* ... */
1027 : 0 : /* ... */
1028 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1029 : : /* (content generated from coverage data) */
1030 : 0 : /* ... */
1031 : 0 : /* ... */
1032 : : /* ... */
1033 : 0 : /* ... */
1034 : 0 : /* ... */
1035 : : /* ... */
1036 : 0 : /* ... */
1037 : 0 : /* ... */
1038 : : /* ... */
1039 : 214 : /* ... */
1040 : 214 : /* ... */
1041 : : /* ... */
1042 : 0 : /* ... */
1043 : 0 : /* ... */
1044 : : /* ... */
1045 : 49 : /* ... */
1046 : 49 : /* ... */
1047 : : /* ... */
1048 : 9 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1049 : 9 : /* (content generated from coverage data) */
1050 : : /* ... */
1051 : 3 : /* ... */
1052 : 3 : /* ... */
1053 : : /* ... */
1054 : 3 : /* ... */
1055 : 3 : /* ... */
1056 : : /* ... */
1057 : 0 : /* ... */
1058 : 0 : /* ... */
1059 : : /* ... */
1060 : 4 : /* ... */
1061 : 4 : /* ... */
1062 : : /* ... */
1063 : 0 : /* ... */
1064 : 0 : /* ... */
1065 : : /* ... */
1066 : 1 : /* ... */
1067 : 1 : /* ... */
1068 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1069 : 0 : /* (content generated from coverage data) */
1070 : 0 : /* ... */
1071 : : /* ... */
1072 : 0 : /* ... */
1073 : 0 : /* ... */
1074 : : /* ... */
1075 : 0 : /* ... */
1076 : 0 : /* ... */
1077 : : /* ... */
1078 : 0 : /* ... */
1079 : 0 : /* ... */
1080 : : /* ... */
1081 : 0 : /* ... */
1082 : 0 : /* ... */
1083 : : /* ... */
1084 : 0 : /* ... */
1085 : 0 : /* ... */
1086 : : /* ... */
1087 : 0 : /* ... */
1088 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1089 : : /* (content generated from coverage data) */
1090 : 6 : /* ... */
1091 : 6 : /* ... */
1092 : : /* ... */
1093 : 6 : /* ... */
1094 : 6 : /* ... */
1095 : : /* ... */
1096 : 1 : /* ... */
1097 : 1 : /* ... */
1098 : : /* ... */
1099 : 33 : /* ... */
1100 : 33 : /* ... */
1101 : : /* ... */
1102 : 0 : /* ... */
1103 : 0 : /* ... */
1104 : : /* ... */
1105 : 1 : /* ... */
1106 : 1 : /* ... */
1107 : : /* ... */
1108 : 26 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1109 : 26 : /* (content generated from coverage data) */
1110 : : /* ... */
1111 : 0 : /* ... */
1112 : 0 : /* ... */
1113 : : /* ... */
1114 : 0 : /* ... */
1115 : 0 : /* ... */
1116 : : /* ... */
1117 : 96 : /* ... */
1118 : 96 : /* ... */
1119 : : /* ... */
1120 : 0 : /* ... */
1121 : 0 : /* ... */
1122 : : /* ... */
1123 : 1 : /* ... */
1124 : 1 : /* ... */
1125 : : /* ... */
1126 : 0 : /* ... */
1127 : 0 : /* ... */
1128 : : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1129 : 0 : /* (content generated from coverage data) */
1130 : 0 : /* ... */
1131 : : /* ... */
1132 : 33 : /* ... */
1133 : 33 : /* ... */
1134 : : /* ... */
1135 : 0 : /* ... */
1136 : 0 : /* ... */
1137 : : /* ... */
1138 : 0 : /* ... */
1139 : 0 : /* ... */
1140 : : /* ... */
1141 : 0 : /* ... */
1142 : 0 : /* ... */
1143 : : /* ... */
1144 : 0 : /* ... */
1145 : 0 : /* ... */
1146 : : /* ... */
1147 : 13 : /* ... */
1148 : 13 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1149 : : /* (content generated from coverage data) */
1150 : 43 : /* ... */
1151 : 43 : /* ... */
1152 : : /* ... */
1153 : 21 : /* ... */
1154 : 21 : /* ... */
1155 : : /* ... */
1156 : 5 : /* ... */
1157 : 5 : /* ... */
1158 : : /* ... */
1159 : 0 : /* ... */
1160 : 0 : /* ... */
1161 : : /* ... */
1162 : 0 : /* ... */
1163 : 0 : /* ... */
1164 : : /* ... */
1165 : 0 : /* ... */
1166 : 0 : /* ... */
1167 : : /* ... */
1168 : 0 : /* /Users/rhaas/pgsql/src/backend/nodes/outfuncs.c not long enough */
1169 : 0 : /* (content generated from coverage data) */
1170 : : /* ... */
1171 : 0 : /* ... */
1172 : 0 : /* END: function "bmsToString" */
|
