PostgreSQL Source Code: src/backend/nodes/readfuncs.c Source File

PostgreSQL Source Code git master
readfuncs.c
Go to the documentation of this file.
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
187static char *
188 nullable_string(const char *token, int length)
189{
190 /* outToken emits <> for NULL, and pg_strtok makes that an empty string */
191 if (length == 0)
192 return NULL;
193 /* outToken emits "" for empty string */
194 if (length == 2 && token[0] == '"' && token[1] == '"')
195 return pstrdup("");
196 /* otherwise, we must remove protective backslashes added by outToken */
197 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 */
208static Bitmapset *
209 _readBitmapset(void)
210{
211 Bitmapset *result = NULL;
212
213 READ_TEMP_LOCALS();
214
215 token = pg_strtok(&length);
216 if (token == NULL)
217 elog(ERROR, "incomplete Bitmapset structure");
218 if (length != 1 || token[0] != '(')
219 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
220
221 token = pg_strtok(&length);
222 if (token == NULL)
223 elog(ERROR, "incomplete Bitmapset structure");
224 if (length != 1 || token[0] != 'b')
225 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
226
227 for (;;)
228 {
229 int val;
230 char *endptr;
231
232 token = pg_strtok(&length);
233 if (token == NULL)
234 elog(ERROR, "unterminated Bitmapset structure");
235 if (length == 1 && token[0] == ')')
236 break;
237 val = (int) strtol(token, &endptr, 10);
238 if (endptr != token + length)
239 elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
240 result = bms_add_member(result, val);
241 }
242
243 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 */
250Bitmapset *
251 readBitmapset(void)
252{
253 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
264static Const *
265 _readConst(void)
266{
267 READ_LOCALS(Const);
268
269 READ_OID_FIELD(consttype);
270 READ_INT_FIELD(consttypmod);
271 READ_OID_FIELD(constcollid);
272 READ_INT_FIELD(constlen);
273 READ_BOOL_FIELD(constbyval);
274 READ_BOOL_FIELD(constisnull);
275 READ_LOCATION_FIELD(location);
276
277 token = pg_strtok(&length); /* skip :constvalue */
278 if (local_node->constisnull)
279 token = pg_strtok(&length); /* skip "<>" */
280 else
281 local_node->constvalue = readDatum(local_node->constbyval);
282
283 READ_DONE();
284}
285
286static BoolExpr *
287 _readBoolExpr(void)
288{
289 READ_LOCALS(BoolExpr);
290
291 /* do-it-yourself enum representation */
292 token = pg_strtok(&length); /* skip :boolop */
293 token = pg_strtok(&length); /* get field value */
294 if (length == 3 && strncmp(token, "and", 3) == 0)
295 local_node->boolop = AND_EXPR;
296 else if (length == 2 && strncmp(token, "or", 2) == 0)
297 local_node->boolop = OR_EXPR;
298 else if (length == 3 && strncmp(token, "not", 3) == 0)
299 local_node->boolop = NOT_EXPR;
300 else
301 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
302
303 READ_NODE_FIELD(args);
304 READ_LOCATION_FIELD(location);
305
306 READ_DONE();
307}
308
309static A_Const *
310 _readA_Const(void)
311{
312 READ_LOCALS(A_Const);
313
314 /* We expect either NULL or :val here */
315 token = pg_strtok(&length);
316 if (length == 4 && strncmp(token, "NULL", 4) == 0)
317 local_node->isnull = true;
318 else
319 {
320 union ValUnion *tmp = nodeRead(NULL, 0);
321
322 /* To forestall valgrind complaints, copy only the valid data */
323 switch (nodeTag(tmp))
324 {
325 case T_Integer:
326 memcpy(&local_node->val, tmp, sizeof(Integer));
327 break;
328 case T_Float:
329 memcpy(&local_node->val, tmp, sizeof(Float));
330 break;
331 case T_Boolean:
332 memcpy(&local_node->val, tmp, sizeof(Boolean));
333 break;
334 case T_String:
335 memcpy(&local_node->val, tmp, sizeof(String));
336 break;
337 case T_BitString:
338 memcpy(&local_node->val, tmp, sizeof(BitString));
339 break;
340 default:
341 elog(ERROR, "unrecognized node type: %d",
342 (int) nodeTag(tmp));
343 break;
344 }
345 }
346
347 READ_LOCATION_FIELD(location);
348
349 READ_DONE();
350}
351
352static RangeTblEntry *
353 _readRangeTblEntry(void)
354{
355 READ_LOCALS(RangeTblEntry);
356
357 READ_NODE_FIELD(alias);
358 READ_NODE_FIELD(eref);
359 READ_ENUM_FIELD(rtekind, RTEKind);
360
361 switch (local_node->rtekind)
362 {
363 case RTE_RELATION:
364 READ_OID_FIELD(relid);
365 READ_BOOL_FIELD(inh);
366 READ_CHAR_FIELD(relkind);
367 READ_INT_FIELD(rellockmode);
368 READ_UINT_FIELD(perminfoindex);
369 READ_NODE_FIELD(tablesample);
370 break;
371 case RTE_SUBQUERY:
372 READ_NODE_FIELD(subquery);
373 READ_BOOL_FIELD(security_barrier);
374 /* we re-use these RELATION fields, too: */
375 READ_OID_FIELD(relid);
376 READ_BOOL_FIELD(inh);
377 READ_CHAR_FIELD(relkind);
378 READ_INT_FIELD(rellockmode);
379 READ_UINT_FIELD(perminfoindex);
380 break;
381 case RTE_JOIN:
382 READ_ENUM_FIELD(jointype, JoinType);
383 READ_INT_FIELD(joinmergedcols);
384 READ_NODE_FIELD(joinaliasvars);
385 READ_NODE_FIELD(joinleftcols);
386 READ_NODE_FIELD(joinrightcols);
387 READ_NODE_FIELD(join_using_alias);
388 break;
389 case RTE_FUNCTION:
390 READ_NODE_FIELD(functions);
391 READ_BOOL_FIELD(funcordinality);
392 break;
393 case RTE_TABLEFUNC:
394 READ_NODE_FIELD(tablefunc);
395 /* The RTE must have a copy of the column type info, if any */
396 if (local_node->tablefunc)
397 {
398 TableFunc *tf = local_node->tablefunc;
399
400 local_node->coltypes = tf->coltypes;
401 local_node->coltypmods = tf->coltypmods;
402 local_node->colcollations = tf->colcollations;
403 }
404 break;
405 case RTE_VALUES:
406 READ_NODE_FIELD(values_lists);
407 READ_NODE_FIELD(coltypes);
408 READ_NODE_FIELD(coltypmods);
409 READ_NODE_FIELD(colcollations);
410 break;
411 case RTE_CTE:
412 READ_STRING_FIELD(ctename);
413 READ_UINT_FIELD(ctelevelsup);
414 READ_BOOL_FIELD(self_reference);
415 READ_NODE_FIELD(coltypes);
416 READ_NODE_FIELD(coltypmods);
417 READ_NODE_FIELD(colcollations);
418 break;
419 case RTE_NAMEDTUPLESTORE:
420 READ_STRING_FIELD(enrname);
421 READ_FLOAT_FIELD(enrtuples);
422 READ_NODE_FIELD(coltypes);
423 READ_NODE_FIELD(coltypmods);
424 READ_NODE_FIELD(colcollations);
425 /* we re-use these RELATION fields, too: */
426 READ_OID_FIELD(relid);
427 break;
428 case RTE_RESULT:
429 /* no extra fields */
430 break;
431 case RTE_GROUP:
432 READ_NODE_FIELD(groupexprs);
433 break;
434 default:
435 elog(ERROR, "unrecognized RTE kind: %d",
436 (int) local_node->rtekind);
437 break;
438 }
439
440 READ_BOOL_FIELD(lateral);
441 READ_BOOL_FIELD(inFromCl);
442 READ_NODE_FIELD(securityQuals);
443
444 READ_DONE();
445}
446
447static A_Expr *
448 _readA_Expr(void)
449{
450 READ_LOCALS(A_Expr);
451
452 token = pg_strtok(&length);
453
454 if (length == 3 && strncmp(token, "ANY", 3) == 0)
455 {
456 local_node->kind = AEXPR_OP_ANY;
457 READ_NODE_FIELD(name);
458 }
459 else if (length == 3 && strncmp(token, "ALL", 3) == 0)
460 {
461 local_node->kind = AEXPR_OP_ALL;
462 READ_NODE_FIELD(name);
463 }
464 else if (length == 8 && strncmp(token, "DISTINCT", 8) == 0)
465 {
466 local_node->kind = AEXPR_DISTINCT;
467 READ_NODE_FIELD(name);
468 }
469 else if (length == 12 && strncmp(token, "NOT_DISTINCT", 12) == 0)
470 {
471 local_node->kind = AEXPR_NOT_DISTINCT;
472 READ_NODE_FIELD(name);
473 }
474 else if (length == 6 && strncmp(token, "NULLIF", 6) == 0)
475 {
476 local_node->kind = AEXPR_NULLIF;
477 READ_NODE_FIELD(name);
478 }
479 else if (length == 2 && strncmp(token, "IN", 2) == 0)
480 {
481 local_node->kind = AEXPR_IN;
482 READ_NODE_FIELD(name);
483 }
484 else if (length == 4 && strncmp(token, "LIKE", 4) == 0)
485 {
486 local_node->kind = AEXPR_LIKE;
487 READ_NODE_FIELD(name);
488 }
489 else if (length == 5 && strncmp(token, "ILIKE", 5) == 0)
490 {
491 local_node->kind = AEXPR_ILIKE;
492 READ_NODE_FIELD(name);
493 }
494 else if (length == 7 && strncmp(token, "SIMILAR", 7) == 0)
495 {
496 local_node->kind = AEXPR_SIMILAR;
497 READ_NODE_FIELD(name);
498 }
499 else if (length == 7 && strncmp(token, "BETWEEN", 7) == 0)
500 {
501 local_node->kind = AEXPR_BETWEEN;
502 READ_NODE_FIELD(name);
503 }
504 else if (length == 11 && strncmp(token, "NOT_BETWEEN", 11) == 0)
505 {
506 local_node->kind = AEXPR_NOT_BETWEEN;
507 READ_NODE_FIELD(name);
508 }
509 else if (length == 11 && strncmp(token, "BETWEEN_SYM", 11) == 0)
510 {
511 local_node->kind = AEXPR_BETWEEN_SYM;
512 READ_NODE_FIELD(name);
513 }
514 else if (length == 15 && strncmp(token, "NOT_BETWEEN_SYM", 15) == 0)
515 {
516 local_node->kind = AEXPR_NOT_BETWEEN_SYM;
517 READ_NODE_FIELD(name);
518 }
519 else if (length == 5 && strncmp(token, ":name", 5) == 0)
520 {
521 local_node->kind = AEXPR_OP;
522 local_node->name = nodeRead(NULL, 0);
523 }
524 else
525 elog(ERROR, "unrecognized A_Expr kind: \"%.*s\"", length, token);
526
527 READ_NODE_FIELD(lexpr);
528 READ_NODE_FIELD(rexpr);
529 READ_LOCATION_FIELD(rexpr_list_start);
530 READ_LOCATION_FIELD(rexpr_list_end);
531 READ_LOCATION_FIELD(location);
532
533 READ_DONE();
534}
535
536static ExtensibleNode *
537 _readExtensibleNode(void)
538{
539 const ExtensibleNodeMethods *methods;
540 ExtensibleNode *local_node;
541 const char *extnodename;
542
543 READ_TEMP_LOCALS();
544
545 token = pg_strtok(&length); /* skip :extnodename */
546 token = pg_strtok(&length); /* get extnodename */
547
548 extnodename = nullable_string(token, length);
549 if (!extnodename)
550 elog(ERROR, "extnodename has to be supplied");
551 methods = GetExtensibleNodeMethods(extnodename, false);
552
553 local_node = (ExtensibleNode *) newNode(methods->node_size,
554 T_ExtensibleNode);
555 local_node->extnodename = extnodename;
556
557 /* deserialize the private fields */
558 methods->nodeRead(local_node);
559
560 READ_DONE();
561}
562
563
564/*
565 * parseNodeString
566 *
567 * Given a character string representing a node tree, parseNodeString creates
568 * the internal node structure.
569 *
570 * The string to be read must already have been loaded into pg_strtok().
571 */
572Node *
573 parseNodeString(void)
574{
575 READ_TEMP_LOCALS();
576
577 /* Guard against stack overflow due to overly complex expressions */
578 check_stack_depth();
579
580 token = pg_strtok(&length);
581
582#define MATCH(tokname, namelen) \
583 (length == namelen && memcmp(token, tokname, namelen) == 0)
584
585#include "readfuncs.switch.c"
586
587 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
588 return NULL; /* keep compiler quiet */
589}
590
591
592/*
593 * readDatum
594 *
595 * Given a string representation of a constant, recreate the appropriate
596 * Datum. The string representation embeds length info, but not byValue,
597 * so we must be told that.
598 */
599Datum
600 readDatum(bool typbyval)
601{
602 Size length,
603 i;
604 int tokenLength;
605 const char *token;
606 Datum res;
607 char *s;
608
609 /*
610 * read the actual length of the value
611 */
612 token = pg_strtok(&tokenLength);
613 length = atoui(token);
614
615 token = pg_strtok(&tokenLength); /* read the '[' */
616 if (token == NULL || token[0] != '[')
617 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
618 token ? token : "[NULL]", length);
619
620 if (typbyval)
621 {
622 if (length > (Size) sizeof(Datum))
623 elog(ERROR, "byval datum but length = %zu", length);
624 res = (Datum) 0;
625 s = (char *) (&res);
626 for (i = 0; i < (Size) sizeof(Datum); i++)
627 {
628 token = pg_strtok(&tokenLength);
629 s[i] = (char) atoi(token);
630 }
631 }
632 else if (length <= 0)
633 res = (Datum) 0;
634 else
635 {
636 s = (char *) palloc(length);
637 for (i = 0; i < length; i++)
638 {
639 token = pg_strtok(&tokenLength);
640 s[i] = (char) atoi(token);
641 }
642 res = PointerGetDatum(s);
643 }
644
645 token = pg_strtok(&tokenLength); /* read the ']' */
646 if (token == NULL || token[0] != ']')
647 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
648 token ? token : "[NULL]", length);
649
650 return res;
651}
652
653/*
654 * common implementation for scalar-array-reading functions
655 *
656 * The data format is either "<>" for a NULL pointer (in which case numCols
657 * is ignored) or "(item item item)" where the number of items must equal
658 * numCols. The convfunc must be okay with stopping at whitespace or a
659 * right parenthesis, since pg_strtok won't null-terminate the token.
660 */
661 #define READ_SCALAR_ARRAY(fnname, datatype, convfunc) \
662datatype * \
663fnname(int numCols) \
664{ \
665 datatype *vals; \
666 READ_TEMP_LOCALS(); \
667 token = pg_strtok(&length); \
668 if (token == NULL) \
669 elog(ERROR, "incomplete scalar array"); \
670 if (length == 0) \
671 return NULL; /* it was "<>", so return NULL pointer */ \
672 if (length != 1 || token[0] != '(') \
673 elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \
674 vals = (datatype *) palloc(numCols * sizeof(datatype)); \
675 for (int i = 0; i < numCols; i++) \
676 { \
677 token = pg_strtok(&length); \
678 if (token == NULL || token[0] == ')') \
679 elog(ERROR, "incomplete scalar array"); \
680 vals[i] = convfunc(token); \
681 } \
682 token = pg_strtok(&length); \
683 if (token == NULL || length != 1 || token[0] != ')') \
684 elog(ERROR, "incomplete scalar array"); \
685 return vals; \
686}
687
688/*
689 * Note: these functions are exported in nodes.h for possible use by
690 * extensions, so don't mess too much with their names or API.
691 */
692READ_SCALAR_ARRAY(readAttrNumberCols, int16, atoi)
693READ_SCALAR_ARRAY(readOidCols, Oid, atooid)
694/* outfuncs.c has writeIndexCols, but we don't yet need that here */
695/* READ_SCALAR_ARRAY(readIndexCols, Index, atoui) */
696READ_SCALAR_ARRAY(readIntCols, int, atoi)
697READ_SCALAR_ARRAY(readBoolCols, bool, strtobool)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
int16_t int16
Definition: c.h:533
size_t Size
Definition: c.h:610
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
const ExtensibleNodeMethods * GetExtensibleNodeMethods(const char *extnodename, bool missing_ok)
Definition: extensible.c:125
#define token
Definition: indent_globs.h:126
long val
Definition: informix.c:689
i
int i
Definition: isn.c:77
char * pstrdup(const char *in)
Definition: mcxt.c:1759
void * palloc(Size size)
Definition: mcxt.c:1365
args
#define nodeTag(nodeptr)
Definition: nodes.h:139
int * readIntCols(int numCols)
static Node * newNode(size_t size, NodeTag tag)
Definition: nodes.h:150
Oid * readOidCols(int numCols)
JoinType
Definition: nodes.h:298
int16 * readAttrNumberCols(int numCols)
bool * readBoolCols(int numCols)
@ AEXPR_BETWEEN
Definition: parsenodes.h:340
@ AEXPR_NULLIF
Definition: parsenodes.h:335
@ AEXPR_NOT_DISTINCT
Definition: parsenodes.h:334
@ AEXPR_BETWEEN_SYM
Definition: parsenodes.h:342
@ AEXPR_NOT_BETWEEN_SYM
Definition: parsenodes.h:343
@ AEXPR_ILIKE
Definition: parsenodes.h:338
@ AEXPR_IN
Definition: parsenodes.h:336
@ AEXPR_NOT_BETWEEN
Definition: parsenodes.h:341
@ AEXPR_DISTINCT
Definition: parsenodes.h:333
@ AEXPR_SIMILAR
Definition: parsenodes.h:339
@ AEXPR_LIKE
Definition: parsenodes.h:337
@ AEXPR_OP
Definition: parsenodes.h:330
@ AEXPR_OP_ANY
Definition: parsenodes.h:331
@ AEXPR_OP_ALL
Definition: parsenodes.h:332
RTEKind
Definition: parsenodes.h:1042
@ RTE_JOIN
Definition: parsenodes.h:1045
@ RTE_CTE
Definition: parsenodes.h:1049
@ RTE_NAMEDTUPLESTORE
Definition: parsenodes.h:1050
@ RTE_VALUES
Definition: parsenodes.h:1048
@ RTE_SUBQUERY
Definition: parsenodes.h:1044
@ RTE_RESULT
Definition: parsenodes.h:1051
@ RTE_FUNCTION
Definition: parsenodes.h:1046
@ RTE_TABLEFUNC
Definition: parsenodes.h:1047
@ RTE_GROUP
Definition: parsenodes.h:1054
@ RTE_RELATION
Definition: parsenodes.h:1043
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
#define atooid(x)
Definition: postgres_ext.h:43
@ AND_EXPR
Definition: primnodes.h:963
@ OR_EXPR
Definition: primnodes.h:963
@ NOT_EXPR
Definition: primnodes.h:963
char * debackslash(const char *token, int length)
Definition: read.c:214
void * nodeRead(const char *token, int tok_len)
Definition: read.c:320
const char * pg_strtok(int *length)
Definition: read.c:153
#define READ_INT_FIELD(fldname)
Definition: readfuncs.c:60
#define READ_UINT_FIELD(fldname)
Definition: readfuncs.c:66
#define READ_NODE_FIELD(fldname)
Definition: readfuncs.c:141
static ExtensibleNode * _readExtensibleNode(void)
Definition: readfuncs.c:537
#define READ_CHAR_FIELD(fldname)
Definition: readfuncs.c:96
static char * nullable_string(const char *token, int length)
Definition: readfuncs.c:188
#define READ_SCALAR_ARRAY(fnname, datatype, convfunc)
Definition: readfuncs.c:661
Node * parseNodeString(void)
Definition: readfuncs.c:573
#define READ_OID_FIELD(fldname)
Definition: readfuncs.c:90
#define READ_LOCATION_FIELD(fldname)
Definition: readfuncs.c:133
static Bitmapset * _readBitmapset(void)
Definition: readfuncs.c:209
static A_Const * _readA_Const(void)
Definition: readfuncs.c:310
static Const * _readConst(void)
Definition: readfuncs.c:265
#define READ_STRING_FIELD(fldname)
Definition: readfuncs.c:121
#define READ_FLOAT_FIELD(fldname)
Definition: readfuncs.c:109
Datum readDatum(bool typbyval)
Definition: readfuncs.c:600
#define READ_BOOL_FIELD(fldname)
Definition: readfuncs.c:115
#define atoui(x)
Definition: readfuncs.c:183
#define strtobool(x)
Definition: readfuncs.c:185
static BoolExpr * _readBoolExpr(void)
Definition: readfuncs.c:287
#define READ_ENUM_FIELD(fldname, enumtype)
Definition: readfuncs.c:103
#define READ_TEMP_LOCALS()
Definition: readfuncs.c:50
static A_Expr * _readA_Expr(void)
Definition: readfuncs.c:448
Bitmapset * readBitmapset(void)
Definition: readfuncs.c:251
#define READ_LOCALS(nodeTypeName)
Definition: readfuncs.c:55
#define READ_DONE()
Definition: readfuncs.c:173
static RangeTblEntry * _readRangeTblEntry(void)
Definition: readfuncs.c:353
static const struct fns functions
Definition: regcomp.c:358
void check_stack_depth(void)
Definition: stack_depth.c:95
Definition: parsenodes.h:383
Definition: parsenodes.h:347
Definition: value.h:72
Definition: value.h:56
Definition: primnodes.h:324
void(* nodeRead)(struct ExtensibleNode *node)
Definition: extensible.h:72
const char * extnodename
Definition: extensible.h:37
Definition: value.h:48
Definition: value.h:29
Definition: nodes.h:135
Definition: value.h:64
Definition: oauth-curl.c:192
const char * name

AltStyle によって変換されたページ (->オリジナル) /