Debian Codegraph @

src/backend/utils/adt/jsonbsubs.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * jsonbsubs.c
4 * Subscripting support functions for jsonb.
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/utils/adt/jsonbsubs.c
12 *
13 *-------------------------------------------------------------------------
14 */
15 #include "postgres.h"
16
17 #include "executor/execExpr.h"
18 #include "nodes/nodeFuncs.h"
19 #include "nodes/subscripting.h"
20 #include "parser/parse_coerce.h"
21 #include "parser/parse_expr.h"
22 #include "utils/builtins.h"
23 #include "utils/jsonb.h"
24
25
26 /* SubscriptingRefState.workspace for jsonb subscripting execution */
27 typedef struct JsonbSubWorkspace
28 {
29 bool expectArray; /* jsonb root is expected to be an array */
30 Oid *indexOid; /* OID of coerced subscript expression, could
31 * be only integer or text */
32 Datum *index; /* Subscript values in Datum format */
33 } JsonbSubWorkspace;
34
35
36 /*
37 * Finish parse analysis of a SubscriptingRef expression for a jsonb.
38 *
39 * Transform the subscript expressions, coerce them to text,
40 * and determine the result type of the SubscriptingRef node.
41 */
42 static void
43 jsonb_subscript_transform(SubscriptingRef *sbsref,
44 List *indirection,
45 ParseState *pstate,
46 bool isSlice,
47 bool isAssignment)
48 {
49 List *upperIndexpr = NIL;
50 ListCell *idx;
51
52 /*
53 * Transform and convert the subscript expressions. Jsonb subscripting
54 * does not support slices, look only and the upper index.
55 */
56 foreach(idx, indirection)
57 {
58 A_Indices *ai = lfirst_node(A_Indices, idx);
59 Node *subExpr;
60
61 if (isSlice)
62 {
63 Node *expr = ai->uidx ? ai->uidx : ai->lidx;
64
65 ereport(ERROR,
66 (errcode(ERRCODE_DATATYPE_MISMATCH),
67 errmsg("jsonb subscript does not support slices"),
68 parser_errposition(pstate, exprLocation(expr))));
69 }
70
71 if (ai->uidx)
72 {
73 Oid subExprType = InvalidOid,
74 targetType = UNKNOWNOID;
75
76 subExpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
77 subExprType = exprType(subExpr);
78
79 if (subExprType != UNKNOWNOID)
80 {
81 Oid targets[2] = {INT4OID, TEXTOID};
82
83 /*
84 * Jsonb can handle multiple subscript types, but cases when a
85 * subscript could be coerced to multiple target types must be
86 * avoided, similar to overloaded functions. It could be
87 * possibly extend with jsonpath in the future.
88 */
89 for (int i = 0; i < 2; i++)
90 {
91 if (can_coerce_type(1, &subExprType, &targets[i], COERCION_IMPLICIT))
92 {
93 /*
94 * One type has already succeeded, it means there are
95 * two coercion targets possible, failure.
96 */
97 if (targetType != UNKNOWNOID)
98 ereport(ERROR,
99 (errcode(ERRCODE_DATATYPE_MISMATCH),
100 errmsg("subscript type %s is not supported", format_type_be(subExprType)),
101 errhint("jsonb subscript must be coercible to only one type, integer or text."),
102 parser_errposition(pstate, exprLocation(subExpr))));
103
104 targetType = targets[i];
105 }
106 }
107
108 /*
109 * No suitable types were found, failure.
110 */
111 if (targetType == UNKNOWNOID)
112 ereport(ERROR,
113 (errcode(ERRCODE_DATATYPE_MISMATCH),
114 errmsg("subscript type %s is not supported", format_type_be(subExprType)),
115 errhint("jsonb subscript must be coercible to either integer or text."),
116 parser_errposition(pstate, exprLocation(subExpr))));
117 }
118 else
119 targetType = TEXTOID;
120
121 /*
122 * We known from can_coerce_type that coercion will succeed, so
123 * coerce_type could be used. Note the implicit coercion context,
124 * which is required to handle subscripts of different types,
125 * similar to overloaded functions.
126 */
127 subExpr = coerce_type(pstate,
128 subExpr, subExprType,
129 targetType, -1,
130 COERCION_IMPLICIT,
131 COERCE_IMPLICIT_CAST,
132 -1);
133 if (subExpr == NULL)
134 ereport(ERROR,
135 (errcode(ERRCODE_DATATYPE_MISMATCH),
136 errmsg("jsonb subscript must have text type"),
137 parser_errposition(pstate, exprLocation(subExpr))));
138 }
139 else
140 {
141 /*
142 * Slice with omitted upper bound. Should not happen as we already
143 * errored out on slice earlier, but handle this just in case.
144 */
145 Assert(isSlice && ai->is_slice);
146 ereport(ERROR,
147 (errcode(ERRCODE_DATATYPE_MISMATCH),
148 errmsg("jsonb subscript does not support slices"),
149 parser_errposition(pstate, exprLocation(ai->uidx))));
150 }
151
152 upperIndexpr = lappend(upperIndexpr, subExpr);
153 }
154
155 /* store the transformed lists into the SubscriptRef node */
156 sbsref->refupperindexpr = upperIndexpr;
157 sbsref->reflowerindexpr = NIL;
158
159 /* Determine the result type of the subscripting operation; always jsonb */
160 sbsref->refrestype = JSONBOID;
161 sbsref->reftypmod = -1;
162 }
163
164 /*
165 * During execution, process the subscripts in a SubscriptingRef expression.
166 *
167 * The subscript expressions are already evaluated in Datum form in the
168 * SubscriptingRefState's arrays. Check and convert them as necessary.
169 *
170 * If any subscript is NULL, we throw error in assignment cases, or in fetch
171 * cases set result to NULL and return false (instructing caller to skip the
172 * rest of the SubscriptingRef sequence).
173 */
174 static bool
175 jsonb_subscript_check_subscripts(ExprState *state,
176 ExprEvalStep *op,
177 ExprContext *econtext)
178 {
179 SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
180 JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
181
182 /*
183 * In case if the first subscript is an integer, the source jsonb is
184 * expected to be an array. This information is not used directly, all
185 * such cases are handled within corresponding jsonb assign functions. But
186 * if the source jsonb is NULL the expected type will be used to construct
187 * an empty source.
188 */
189 if (sbsrefstate->numupper > 0 && sbsrefstate->upperprovided[0] &&
190 !sbsrefstate->upperindexnull[0] && workspace->indexOid[0] == INT4OID)
191 workspace->expectArray = true;
192
193 /* Process upper subscripts */
194 for (int i = 0; i < sbsrefstate->numupper; i++)
195 {
196 if (sbsrefstate->upperprovided[i])
197 {
198 /* If any index expr yields NULL, result is NULL or error */
199 if (sbsrefstate->upperindexnull[i])
200 {
201 if (sbsrefstate->isassignment)
202 ereport(ERROR,
203 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
204 errmsg("jsonb subscript in assignment must not be null")));
205 *op->resnull = true;
206 return false;
207 }
208
209 /*
210 * For jsonb fetch and assign functions we need to provide path in
211 * text format. Convert if it's not already text.
212 */
213 if (workspace->indexOid[i] == INT4OID)
214 {
215 Datum datum = sbsrefstate->upperindex[i];
216 char *cs = DatumGetCString(DirectFunctionCall1(int4out, datum));
217
218 workspace->index[i] = CStringGetTextDatum(cs);
219 }
220 else
221 workspace->index[i] = sbsrefstate->upperindex[i];
222 }
223 }
224
225 return true;
226 }
227
228 /*
229 * Evaluate SubscriptingRef fetch for a jsonb element.
230 *
231 * Source container is in step's result variable (it's known not NULL, since
232 * we set fetch_strict to true).
233 */
234 static void
235 jsonb_subscript_fetch(ExprState *state,
236 ExprEvalStep *op,
237 ExprContext *econtext)
238 {
239 SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
240 JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
241 Jsonb *jsonbSource;
242
243 /* Should not get here if source jsonb (or any subscript) is null */
244 Assert(!(*op->resnull));
245
246 jsonbSource = DatumGetJsonbP(*op->resvalue);
247 *op->resvalue = jsonb_get_element(jsonbSource,
248 workspace->index,
249 sbsrefstate->numupper,
250 op->resnull,
251 false);
252 }
253
254 /*
255 * Evaluate SubscriptingRef assignment for a jsonb element assignment.
256 *
257 * Input container (possibly null) is in result area, replacement value is in
258 * SubscriptingRefState's replacevalue/replacenull.
259 */
260 static void
261 jsonb_subscript_assign(ExprState *state,
262 ExprEvalStep *op,
263 ExprContext *econtext)
264 {
265 SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
266 JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
267 Jsonb *jsonbSource;
268 JsonbValue replacevalue;
269
270 if (sbsrefstate->replacenull)
271 replacevalue.type = jbvNull;
272 else
273 JsonbToJsonbValue(DatumGetJsonbP(sbsrefstate->replacevalue),
274 &replacevalue);
275
276 /*
277 * In case if the input container is null, set up an empty jsonb and
278 * proceed with the assignment.
279 */
280 if (*op->resnull)
281 {
282 JsonbValue newSource;
283
284 /*
285 * To avoid any surprising results, set up an empty jsonb array in
286 * case of an array is expected (i.e. the first subscript is integer),
287 * otherwise jsonb object.
288 */
289 if (workspace->expectArray)
290 {
291 newSource.type = jbvArray;
292 newSource.val.array.nElems = 0;
293 newSource.val.array.rawScalar = false;
294 }
295 else
296 {
297 newSource.type = jbvObject;
298 newSource.val.object.nPairs = 0;
299 }
300
301 jsonbSource = JsonbValueToJsonb(&newSource);
302 *op->resnull = false;
303 }
304 else
305 jsonbSource = DatumGetJsonbP(*op->resvalue);
306
307 *op->resvalue = jsonb_set_element(jsonbSource,
308 workspace->index,
309 sbsrefstate->numupper,
310 &replacevalue);
311 /* The result is never NULL, so no need to change *op->resnull */
312 }
313
314 /*
315 * Compute old jsonb element value for a SubscriptingRef assignment
316 * expression. Will only be called if the new-value subexpression
317 * contains SubscriptingRef or FieldStore. This is the same as the
318 * regular fetch case, except that we have to handle a null jsonb,
319 * and the value should be stored into the SubscriptingRefState's
320 * prevvalue/prevnull fields.
321 */
322 static void
323 jsonb_subscript_fetch_old(ExprState *state,
324 ExprEvalStep *op,
325 ExprContext *econtext)
326 {
327 SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
328
329 if (*op->resnull)
330 {
331 /* whole jsonb is null, so any element is too */
332 sbsrefstate->prevvalue = (Datum) 0;
333 sbsrefstate->prevnull = true;
334 }
335 else
336 {
337 Jsonb *jsonbSource = DatumGetJsonbP(*op->resvalue);
338
339 sbsrefstate->prevvalue = jsonb_get_element(jsonbSource,
340 sbsrefstate->upperindex,
341 sbsrefstate->numupper,
342 &sbsrefstate->prevnull,
343 false);
344 }
345 }
346
347 /*
348 * Set up execution state for a jsonb subscript operation. Opposite to the
349 * arrays subscription, there is no limit for number of subscripts as jsonb
350 * type itself doesn't have nesting limits.
351 */
352 static void
353 jsonb_exec_setup(const SubscriptingRef *sbsref,
354 SubscriptingRefState *sbsrefstate,
355 SubscriptExecSteps *methods)
356 {
357 JsonbSubWorkspace *workspace;
358 ListCell *lc;
359 int nupper = sbsref->refupperindexpr->length;
360 char *ptr;
361
362 /* Allocate type-specific workspace with space for per-subscript data */
363 workspace = palloc0(MAXALIGN(sizeof(JsonbSubWorkspace)) +
364 nupper * (sizeof(Datum) + sizeof(Oid)));
365 workspace->expectArray = false;
366 ptr = ((char *) workspace) + MAXALIGN(sizeof(JsonbSubWorkspace));
367
368 /*
369 * This coding assumes sizeof(Datum) >= sizeof(Oid), else we might
370 * misalign the indexOid pointer
371 */
372 workspace->index = (Datum *) ptr;
373 ptr += nupper * sizeof(Datum);
374 workspace->indexOid = (Oid *) ptr;
375
376 sbsrefstate->workspace = workspace;
377
378 /* Collect subscript data types necessary at execution time */
379 foreach(lc, sbsref->refupperindexpr)
380 {
381 Node *expr = lfirst(lc);
382 int i = foreach_current_index(lc);
383
384 workspace->indexOid[i] = exprType(expr);
385 }
386
387 /*
388 * Pass back pointers to appropriate step execution functions.
389 */
390 methods->sbs_check_subscripts = jsonb_subscript_check_subscripts;
391 methods->sbs_fetch = jsonb_subscript_fetch;
392 methods->sbs_assign = jsonb_subscript_assign;
393 methods->sbs_fetch_old = jsonb_subscript_fetch_old;
394 }
395
396 /*
397 * jsonb_subscript_handler
398 * Subscripting handler for jsonb.
399 *
400 */
401 Datum
402 jsonb_subscript_handler(PG_FUNCTION_ARGS)
403 {
404 static const SubscriptRoutines sbsroutines = {
405 .transform = jsonb_subscript_transform,
406 .exec_setup = jsonb_exec_setup,
407 .fetch_strict = true, /* fetch returns NULL for NULL inputs */
408 .fetch_leakproof = true, /* fetch returns NULL for bad subscript */
409 .store_leakproof = false /* ... but assignment throws error */
410 };
411
412 PG_RETURN_POINTER(&sbsroutines);
413 }