PostgreSQL Source Code: src/backend/parser/parse_jsontable.c Source File

PostgreSQL Source Code git master
parse_jsontable.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * parse_jsontable.c
4 * parsing of JSON_TABLE
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/parser/parse_jsontable.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16#include "postgres.h"
17
18#include "catalog/pg_type.h"
19#include "nodes/makefuncs.h"
20#include "nodes/nodeFuncs.h"
21#include "optimizer/optimizer.h"
22#include "parser/parse_clause.h"
23#include "parser/parse_collate.h"
24#include "parser/parse_expr.h"
25#include "parser/parse_relation.h"
26#include "parser/parse_type.h"
27#include "utils/fmgrprotos.h"
28#include "utils/json.h"
29#include "utils/lsyscache.h"
30
31/* Context for transformJsonTableColumns() */
32 typedef struct JsonTableParseContext
33{
34 ParseState *pstate;
35 JsonTable *jt;
36 TableFunc *tf;
37 List *pathNames; /* list of all path and columns names */
38 int pathNameId; /* path name id counter */
39 } JsonTableParseContext;
40
41static JsonTablePlan *transformJsonTableColumns(JsonTableParseContext *cxt,
42 List *columns,
43 List *passingArgs,
44 JsonTablePathSpec *pathspec);
45static JsonTablePlan *transformJsonTableNestedColumns(JsonTableParseContext *cxt,
46 List *passingArgs,
47 List *columns);
48static JsonFuncExpr *transformJsonTableColumn(JsonTableColumn *jtc,
49 Node *contextItemExpr,
50 List *passingArgs);
51static bool isCompositeType(Oid typid);
52static JsonTablePlan *makeJsonTablePathScan(JsonTablePathSpec *pathspec,
53 bool errorOnError,
54 int colMin, int colMax,
55 JsonTablePlan *childplan);
56static void CheckDuplicateColumnOrPathNames(JsonTableParseContext *cxt,
57 List *columns);
58static bool LookupPathOrColumnName(JsonTableParseContext *cxt, char *name);
59static char *generateJsonTablePathName(JsonTableParseContext *cxt);
60static JsonTablePlan *makeJsonTableSiblingJoin(JsonTablePlan *lplan,
61 JsonTablePlan *rplan);
62
63/*
64 * transformJsonTable -
65 * Transform a raw JsonTable into TableFunc
66 *
67 * Mainly, this transforms the JSON_TABLE() document-generating expression
68 * (jt->context_item) and the column-generating expressions (jt->columns) to
69 * populate TableFunc.docexpr and TableFunc.colvalexprs, respectively. Also,
70 * the PASSING values (jt->passing) are transformed and added into
71 * TableFunc.passingvalexprs.
72 */
73ParseNamespaceItem *
74 transformJsonTable(ParseState *pstate, JsonTable *jt)
75{
76 TableFunc *tf;
77 JsonFuncExpr *jfe;
78 JsonExpr *je;
79 JsonTablePathSpec *rootPathSpec = jt->pathspec;
80 bool is_lateral;
81 JsonTableParseContext cxt = {pstate};
82
83 Assert(IsA(rootPathSpec->string, A_Const) &&
84 castNode(A_Const, rootPathSpec->string)->val.node.type == T_String);
85
86 if (jt->on_error &&
87 jt->on_error->btype != JSON_BEHAVIOR_ERROR &&
88 jt->on_error->btype != JSON_BEHAVIOR_EMPTY &&
89 jt->on_error->btype != JSON_BEHAVIOR_EMPTY_ARRAY)
90 ereport(ERROR,
91 errcode(ERRCODE_SYNTAX_ERROR),
92 errmsg("invalid %s behavior", "ON ERROR"),
93 errdetail("Only EMPTY [ ARRAY ] or ERROR is allowed in the top-level ON ERROR clause."),
94 parser_errposition(pstate, jt->on_error->location));
95
96 cxt.pathNameId = 0;
97 if (rootPathSpec->name == NULL)
98 rootPathSpec->name = generateJsonTablePathName(&cxt);
99 cxt.pathNames = list_make1(rootPathSpec->name);
100 CheckDuplicateColumnOrPathNames(&cxt, jt->columns);
101
102 /*
103 * We make lateral_only names of this level visible, whether or not the
104 * RangeTableFunc is explicitly marked LATERAL. This is needed for SQL
105 * spec compliance and seems useful on convenience grounds for all
106 * functions in FROM.
107 *
108 * (LATERAL can't nest within a single pstate level, so we don't need
109 * save/restore logic here.)
110 */
111 Assert(!pstate->p_lateral_active);
112 pstate->p_lateral_active = true;
113
114 tf = makeNode(TableFunc);
115 tf->functype = TFT_JSON_TABLE;
116
117 /*
118 * Transform JsonFuncExpr representing the top JSON_TABLE context_item and
119 * pathspec into a dummy JSON_TABLE_OP JsonExpr.
120 */
121 jfe = makeNode(JsonFuncExpr);
122 jfe->op = JSON_TABLE_OP;
123 jfe->context_item = jt->context_item;
124 jfe->pathspec = (Node *) rootPathSpec->string;
125 jfe->passing = jt->passing;
126 jfe->on_empty = NULL;
127 jfe->on_error = jt->on_error;
128 jfe->location = jt->location;
129 tf->docexpr = transformExpr(pstate, (Node *) jfe, EXPR_KIND_FROM_FUNCTION);
130
131 /*
132 * Create a JsonTablePlan that will generate row pattern that becomes
133 * source data for JSON path expressions in jt->columns. This also adds
134 * the columns' transformed JsonExpr nodes into tf->colvalexprs.
135 */
136 cxt.jt = jt;
137 cxt.tf = tf;
138 tf->plan = (Node *) transformJsonTableColumns(&cxt, jt->columns,
139 jt->passing,
140 rootPathSpec);
141
142 /*
143 * Copy the transformed PASSING arguments into the TableFunc node, because
144 * they are evaluated separately from the JsonExpr that we just put in
145 * TableFunc.docexpr. JsonExpr.passing_values is still kept around for
146 * get_json_table().
147 */
148 je = (JsonExpr *) tf->docexpr;
149 tf->passingvalexprs = copyObject(je->passing_values);
150
151 tf->ordinalitycol = -1; /* undefine ordinality column number */
152 tf->location = jt->location;
153
154 pstate->p_lateral_active = false;
155
156 /*
157 * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
158 * there are any lateral cross-references in it.
159 */
160 is_lateral = jt->lateral || contain_vars_of_level((Node *) tf, 0);
161
162 return addRangeTableEntryForTableFunc(pstate,
163 tf, jt->alias, is_lateral, true);
164}
165
166/*
167 * Check if a column / path name is duplicated in the given shared list of
168 * names.
169 */
170static void
171 CheckDuplicateColumnOrPathNames(JsonTableParseContext *cxt,
172 List *columns)
173{
174 ListCell *lc1;
175
176 foreach(lc1, columns)
177 {
178 JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc1));
179
180 if (jtc->coltype == JTC_NESTED)
181 {
182 if (jtc->pathspec->name)
183 {
184 if (LookupPathOrColumnName(cxt, jtc->pathspec->name))
185 ereport(ERROR,
186 errcode(ERRCODE_DUPLICATE_ALIAS),
187 errmsg("duplicate JSON_TABLE column or path name: %s",
188 jtc->pathspec->name),
189 parser_errposition(cxt->pstate,
190 jtc->pathspec->name_location));
191 cxt->pathNames = lappend(cxt->pathNames, jtc->pathspec->name);
192 }
193
194 CheckDuplicateColumnOrPathNames(cxt, jtc->columns);
195 }
196 else
197 {
198 if (LookupPathOrColumnName(cxt, jtc->name))
199 ereport(ERROR,
200 errcode(ERRCODE_DUPLICATE_ALIAS),
201 errmsg("duplicate JSON_TABLE column or path name: %s",
202 jtc->name),
203 parser_errposition(cxt->pstate, jtc->location));
204 cxt->pathNames = lappend(cxt->pathNames, jtc->name);
205 }
206 }
207}
208
209/*
210 * Lookup a column/path name in the given name list, returning true if already
211 * there.
212 */
213static bool
214 LookupPathOrColumnName(JsonTableParseContext *cxt, char *name)
215{
216 ListCell *lc;
217
218 foreach(lc, cxt->pathNames)
219 {
220 if (strcmp(name, (const char *) lfirst(lc)) == 0)
221 return true;
222 }
223
224 return false;
225}
226
227/* Generate a new unique JSON_TABLE path name. */
228static char *
229 generateJsonTablePathName(JsonTableParseContext *cxt)
230{
231 char namebuf[32];
232 char *name = namebuf;
233
234 snprintf(namebuf, sizeof(namebuf), "json_table_path_%d",
235 cxt->pathNameId++);
236
237 name = pstrdup(name);
238 cxt->pathNames = lappend(cxt->pathNames, name);
239
240 return name;
241}
242
243/*
244 * Create a JsonTablePlan that will supply the source row for 'columns'
245 * using 'pathspec' and append the columns' transformed JsonExpr nodes and
246 * their type/collation information to cxt->tf.
247 */
248static JsonTablePlan *
249 transformJsonTableColumns(JsonTableParseContext *cxt, List *columns,
250 List *passingArgs,
251 JsonTablePathSpec *pathspec)
252{
253 ParseState *pstate = cxt->pstate;
254 JsonTable *jt = cxt->jt;
255 TableFunc *tf = cxt->tf;
256 ListCell *col;
257 bool ordinality_found = false;
258 bool errorOnError = jt->on_error &&
259 jt->on_error->btype == JSON_BEHAVIOR_ERROR;
260 Oid contextItemTypid = exprType(tf->docexpr);
261 int colMin,
262 colMax;
263 JsonTablePlan *childplan;
264
265 /* Start of column range */
266 colMin = list_length(tf->colvalexprs);
267
268 foreach(col, columns)
269 {
270 JsonTableColumn *rawc = castNode(JsonTableColumn, lfirst(col));
271 Oid typid;
272 int32 typmod;
273 Oid typcoll = InvalidOid;
274 Node *colexpr;
275
276 if (rawc->coltype != JTC_NESTED)
277 {
278 Assert(rawc->name);
279 tf->colnames = lappend(tf->colnames,
280 makeString(pstrdup(rawc->name)));
281 }
282
283 /*
284 * Determine the type and typmod for the new column. FOR ORDINALITY
285 * columns are INTEGER by standard; the others are user-specified.
286 */
287 switch (rawc->coltype)
288 {
289 case JTC_FOR_ORDINALITY:
290 if (ordinality_found)
291 ereport(ERROR,
292 (errcode(ERRCODE_SYNTAX_ERROR),
293 errmsg("only one FOR ORDINALITY column is allowed"),
294 parser_errposition(pstate, rawc->location)));
295 ordinality_found = true;
296 colexpr = NULL;
297 typid = INT4OID;
298 typmod = -1;
299 break;
300
301 case JTC_REGULAR:
302 typenameTypeIdAndMod(pstate, rawc->typeName, &typid, &typmod);
303
304 /*
305 * Use JTC_FORMATTED so as to use JSON_QUERY for this column
306 * if the specified type is one that's better handled using
307 * JSON_QUERY() or if non-default WRAPPER or QUOTES behavior
308 * is specified.
309 */
310 if (isCompositeType(typid) ||
311 rawc->quotes != JS_QUOTES_UNSPEC ||
312 rawc->wrapper != JSW_UNSPEC)
313 rawc->coltype = JTC_FORMATTED;
314
315 /* FALLTHROUGH */
316 case JTC_FORMATTED:
317 case JTC_EXISTS:
318 {
319 JsonFuncExpr *jfe;
320 CaseTestExpr *param = makeNode(CaseTestExpr);
321
322 param->collation = InvalidOid;
323 param->typeId = contextItemTypid;
324 param->typeMod = -1;
325
326 jfe = transformJsonTableColumn(rawc, (Node *) param,
327 passingArgs);
328
329 colexpr = transformExpr(pstate, (Node *) jfe,
330 EXPR_KIND_FROM_FUNCTION);
331 assign_expr_collations(pstate, colexpr);
332
333 typid = exprType(colexpr);
334 typmod = exprTypmod(colexpr);
335 typcoll = exprCollation(colexpr);
336 break;
337 }
338
339 case JTC_NESTED:
340 continue;
341
342 default:
343 elog(ERROR, "unknown JSON_TABLE column type: %d", (int) rawc->coltype);
344 break;
345 }
346
347 tf->coltypes = lappend_oid(tf->coltypes, typid);
348 tf->coltypmods = lappend_int(tf->coltypmods, typmod);
349 tf->colcollations = lappend_oid(tf->colcollations, typcoll);
350 tf->colvalexprs = lappend(tf->colvalexprs, colexpr);
351 }
352
353 /* End of column range. */
354 if (list_length(tf->colvalexprs) == colMin)
355 {
356 /* No columns in this Scan beside the nested ones. */
357 colMax = colMin = -1;
358 }
359 else
360 colMax = list_length(tf->colvalexprs) - 1;
361
362 /* Recursively transform nested columns */
363 childplan = transformJsonTableNestedColumns(cxt, passingArgs, columns);
364
365 /* Create a "parent" scan responsible for all columns handled above. */
366 return makeJsonTablePathScan(pathspec, errorOnError, colMin, colMax,
367 childplan);
368}
369
370/*
371 * Check if the type is "composite" for the purpose of checking whether to use
372 * JSON_VALUE() or JSON_QUERY() for a given JsonTableColumn.
373 */
374static bool
375 isCompositeType(Oid typid)
376{
377 char typtype = get_typtype(typid);
378
379 return typid == JSONOID ||
380 typid == JSONBOID ||
381 typid == RECORDOID ||
382 type_is_array(typid) ||
383 typtype == TYPTYPE_COMPOSITE ||
384 /* domain over one of the above? */
385 (typtype == TYPTYPE_DOMAIN &&
386 isCompositeType(getBaseType(typid)));
387}
388
389/*
390 * Transform JSON_TABLE column definition into a JsonFuncExpr
391 * This turns:
392 * - regular column into JSON_VALUE()
393 * - FORMAT JSON column into JSON_QUERY()
394 * - EXISTS column into JSON_EXISTS()
395 */
396static JsonFuncExpr *
397 transformJsonTableColumn(JsonTableColumn *jtc, Node *contextItemExpr,
398 List *passingArgs)
399{
400 Node *pathspec;
401 JsonFuncExpr *jfexpr = makeNode(JsonFuncExpr);
402
403 if (jtc->coltype == JTC_REGULAR)
404 jfexpr->op = JSON_VALUE_OP;
405 else if (jtc->coltype == JTC_EXISTS)
406 jfexpr->op = JSON_EXISTS_OP;
407 else
408 jfexpr->op = JSON_QUERY_OP;
409
410 /* Pass the column name so any runtime JsonExpr errors can print it. */
411 Assert(jtc->name != NULL);
412 jfexpr->column_name = pstrdup(jtc->name);
413
414 jfexpr->context_item = makeJsonValueExpr((Expr *) contextItemExpr, NULL,
415 makeJsonFormat(JS_FORMAT_DEFAULT,
416 JS_ENC_DEFAULT,
417 -1));
418 if (jtc->pathspec)
419 pathspec = (Node *) jtc->pathspec->string;
420 else
421 {
422 /* Construct default path as '$."column_name"' */
423 StringInfoData path;
424
425 initStringInfo(&path);
426
427 appendStringInfoString(&path, "$.");
428 escape_json(&path, jtc->name);
429
430 pathspec = makeStringConst(path.data, -1);
431 }
432 jfexpr->pathspec = pathspec;
433 jfexpr->passing = passingArgs;
434 jfexpr->output = makeNode(JsonOutput);
435 jfexpr->output->typeName = jtc->typeName;
436 jfexpr->output->returning = makeNode(JsonReturning);
437 jfexpr->output->returning->format = jtc->format;
438 jfexpr->on_empty = jtc->on_empty;
439 jfexpr->on_error = jtc->on_error;
440 jfexpr->quotes = jtc->quotes;
441 jfexpr->wrapper = jtc->wrapper;
442 jfexpr->location = jtc->location;
443
444 return jfexpr;
445}
446
447/*
448 * Recursively transform nested columns and create child plan(s) that will be
449 * used to evaluate their row patterns.
450 */
451static JsonTablePlan *
452 transformJsonTableNestedColumns(JsonTableParseContext *cxt,
453 List *passingArgs,
454 List *columns)
455{
456 JsonTablePlan *plan = NULL;
457 ListCell *lc;
458
459 /*
460 * If there are multiple NESTED COLUMNS clauses in 'columns', their
461 * respective plans will be combined using a "sibling join" plan, which
462 * effectively does a UNION of the sets of rows coming from each nested
463 * plan.
464 */
465 foreach(lc, columns)
466 {
467 JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc));
468 JsonTablePlan *nested;
469
470 if (jtc->coltype != JTC_NESTED)
471 continue;
472
473 if (jtc->pathspec->name == NULL)
474 jtc->pathspec->name = generateJsonTablePathName(cxt);
475
476 nested = transformJsonTableColumns(cxt, jtc->columns, passingArgs,
477 jtc->pathspec);
478
479 if (plan)
480 plan = makeJsonTableSiblingJoin(plan, nested);
481 else
482 plan = nested;
483 }
484
485 return plan;
486}
487
488/*
489 * Create a JsonTablePlan for given path and ON ERROR behavior.
490 *
491 * colMin and colMin give the range of columns computed by this scan in the
492 * global flat list of column expressions that will be passed to the
493 * JSON_TABLE's TableFunc. Both are -1 when all of columns are nested and
494 * thus computed by 'childplan'.
495 */
496static JsonTablePlan *
497 makeJsonTablePathScan(JsonTablePathSpec *pathspec, bool errorOnError,
498 int colMin, int colMax,
499 JsonTablePlan *childplan)
500{
501 JsonTablePathScan *scan = makeNode(JsonTablePathScan);
502 char *pathstring;
503 Const *value;
504
505 Assert(IsA(pathspec->string, A_Const));
506 pathstring = castNode(A_Const, pathspec->string)->val.sval.sval;
507 value = makeConst(JSONPATHOID, -1, InvalidOid, -1,
508 DirectFunctionCall1(jsonpath_in,
509 CStringGetDatum(pathstring)),
510 false, false);
511
512 scan->plan.type = T_JsonTablePathScan;
513 scan->path = makeJsonTablePath(value, pathspec->name);
514 scan->errorOnError = errorOnError;
515
516 scan->child = childplan;
517
518 scan->colMin = colMin;
519 scan->colMax = colMax;
520
521 return (JsonTablePlan *) scan;
522}
523
524/*
525 * Create a JsonTablePlan that will perform a join of the rows coming from
526 * 'lplan' and 'rplan'.
527 *
528 * The default way of "joining" the rows is to perform a UNION between the
529 * sets of rows from 'lplan' and 'rplan'.
530 */
531static JsonTablePlan *
532 makeJsonTableSiblingJoin(JsonTablePlan *lplan, JsonTablePlan *rplan)
533{
534 JsonTableSiblingJoin *join = makeNode(JsonTableSiblingJoin);
535
536 join->plan.type = T_JsonTableSiblingJoin;
537 join->lplan = lplan;
538 join->rplan = rplan;
539
540 return (JsonTablePlan *) join;
541}
int32_t int32
Definition: c.h:534
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:150
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:682
Assert(PointerIsAligned(start, uint64))
static struct @169 value
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1603
Datum jsonpath_in(PG_FUNCTION_ARGS)
Definition: jsonpath.c:98
List * lappend(List *list, void *datum)
Definition: list.c:339
List * lappend_int(List *list, int datum)
Definition: list.c:357
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
char get_typtype(Oid typid)
Definition: lsyscache.c:2796
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2688
#define type_is_array(typid)
Definition: lsyscache.h:214
JsonTablePath * makeJsonTablePath(Const *pathvalue, char *pathname)
Definition: makefuncs.c:1026
Node * makeStringConst(char *str, int location)
Definition: makefuncs.c:618
JsonValueExpr * makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr, JsonFormat *format)
Definition: makefuncs.c:938
JsonFormat * makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
Definition: makefuncs.c:922
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:350
char * pstrdup(const char *in)
Definition: mcxt.c:1759
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define copyObject(obj)
Definition: nodes.h:232
#define makeNode(_type_)
Definition: nodes.h:161
#define castNode(_type_, nodeptr)
Definition: nodes.h:182
void assign_expr_collations(ParseState *pstate, Node *expr)
Definition: parse_collate.c:177
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:118
static JsonTablePlan * makeJsonTableSiblingJoin(JsonTablePlan *lplan, JsonTablePlan *rplan)
static char * generateJsonTablePathName(JsonTableParseContext *cxt)
struct JsonTableParseContext JsonTableParseContext
ParseNamespaceItem * transformJsonTable(ParseState *pstate, JsonTable *jt)
static bool LookupPathOrColumnName(JsonTableParseContext *cxt, char *name)
static JsonFuncExpr * transformJsonTableColumn(JsonTableColumn *jtc, Node *contextItemExpr, List *passingArgs)
static JsonTablePlan * makeJsonTablePathScan(JsonTablePathSpec *pathspec, bool errorOnError, int colMin, int colMax, JsonTablePlan *childplan)
static JsonTablePlan * transformJsonTableColumns(JsonTableParseContext *cxt, List *columns, List *passingArgs, JsonTablePathSpec *pathspec)
static bool isCompositeType(Oid typid)
static void CheckDuplicateColumnOrPathNames(JsonTableParseContext *cxt, List *columns)
static JsonTablePlan * transformJsonTableNestedColumns(JsonTableParseContext *cxt, List *passingArgs, List *columns)
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
@ EXPR_KIND_FROM_FUNCTION
Definition: parse_node.h:45
ParseNamespaceItem * addRangeTableEntryForTableFunc(ParseState *pstate, TableFunc *tf, Alias *alias, bool lateral, bool inFromCl)
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition: parse_type.c:310
@ JTC_FORMATTED
Definition: parsenodes.h:1909
@ JTC_FOR_ORDINALITY
Definition: parsenodes.h:1906
@ JTC_NESTED
Definition: parsenodes.h:1910
@ JTC_EXISTS
Definition: parsenodes.h:1908
@ JTC_REGULAR
Definition: parsenodes.h:1907
@ JS_QUOTES_UNSPEC
Definition: parsenodes.h:1841
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define list_make1(x1)
Definition: pg_list.h:212
#define plan(x)
Definition: pg_regress.c:161
#define snprintf
Definition: port.h:239
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:360
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
@ JS_FORMAT_DEFAULT
Definition: primnodes.h:1662
@ TFT_JSON_TABLE
Definition: primnodes.h:101
@ JS_ENC_DEFAULT
Definition: primnodes.h:1650
@ JSW_UNSPEC
Definition: primnodes.h:1774
@ JSON_BEHAVIOR_ERROR
Definition: primnodes.h:1790
@ JSON_BEHAVIOR_EMPTY
Definition: primnodes.h:1791
@ JSON_BEHAVIOR_EMPTY_ARRAY
Definition: primnodes.h:1795
@ JSON_QUERY_OP
Definition: primnodes.h:1827
@ JSON_TABLE_OP
Definition: primnodes.h:1829
@ JSON_EXISTS_OP
Definition: primnodes.h:1826
@ JSON_VALUE_OP
Definition: primnodes.h:1828
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
Definition: parsenodes.h:383
Oid typeId
Definition: primnodes.h:1387
Definition: primnodes.h:324
Definition: primnodes.h:189
ParseLoc location
Definition: primnodes.h:1817
JsonBehaviorType btype
Definition: primnodes.h:1814
List * passing_values
Definition: primnodes.h:1860
char * column_name
Definition: parsenodes.h:1855
JsonExprOp op
Definition: parsenodes.h:1854
List * passing
Definition: parsenodes.h:1859
JsonBehavior * on_empty
Definition: parsenodes.h:1861
ParseLoc location
Definition: parsenodes.h:1865
Node * pathspec
Definition: parsenodes.h:1858
JsonBehavior * on_error
Definition: parsenodes.h:1862
JsonValueExpr * context_item
Definition: parsenodes.h:1857
List * columns
Definition: parsenodes.h:1927
ParseLoc location
Definition: parsenodes.h:1930
JsonTableColumnType coltype
Definition: parsenodes.h:1920
JsonWrapper wrapper
Definition: parsenodes.h:1925
JsonQuotes quotes
Definition: parsenodes.h:1926
TypeName * typeName
Definition: parsenodes.h:1922
JsonTablePathSpec * pathspec
Definition: parsenodes.h:1923
ParseState * pstate
JsonTablePath * path
Definition: primnodes.h:1922
JsonTablePlan * child
Definition: primnodes.h:1931
JsonTablePlan plan
Definition: primnodes.h:1919
ParseLoc name_location
Definition: parsenodes.h:1879
JsonTablePlan * rplan
Definition: primnodes.h:1952
JsonTablePlan * lplan
Definition: primnodes.h:1951
JsonTablePlan plan
Definition: primnodes.h:1949
JsonBehavior * on_error
Definition: parsenodes.h:1894
List * columns
Definition: parsenodes.h:1893
JsonTablePathSpec * pathspec
Definition: parsenodes.h:1891
Alias * alias
Definition: parsenodes.h:1895
bool lateral
Definition: parsenodes.h:1896
List * passing
Definition: parsenodes.h:1892
JsonValueExpr * context_item
Definition: parsenodes.h:1890
ParseLoc location
Definition: parsenodes.h:1897
Definition: pg_list.h:54
Definition: nodes.h:135
bool p_lateral_active
Definition: parse_node.h:205
ParseLoc location
Definition: primnodes.h:146
Node * docexpr
Definition: primnodes.h:120
TableFuncType functype
Definition: primnodes.h:114
Definition: pg_list.h:46
String * makeString(char *str)
Definition: value.c:63
bool contain_vars_of_level(Node *node, int levelsup)
Definition: var.c:444
const char * name

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