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