Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * json.c
4 : : * JSON data type support.
5 : : *
6 : : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : * IDENTIFICATION
10 : : * src/backend/utils/adt/json.c
11 : : *
12 : : *-------------------------------------------------------------------------
13 : : */
14 : : #include "postgres.h"
15 : :
16 : : #include "access/htup_details.h"
17 : : #include "catalog/pg_proc.h"
18 : : #include "catalog/pg_type.h"
19 : : #include "common/hashfn.h"
20 : : #include "funcapi.h"
21 : : #include "libpq/pqformat.h"
22 : : #include "miscadmin.h"
23 : : #include "port/simd.h"
24 : : #include "utils/array.h"
25 : : #include "utils/builtins.h"
26 : : #include "utils/date.h"
27 : : #include "utils/datetime.h"
28 : : #include "utils/fmgroids.h"
29 : : #include "utils/json.h"
30 : : #include "utils/jsonfuncs.h"
31 : : #include "utils/lsyscache.h"
32 : : #include "utils/typcache.h"
33 : :
34 : :
35 : : /*
36 : : * Support for fast key uniqueness checking.
37 : : *
38 : : * We maintain a hash table of used keys in JSON objects for fast detection
39 : : * of duplicates.
40 : : */
41 : : /* Common context for key uniqueness check */
42 : : typedef struct HTAB *JsonUniqueCheckState; /* hash table for key names */
43 : :
44 : : /* Hash entry for JsonUniqueCheckState */
45 : : typedef struct JsonUniqueHashEntry
46 : : {
47 : : const char *key;
48 : : int key_len;
49 : : int object_id;
50 : : } JsonUniqueHashEntry;
51 : :
52 : : /* Stack element for key uniqueness check during JSON parsing */
53 : : typedef struct JsonUniqueStackEntry
54 : : {
55 : : struct JsonUniqueStackEntry *parent;
56 : : int object_id;
57 : : } JsonUniqueStackEntry;
58 : :
59 : : /* Context struct for key uniqueness check during JSON parsing */
60 : : typedef struct JsonUniqueParsingState
61 : : {
62 : : JsonLexContext *lex;
63 : : JsonUniqueCheckState check;
64 : : JsonUniqueStackEntry *stack;
65 : : int id_counter;
66 : : bool unique;
67 : : } JsonUniqueParsingState;
68 : :
69 : : /* Context struct for key uniqueness check during JSON building */
70 : : typedef struct JsonUniqueBuilderState
71 : : {
72 : : JsonUniqueCheckState check; /* unique check */
73 : : StringInfoData skipped_keys; /* skipped keys with NULL values */
74 : : MemoryContext mcxt; /* context for saving skipped keys */
75 : : } JsonUniqueBuilderState;
76 : :
77 : :
78 : : /* State struct for JSON aggregation */
79 : : typedef struct JsonAggState
80 : : {
81 : : StringInfo str;
82 : : JsonTypeCategory key_category;
83 : : Oid key_output_func;
84 : : JsonTypeCategory val_category;
85 : : Oid val_output_func;
86 : : JsonUniqueBuilderState unique_check;
87 : : } JsonAggState;
88 : :
89 : : static void composite_to_json(Datum composite, StringInfo result,
90 : : bool use_line_feeds);
91 : : static void array_dim_to_json(StringInfo result, int dim, int ndims, int *dims,
92 : : const Datum *vals, const bool *nulls, int *valcount,
93 : : JsonTypeCategory tcategory, Oid outfuncoid,
94 : : bool use_line_feeds);
95 : : static void array_to_json_internal(Datum array, StringInfo result,
96 : : bool use_line_feeds);
97 : : static void datum_to_json_internal(Datum val, bool is_null, StringInfo result,
98 : : JsonTypeCategory tcategory, Oid outfuncoid,
99 : : bool key_scalar);
100 : : static void add_json(Datum val, bool is_null, StringInfo result,
101 : : Oid val_type, bool key_scalar);
102 : : static text *catenate_stringinfo_string(StringInfo buffer, const char *addon);
103 : :
104 : : /*
105 : : * Input.
106 : : */
107 : : Datum
5069 rhaas@postgresql.org 108 :CBC 3158 : json_in(PG_FUNCTION_ARGS)
109 : : {
4646 andrew@dunslane.net 110 : 3158 : char *json = PG_GETARG_CSTRING(0);
111 : 3158 : text *result = cstring_to_text(json);
112 : : JsonLexContext lex;
113 : :
114 : : /* validate it */
804 alvherre@alvh.no-ip. 115 : 3158 : makeJsonLexContext(&lex, result, false);
116 [ + + ]: 3158 : if (!pg_parse_json_or_errsave(&lex, &nullSemAction, fcinfo->context))
1102 tgl@sss.pgh.pa.us 117 : 6 : PG_RETURN_NULL();
118 : :
119 : : /* Internal representation is the same as text */
4646 andrew@dunslane.net 120 : 3056 : PG_RETURN_TEXT_P(result);
121 : : }
122 : :
123 : : /*
124 : : * Output.
125 : : */
126 : : Datum
5069 rhaas@postgresql.org 127 : 2830 : json_out(PG_FUNCTION_ARGS)
128 : : {
129 : : /* we needn't detoast because text_to_cstring will handle that */
4938 bruce@momjian.us 130 : 2830 : Datum txt = PG_GETARG_DATUM(0);
131 : :
5069 rhaas@postgresql.org 132 : 2830 : PG_RETURN_CSTRING(TextDatumGetCString(txt));
133 : : }
134 : :
135 : : /*
136 : : * Binary send.
137 : : */
138 : : Datum
5069 rhaas@postgresql.org 139 :UBC 0 : json_send(PG_FUNCTION_ARGS)
140 : : {
4938 bruce@momjian.us 141 : 0 : text *t = PG_GETARG_TEXT_PP(0);
142 : : StringInfoData buf;
143 : :
5069 rhaas@postgresql.org 144 : 0 : pq_begintypsend(&buf);
145 [ # # # # : 0 : pq_sendtext(&buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
# # # # #
# # # ]
146 : 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
147 : : }
148 : :
149 : : /*
150 : : * Binary receive.
151 : : */
152 : : Datum
153 : 0 : json_recv(PG_FUNCTION_ARGS)
154 : : {
155 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
156 : : char *str;
157 : : int nbytes;
158 : : JsonLexContext lex;
159 : :
160 : 0 : str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
161 : :
162 : : /* Validate it. */
804 alvherre@alvh.no-ip. 163 : 0 : makeJsonLexContextCstringLen(&lex, str, nbytes, GetDatabaseEncoding(),
164 : : false);
165 : 0 : pg_parse_json_or_ereport(&lex, &nullSemAction);
166 : :
4287 andrew@dunslane.net 167 : 0 : PG_RETURN_TEXT_P(cstring_to_text_with_len(str, nbytes));
168 : : }
169 : :
170 : : /*
171 : : * Turn a Datum into JSON text, appending the string to "result".
172 : : *
173 : : * tcategory and outfuncoid are from a previous call to json_categorize_type,
174 : : * except that if is_null is true then they can be invalid.
175 : : *
176 : : * If key_scalar is true, the value is being printed as a key, so insist
177 : : * it's of an acceptable type, and force it to be quoted.
178 : : */
179 : : static void
880 amitlan@postgresql.o 180 :CBC 4230 : datum_to_json_internal(Datum val, bool is_null, StringInfo result,
181 : : JsonTypeCategory tcategory, Oid outfuncoid,
182 : : bool key_scalar)
183 : : {
184 : : char *outputstr;
185 : : text *jsontext;
186 : :
3726 noah@leadboat.com 187 : 4230 : check_stack_depth();
188 : :
189 : : /* callers are expected to ensure that null keys are not passed in */
4033 tgl@sss.pgh.pa.us 190 [ + + - + ]: 4230 : Assert(!(key_scalar && is_null));
191 : :
5046 andrew@dunslane.net 192 [ + + ]: 4230 : if (is_null)
193 : : {
730 nathan@postgresql.or 194 : 159 : appendBinaryStringInfo(result, "null", strlen("null"));
5066 andrew@dunslane.net 195 : 159 : return;
196 : : }
197 : :
4240 tgl@sss.pgh.pa.us 198 [ + + + + ]: 4071 : if (key_scalar &&
199 [ + + ]: 994 : (tcategory == JSONTYPE_ARRAY ||
200 [ + + ]: 991 : tcategory == JSONTYPE_COMPOSITE ||
201 [ - + ]: 985 : tcategory == JSONTYPE_JSON ||
202 : : tcategory == JSONTYPE_CAST))
203 [ + - ]: 18 : ereport(ERROR,
204 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
205 : : errmsg("key value must be scalar, not array, composite, or json")));
206 : :
5066 andrew@dunslane.net 207 [ + + + + : 4053 : switch (tcategory)
+ + + + +
+ ]
208 : : {
4240 tgl@sss.pgh.pa.us 209 : 162 : case JSONTYPE_ARRAY:
5066 andrew@dunslane.net 210 : 162 : array_to_json_internal(val, result, false);
211 : 162 : break;
4240 tgl@sss.pgh.pa.us 212 : 250 : case JSONTYPE_COMPOSITE:
4097 sfrost@snowman.net 213 : 250 : composite_to_json(val, result, false);
5066 andrew@dunslane.net 214 : 250 : break;
4240 tgl@sss.pgh.pa.us 215 : 19 : case JSONTYPE_BOOL:
216 [ - + ]: 19 : if (key_scalar)
730 nathan@postgresql.or 217 :UBC 0 : appendStringInfoChar(result, '"');
730 nathan@postgresql.or 218 [ + + ]:CBC 19 : if (DatumGetBool(val))
219 : 13 : appendBinaryStringInfo(result, "true", strlen("true"));
220 : : else
221 : 6 : appendBinaryStringInfo(result, "false", strlen("false"));
222 [ - + ]: 19 : if (key_scalar)
730 nathan@postgresql.or 223 :UBC 0 : appendStringInfoChar(result, '"');
5066 andrew@dunslane.net 224 :CBC 19 : break;
4240 tgl@sss.pgh.pa.us 225 : 2565 : case JSONTYPE_NUMERIC:
226 : 2565 : outputstr = OidOutputFunctionCall(outfuncoid, val);
227 : :
228 : : /*
229 : : * Don't quote a non-key if it's a valid JSON number (i.e., not
230 : : * "Infinity", "-Infinity", or "NaN"). Since we know this is a
231 : : * numeric data type's output, we simplify and open-code the
232 : : * validation for better performance.
233 : : */
740 nathan@postgresql.or 234 [ + + ]: 2565 : if (!key_scalar &&
235 [ + + + + ]: 1815 : ((*outputstr >= '0' && *outputstr <= '9') ||
236 [ + + ]: 33 : (*outputstr == '-' &&
237 [ + - + + ]: 27 : (outputstr[1] >= '0' && outputstr[1] <= '9'))))
4034 andrew@dunslane.net 238 : 1806 : appendStringInfoString(result, outputstr);
239 : : else
240 : : {
740 nathan@postgresql.or 241 : 759 : appendStringInfoChar(result, '"');
242 : 759 : appendStringInfoString(result, outputstr);
243 : 759 : appendStringInfoChar(result, '"');
244 : : }
5049 andrew@dunslane.net 245 : 2565 : pfree(outputstr);
246 : 2565 : break;
4140 tgl@sss.pgh.pa.us 247 : 12 : case JSONTYPE_DATE:
248 : : {
249 : : char buf[MAXDATELEN + 1];
250 : :
2275 akorotkov@postgresql 251 : 12 : JsonEncodeDateTime(buf, val, DATEOID, NULL);
740 nathan@postgresql.or 252 : 12 : appendStringInfoChar(result, '"');
253 : 12 : appendStringInfoString(result, buf);
254 : 12 : appendStringInfoChar(result, '"');
255 : : }
2892 andrew@dunslane.net 256 : 12 : break;
257 : 13 : case JSONTYPE_TIMESTAMP:
258 : : {
259 : : char buf[MAXDATELEN + 1];
260 : :
2275 akorotkov@postgresql 261 : 13 : JsonEncodeDateTime(buf, val, TIMESTAMPOID, NULL);
740 nathan@postgresql.or 262 : 13 : appendStringInfoChar(result, '"');
263 : 13 : appendStringInfoString(result, buf);
264 : 13 : appendStringInfoChar(result, '"');
265 : : }
2892 andrew@dunslane.net 266 : 13 : break;
267 : 12 : case JSONTYPE_TIMESTAMPTZ:
268 : : {
269 : : char buf[MAXDATELEN + 1];
270 : :
2275 akorotkov@postgresql 271 : 12 : JsonEncodeDateTime(buf, val, TIMESTAMPTZOID, NULL);
740 nathan@postgresql.or 272 : 12 : appendStringInfoChar(result, '"');
273 : 12 : appendStringInfoString(result, buf);
274 : 12 : appendStringInfoChar(result, '"');
275 : : }
2892 andrew@dunslane.net 276 : 12 : break;
277 : 411 : case JSONTYPE_JSON:
278 : : /* JSON and JSONB output will already be escaped */
279 : 411 : outputstr = OidOutputFunctionCall(outfuncoid, val);
280 : 411 : appendStringInfoString(result, outputstr);
281 : 411 : pfree(outputstr);
282 : 411 : break;
283 : 2 : case JSONTYPE_CAST:
284 : : /* outfuncoid refers to a cast function, not an output function */
285 : 2 : jsontext = DatumGetTextPP(OidFunctionCall1(outfuncoid, val));
730 nathan@postgresql.or 286 [ - + ]: 2 : appendBinaryStringInfo(result, VARDATA_ANY(jsontext),
287 [ - + - - : 2 : VARSIZE_ANY_EXHDR(jsontext));
- - - - -
+ ]
2892 andrew@dunslane.net 288 : 2 : pfree(jsontext);
289 : 2 : break;
290 : 607 : default:
291 : : /* special-case text types to save useless palloc/memcpy cycles */
508 drowley@postgresql.o 292 [ + + + - : 607 : if (outfuncoid == F_TEXTOUT || outfuncoid == F_VARCHAROUT ||
- + ]
293 : : outfuncoid == F_BPCHAROUT)
294 : 456 : escape_json_text(result, (text *) DatumGetPointer(val));
295 : : else
296 : : {
297 : 151 : outputstr = OidOutputFunctionCall(outfuncoid, val);
298 : 151 : escape_json(result, outputstr);
299 : 151 : pfree(outputstr);
300 : : }
2892 andrew@dunslane.net 301 : 607 : break;
302 : : }
303 : : }
304 : :
305 : : /*
306 : : * Encode 'value' of datetime type 'typid' into JSON string in ISO format using
307 : : * optionally preallocated buffer 'buf'. Optional 'tzp' determines time-zone
308 : : * offset (in seconds) in which we want to show timestamptz.
309 : : */
310 : : char *
2275 akorotkov@postgresql 311 : 865 : JsonEncodeDateTime(char *buf, Datum value, Oid typid, const int *tzp)
312 : : {
2892 andrew@dunslane.net 313 [ + + ]: 865 : if (!buf)
314 : 30 : buf = palloc(MAXDATELEN + 1);
315 : :
316 [ + + + + : 865 : switch (typid)
+ - ]
317 : : {
318 : 120 : case DATEOID:
319 : : {
320 : : DateADT date;
321 : : struct pg_tm tm;
322 : :
323 : 120 : date = DatumGetDateADT(value);
324 : :
325 : : /* Same as date_out(), but forcing DateStyle */
4140 tgl@sss.pgh.pa.us 326 [ + + + + ]: 120 : if (DATE_NOT_FINITE(date))
3711 327 : 12 : EncodeSpecialDate(date, buf);
328 : : else
329 : : {
4140 330 : 108 : j2date(date + POSTGRES_EPOCH_JDATE,
331 : : &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
332 : 108 : EncodeDateOnly(&tm, USE_XSD_DATES, buf);
333 : : }
334 : : }
335 : 120 : break;
2892 andrew@dunslane.net 336 : 135 : case TIMEOID:
337 : : {
338 : 135 : TimeADT time = DatumGetTimeADT(value);
339 : : struct pg_tm tt,
340 : 135 : *tm = &tt;
341 : : fsec_t fsec;
342 : :
343 : : /* Same as time_out(), but forcing DateStyle */
344 : 135 : time2tm(time, tm, &fsec);
345 : 135 : EncodeTimeOnly(tm, fsec, false, 0, USE_XSD_DATES, buf);
346 : : }
347 : 135 : break;
348 : 171 : case TIMETZOID:
349 : : {
350 : 171 : TimeTzADT *time = DatumGetTimeTzADTP(value);
351 : : struct pg_tm tt,
352 : 171 : *tm = &tt;
353 : : fsec_t fsec;
354 : : int tz;
355 : :
356 : : /* Same as timetz_out(), but forcing DateStyle */
357 : 171 : timetz2tm(time, tm, &fsec, &tz);
358 : 171 : EncodeTimeOnly(tm, fsec, true, tz, USE_XSD_DATES, buf);
359 : : }
360 : 171 : break;
361 : 184 : case TIMESTAMPOID:
362 : : {
363 : : Timestamp timestamp;
364 : : struct pg_tm tm;
365 : : fsec_t fsec;
366 : :
367 : 184 : timestamp = DatumGetTimestamp(value);
368 : : /* Same as timestamp_out(), but forcing DateStyle */
4215 369 [ + + + + ]: 184 : if (TIMESTAMP_NOT_FINITE(timestamp))
3711 tgl@sss.pgh.pa.us 370 : 12 : EncodeSpecialTimestamp(timestamp, buf);
4215 andrew@dunslane.net 371 [ + - ]: 172 : else if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, NULL) == 0)
372 : 172 : EncodeDateTime(&tm, fsec, false, 0, NULL, USE_XSD_DATES, buf);
373 : : else
4215 andrew@dunslane.net 374 [ # # ]:UBC 0 : ereport(ERROR,
375 : : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
376 : : errmsg("timestamp out of range")));
377 : : }
4215 andrew@dunslane.net 378 :CBC 184 : break;
2892 379 : 255 : case TIMESTAMPTZOID:
380 : : {
381 : : TimestampTz timestamp;
382 : : struct pg_tm tm;
383 : : int tz;
384 : : fsec_t fsec;
4215 385 : 255 : const char *tzn = NULL;
386 : :
2892 387 : 255 : timestamp = DatumGetTimestampTz(value);
388 : :
389 : : /*
390 : : * If a time zone is specified, we apply the time-zone shift,
391 : : * convert timestamptz to pg_tm as if it were without a time
392 : : * zone, and then use the specified time zone for converting
393 : : * the timestamp into a string.
394 : : */
2275 akorotkov@postgresql 395 [ + + ]: 255 : if (tzp)
396 : : {
397 : 231 : tz = *tzp;
398 : 231 : timestamp -= (TimestampTz) tz * USECS_PER_SEC;
399 : : }
400 : :
401 : : /* Same as timestamptz_out(), but forcing DateStyle */
4215 andrew@dunslane.net 402 [ + + + + ]: 255 : if (TIMESTAMP_NOT_FINITE(timestamp))
3711 tgl@sss.pgh.pa.us 403 : 12 : EncodeSpecialTimestamp(timestamp, buf);
2275 akorotkov@postgresql 404 [ + + + + : 243 : else if (timestamp2tm(timestamp, tzp ? NULL : &tz, &tm, &fsec,
+ - ]
405 : : tzp ? NULL : &tzn, NULL) == 0)
406 : : {
407 [ + + ]: 243 : if (tzp)
408 : 231 : tm.tm_isdst = 1; /* set time-zone presence flag */
409 : :
4215 andrew@dunslane.net 410 : 243 : EncodeDateTime(&tm, fsec, true, tz, tzn, USE_XSD_DATES, buf);
411 : : }
412 : : else
4215 andrew@dunslane.net 413 [ # # ]:UBC 0 : ereport(ERROR,
414 : : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
415 : : errmsg("timestamp out of range")));
416 : : }
4215 andrew@dunslane.net 417 :CBC 255 : break;
5066 andrew@dunslane.net 418 :UBC 0 : default:
1967 michael@paquier.xyz 419 [ # # ]: 0 : elog(ERROR, "unknown jsonb value datetime type oid %u", typid);
420 : : return NULL;
421 : : }
422 : :
2892 andrew@dunslane.net 423 :CBC 865 : return buf;
424 : : }
425 : :
426 : : /*
427 : : * Process a single dimension of an array.
428 : : * If it's the innermost dimension, output the values, otherwise call
429 : : * ourselves recursively to process the next dimension.
430 : : */
431 : : static void
47 peter@eisentraut.org 432 :GNC 189 : array_dim_to_json(StringInfo result, int dim, int ndims, int *dims, const Datum *vals,
433 : : const bool *nulls, int *valcount, JsonTypeCategory tcategory,
434 : : Oid outfuncoid, bool use_line_feeds)
435 : : {
436 : : int i;
437 : : const char *sep;
438 : :
5066 andrew@dunslane.net 439 [ - + ]:CBC 189 : Assert(dim < ndims);
440 : :
441 [ + + ]: 189 : sep = use_line_feeds ? ",\n " : ",";
442 : :
443 : 189 : appendStringInfoChar(result, '[');
444 : :
445 [ + + ]: 705 : for (i = 1; i <= dims[dim]; i++)
446 : : {
447 [ + + ]: 516 : if (i > 1)
4938 bruce@momjian.us 448 : 327 : appendStringInfoString(result, sep);
449 : :
5066 andrew@dunslane.net 450 [ + + ]: 516 : if (dim + 1 == ndims)
451 : : {
880 amitlan@postgresql.o 452 : 510 : datum_to_json_internal(vals[*valcount], nulls[*valcount],
453 : : result, tcategory,
454 : : outfuncoid, false);
5066 andrew@dunslane.net 455 : 510 : (*valcount)++;
456 : : }
457 : : else
458 : : {
459 : : /*
460 : : * Do we want line feeds on inner dimensions of arrays? For now
461 : : * we'll say no.
462 : : */
4938 bruce@momjian.us 463 : 6 : array_dim_to_json(result, dim + 1, ndims, dims, vals, nulls,
464 : : valcount, tcategory, outfuncoid, false);
465 : : }
466 : : }
467 : :
5066 andrew@dunslane.net 468 : 189 : appendStringInfoChar(result, ']');
469 : 189 : }
470 : :
471 : : /*
472 : : * Turn an array into JSON.
473 : : */
474 : : static void
475 : 183 : array_to_json_internal(Datum array, StringInfo result, bool use_line_feeds)
476 : : {
477 : 183 : ArrayType *v = DatumGetArrayTypeP(array);
478 : 183 : Oid element_type = ARR_ELEMTYPE(v);
479 : : int *dim;
480 : : int ndim;
481 : : int nitems;
4938 bruce@momjian.us 482 : 183 : int count = 0;
483 : : Datum *elements;
484 : : bool *nulls;
485 : : int16 typlen;
486 : : bool typbyval;
487 : : char typalign;
488 : : JsonTypeCategory tcategory;
489 : : Oid outfuncoid;
490 : :
5066 andrew@dunslane.net 491 : 183 : ndim = ARR_NDIM(v);
492 : 183 : dim = ARR_DIMS(v);
493 : 183 : nitems = ArrayGetNItems(ndim, dim);
494 : :
495 [ - + ]: 183 : if (nitems <= 0)
496 : : {
4938 bruce@momjian.us 497 :UBC 0 : appendStringInfoString(result, "[]");
5066 andrew@dunslane.net 498 : 0 : return;
499 : : }
500 : :
4240 tgl@sss.pgh.pa.us 501 :CBC 183 : get_typlenbyvalalign(element_type,
502 : : &typlen, &typbyval, &typalign);
503 : :
881 amitlan@postgresql.o 504 : 183 : json_categorize_type(element_type, false,
505 : : &tcategory, &outfuncoid);
506 : :
5066 andrew@dunslane.net 507 : 183 : deconstruct_array(v, element_type, typlen, typbyval,
508 : : typalign, &elements, &nulls,
509 : : &nitems);
510 : :
5046 511 : 183 : array_dim_to_json(result, 0, ndim, dim, elements, nulls, &count, tcategory,
512 : : outfuncoid, use_line_feeds);
513 : :
5066 514 : 183 : pfree(elements);
515 : 183 : pfree(nulls);
516 : : }
517 : :
518 : : /*
519 : : * Turn a composite / record into JSON.
520 : : */
521 : : static void
4097 sfrost@snowman.net 522 : 628 : composite_to_json(Datum composite, StringInfo result, bool use_line_feeds)
523 : : {
524 : : HeapTupleHeader td;
525 : : Oid tupType;
526 : : int32 tupTypmod;
527 : : TupleDesc tupdesc;
528 : : HeapTupleData tmptup,
529 : : *tuple;
530 : : int i;
4938 bruce@momjian.us 531 : 628 : bool needsep = false;
532 : : const char *sep;
533 : : int seplen;
534 : :
535 : : /*
536 : : * We can avoid expensive strlen() calls by precalculating the separator
537 : : * length.
538 : : */
5066 andrew@dunslane.net 539 [ + + ]: 628 : sep = use_line_feeds ? ",\n " : ",";
740 nathan@postgresql.or 540 [ + + ]: 628 : seplen = use_line_feeds ? strlen(",\n ") : strlen(",");
541 : :
4938 bruce@momjian.us 542 : 628 : td = DatumGetHeapTupleHeader(composite);
543 : :
544 : : /* Extract rowtype info and find a tupdesc */
545 : 628 : tupType = HeapTupleHeaderGetTypeId(td);
546 : 628 : tupTypmod = HeapTupleHeaderGetTypMod(td);
547 : 628 : tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
548 : :
549 : : /* Build a temporary HeapTuple control structure */
550 : 628 : tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
551 : 628 : tmptup.t_data = td;
5066 andrew@dunslane.net 552 : 628 : tuple = &tmptup;
553 : :
4938 bruce@momjian.us 554 : 628 : appendStringInfoChar(result, '{');
555 : :
556 [ + + ]: 1854 : for (i = 0; i < tupdesc->natts; i++)
557 : : {
558 : : Datum val;
559 : : bool isnull;
560 : : char *attname;
561 : : JsonTypeCategory tcategory;
562 : : Oid outfuncoid;
3041 andres@anarazel.de 563 : 1226 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
564 : :
565 [ - + ]: 1226 : if (att->attisdropped)
4938 bruce@momjian.us 566 :UBC 0 : continue;
567 : :
5066 andrew@dunslane.net 568 [ + + ]:CBC 1226 : if (needsep)
740 nathan@postgresql.or 569 : 598 : appendBinaryStringInfo(result, sep, seplen);
5066 andrew@dunslane.net 570 : 1226 : needsep = true;
571 : :
3041 andres@anarazel.de 572 : 1226 : attname = NameStr(att->attname);
4938 bruce@momjian.us 573 : 1226 : escape_json(result, attname);
574 : 1226 : appendStringInfoChar(result, ':');
575 : :
4097 sfrost@snowman.net 576 : 1226 : val = heap_getattr(tuple, i + 1, tupdesc, &isnull);
577 : :
4240 tgl@sss.pgh.pa.us 578 [ + + ]: 1226 : if (isnull)
579 : : {
580 : 90 : tcategory = JSONTYPE_NULL;
581 : 90 : outfuncoid = InvalidOid;
582 : : }
583 : : else
881 amitlan@postgresql.o 584 : 1136 : json_categorize_type(att->atttypid, false, &tcategory,
585 : : &outfuncoid);
586 : :
880 587 : 1226 : datum_to_json_internal(val, isnull, result, tcategory, outfuncoid,
588 : : false);
589 : : }
590 : :
4938 bruce@momjian.us 591 : 628 : appendStringInfoChar(result, '}');
592 [ + - ]: 628 : ReleaseTupleDesc(tupdesc);
5066 andrew@dunslane.net 593 : 628 : }
594 : :
595 : : /*
596 : : * Append JSON text for "val" to "result".
597 : : *
598 : : * This is just a thin wrapper around datum_to_json. If the same type will be
599 : : * printed many times, avoid using this; better to do the json_categorize_type
600 : : * lookups only once.
601 : : */
602 : : static void
4240 tgl@sss.pgh.pa.us 603 : 682 : add_json(Datum val, bool is_null, StringInfo result,
604 : : Oid val_type, bool key_scalar)
605 : : {
606 : : JsonTypeCategory tcategory;
607 : : Oid outfuncoid;
608 : :
4341 andrew@dunslane.net 609 [ - + ]: 682 : if (val_type == InvalidOid)
4341 andrew@dunslane.net 610 [ # # ]:UBC 0 : ereport(ERROR,
611 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
612 : : errmsg("could not determine input data type")));
613 : :
4240 tgl@sss.pgh.pa.us 614 [ + + ]:CBC 682 : if (is_null)
615 : : {
616 : 36 : tcategory = JSONTYPE_NULL;
617 : 36 : outfuncoid = InvalidOid;
618 : : }
619 : : else
881 amitlan@postgresql.o 620 : 646 : json_categorize_type(val_type, false,
621 : : &tcategory, &outfuncoid);
622 : :
880 623 : 682 : datum_to_json_internal(val, is_null, result, tcategory, outfuncoid,
624 : : key_scalar);
4341 andrew@dunslane.net 625 : 664 : }
626 : :
627 : : /*
628 : : * SQL function array_to_json(row)
629 : : */
630 : : Datum
4115 sfrost@snowman.net 631 : 9 : array_to_json(PG_FUNCTION_ARGS)
632 : : {
4097 633 : 9 : Datum array = PG_GETARG_DATUM(0);
634 : : StringInfoData result;
635 : :
41 drowley@postgresql.o 636 :GNC 9 : initStringInfo(&result);
637 : :
638 : 9 : array_to_json_internal(array, &result, false);
639 : :
640 : 9 : PG_RETURN_TEXT_P(cstring_to_text_with_len(result.data, result.len));
641 : : }
642 : :
643 : : /*
644 : : * SQL function array_to_json(row, prettybool)
645 : : */
646 : : Datum
4097 sfrost@snowman.net 647 :CBC 12 : array_to_json_pretty(PG_FUNCTION_ARGS)
648 : : {
4938 bruce@momjian.us 649 : 12 : Datum array = PG_GETARG_DATUM(0);
650 : 12 : bool use_line_feeds = PG_GETARG_BOOL(1);
651 : : StringInfoData result;
652 : :
41 drowley@postgresql.o 653 :GNC 12 : initStringInfo(&result);
654 : :
655 : 12 : array_to_json_internal(array, &result, use_line_feeds);
656 : :
657 : 12 : PG_RETURN_TEXT_P(cstring_to_text_with_len(result.data, result.len));
658 : : }
659 : :
660 : : /*
661 : : * SQL function row_to_json(row)
662 : : */
663 : : Datum
5066 andrew@dunslane.net 664 :CBC 354 : row_to_json(PG_FUNCTION_ARGS)
665 : : {
4097 sfrost@snowman.net 666 : 354 : Datum array = PG_GETARG_DATUM(0);
667 : : StringInfoData result;
668 : :
41 drowley@postgresql.o 669 :GNC 354 : initStringInfo(&result);
670 : :
671 : 354 : composite_to_json(array, &result, false);
672 : :
673 : 354 : PG_RETURN_TEXT_P(cstring_to_text_with_len(result.data, result.len));
674 : : }
675 : :
676 : : /*
677 : : * SQL function row_to_json(row, prettybool)
678 : : */
679 : : Datum
4097 sfrost@snowman.net 680 :CBC 24 : row_to_json_pretty(PG_FUNCTION_ARGS)
681 : : {
4938 bruce@momjian.us 682 : 24 : Datum array = PG_GETARG_DATUM(0);
683 : 24 : bool use_line_feeds = PG_GETARG_BOOL(1);
684 : : StringInfoData result;
685 : :
41 drowley@postgresql.o 686 :GNC 24 : initStringInfo(&result);
687 : :
688 : 24 : composite_to_json(array, &result, use_line_feeds);
689 : :
690 : 24 : PG_RETURN_TEXT_P(cstring_to_text_with_len(result.data, result.len));
691 : : }
692 : :
693 : : /*
694 : : * Is the given type immutable when coming out of a JSON context?
695 : : *
696 : : * At present, datetimes are all considered mutable, because they
697 : : * depend on timezone. XXX we should also drill down into objects
698 : : * and arrays, but do not.
699 : : */
700 : : bool
994 alvherre@alvh.no-ip. 701 :UBC 0 : to_json_is_immutable(Oid typoid)
702 : : {
703 : : JsonTypeCategory tcategory;
704 : : Oid outfuncoid;
705 : :
881 amitlan@postgresql.o 706 : 0 : json_categorize_type(typoid, false, &tcategory, &outfuncoid);
707 : :
994 alvherre@alvh.no-ip. 708 [ # # # # : 0 : switch (tcategory)
# # ]
709 : : {
710 : 0 : case JSONTYPE_BOOL:
711 : : case JSONTYPE_JSON:
712 : : case JSONTYPE_JSONB:
713 : : case JSONTYPE_NULL:
714 : 0 : return true;
715 : :
716 : 0 : case JSONTYPE_DATE:
717 : : case JSONTYPE_TIMESTAMP:
718 : : case JSONTYPE_TIMESTAMPTZ:
719 : 0 : return false;
720 : :
721 : 0 : case JSONTYPE_ARRAY:
722 : 0 : return false; /* TODO recurse into elements */
723 : :
724 : 0 : case JSONTYPE_COMPOSITE:
725 : 0 : return false; /* TODO recurse into fields */
726 : :
727 : 0 : case JSONTYPE_NUMERIC:
728 : : case JSONTYPE_CAST:
729 : : case JSONTYPE_OTHER:
730 : 0 : return func_volatile(outfuncoid) == PROVOLATILE_IMMUTABLE;
731 : : }
732 : :
733 : 0 : return false; /* not reached */
734 : : }
735 : :
736 : : /*
737 : : * SQL function to_json(anyvalue)
738 : : */
739 : : Datum
4665 andrew@dunslane.net 740 :CBC 90 : to_json(PG_FUNCTION_ARGS)
741 : : {
4427 tgl@sss.pgh.pa.us 742 : 90 : Datum val = PG_GETARG_DATUM(0);
4665 andrew@dunslane.net 743 : 90 : Oid val_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
744 : : JsonTypeCategory tcategory;
745 : : Oid outfuncoid;
746 : :
747 [ - + ]: 90 : if (val_type == InvalidOid)
4665 andrew@dunslane.net 748 [ # # ]:UBC 0 : ereport(ERROR,
749 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
750 : : errmsg("could not determine input data type")));
751 : :
881 amitlan@postgresql.o 752 :CBC 90 : json_categorize_type(val_type, false,
753 : : &tcategory, &outfuncoid);
754 : :
880 755 : 90 : PG_RETURN_DATUM(datum_to_json(val, tcategory, outfuncoid));
756 : : }
757 : :
758 : : /*
759 : : * Turn a Datum into JSON text.
760 : : *
761 : : * tcategory and outfuncoid are from a previous call to json_categorize_type.
762 : : */
763 : : Datum
764 : 125 : datum_to_json(Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
765 : : {
766 : : StringInfoData result;
767 : :
41 drowley@postgresql.o 768 :GNC 125 : initStringInfo(&result);
769 : 125 : datum_to_json_internal(val, false, &result, tcategory, outfuncoid,
770 : : false);
771 : :
772 : 125 : return PointerGetDatum(cstring_to_text_with_len(result.data, result.len));
773 : : }
774 : :
775 : : /*
776 : : * json_agg transition function
777 : : *
778 : : * aggregate input column as a json array value.
779 : : */
780 : : static Datum
994 alvherre@alvh.no-ip. 781 :CBC 277 : json_agg_transfn_worker(FunctionCallInfo fcinfo, bool absent_on_null)
782 : : {
783 : : MemoryContext aggcontext,
784 : : oldcontext;
785 : : JsonAggState *state;
786 : : Datum val;
787 : :
4665 andrew@dunslane.net 788 [ - + ]: 277 : if (!AggCheckCallContext(fcinfo, &aggcontext))
789 : : {
790 : : /* cannot be called directly because of internal-type argument */
4665 andrew@dunslane.net 791 [ # # ]:UBC 0 : elog(ERROR, "json_agg_transfn called in non-aggregate context");
792 : : }
793 : :
4665 andrew@dunslane.net 794 [ + + ]:CBC 277 : if (PG_ARGISNULL(0))
795 : : {
3711 tgl@sss.pgh.pa.us 796 : 62 : Oid arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
797 : :
3743 andrew@dunslane.net 798 [ - + ]: 62 : if (arg_type == InvalidOid)
3743 andrew@dunslane.net 799 [ # # ]:UBC 0 : ereport(ERROR,
800 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
801 : : errmsg("could not determine input data type")));
802 : :
803 : : /*
804 : : * Make this state object in a context where it will persist for the
805 : : * duration of the aggregate call. MemoryContextSwitchTo is only
806 : : * needed the first time, as the StringInfo routines make sure they
807 : : * use the right context to enlarge the object if necessary.
808 : : */
4665 andrew@dunslane.net 809 :CBC 62 : oldcontext = MemoryContextSwitchTo(aggcontext);
7 michael@paquier.xyz 810 :GNC 62 : state = palloc_object(JsonAggState);
3743 andrew@dunslane.net 811 :CBC 62 : state->str = makeStringInfo();
4665 812 : 62 : MemoryContextSwitchTo(oldcontext);
813 : :
3743 814 : 62 : appendStringInfoChar(state->str, '[');
881 amitlan@postgresql.o 815 : 62 : json_categorize_type(arg_type, false, &state->val_category,
816 : : &state->val_output_func);
817 : : }
818 : : else
819 : : {
3743 andrew@dunslane.net 820 : 215 : state = (JsonAggState *) PG_GETARG_POINTER(0);
821 : : }
822 : :
994 alvherre@alvh.no-ip. 823 [ + + + + ]: 277 : if (absent_on_null && PG_ARGISNULL(1))
824 : 45 : PG_RETURN_POINTER(state);
825 : :
826 [ + + ]: 232 : if (state->str->len > 1)
827 : 173 : appendStringInfoString(state->str, ", ");
828 : :
829 : : /* fast path for NULLs */
4665 andrew@dunslane.net 830 [ + + ]: 232 : if (PG_ARGISNULL(1))
831 : : {
880 amitlan@postgresql.o 832 : 27 : datum_to_json_internal((Datum) 0, true, state->str, JSONTYPE_NULL,
833 : : InvalidOid, false);
4665 andrew@dunslane.net 834 : 27 : PG_RETURN_POINTER(state);
835 : : }
836 : :
4427 tgl@sss.pgh.pa.us 837 : 205 : val = PG_GETARG_DATUM(1);
838 : :
839 : : /* add some whitespace if structured type and not first item */
994 alvherre@alvh.no-ip. 840 [ + + + + ]: 205 : if (!PG_ARGISNULL(0) && state->str->len > 1 &&
3743 andrew@dunslane.net 841 [ + + ]: 152 : (state->val_category == JSONTYPE_ARRAY ||
842 [ + + ]: 149 : state->val_category == JSONTYPE_COMPOSITE))
843 : : {
844 : 56 : appendStringInfoString(state->str, "\n ");
845 : : }
846 : :
880 amitlan@postgresql.o 847 : 205 : datum_to_json_internal(val, false, state->str, state->val_category,
848 : : state->val_output_func, false);
849 : :
850 : : /*
851 : : * The transition type for json_agg() is declared to be "internal", which
852 : : * is a pass-by-value type the same size as a pointer. So we can safely
853 : : * pass the JsonAggState pointer through nodeAgg.c's machinations.
854 : : */
4665 andrew@dunslane.net 855 : 205 : PG_RETURN_POINTER(state);
856 : : }
857 : :
858 : :
859 : : /*
860 : : * json_agg aggregate function
861 : : */
862 : : Datum
994 alvherre@alvh.no-ip. 863 : 79 : json_agg_transfn(PG_FUNCTION_ARGS)
864 : : {
865 : 79 : return json_agg_transfn_worker(fcinfo, false);
866 : : }
867 : :
868 : : /*
869 : : * json_agg_strict aggregate function
870 : : */
871 : : Datum
872 : 198 : json_agg_strict_transfn(PG_FUNCTION_ARGS)
873 : : {
874 : 198 : return json_agg_transfn_worker(fcinfo, true);
875 : : }
876 : :
877 : : /*
878 : : * json_agg final function
879 : : */
880 : : Datum
4665 andrew@dunslane.net 881 : 68 : json_agg_finalfn(PG_FUNCTION_ARGS)
882 : : {
883 : : JsonAggState *state;
884 : :
885 : : /* cannot be called directly because of internal-type argument */
886 [ - + ]: 68 : Assert(AggCheckCallContext(fcinfo, NULL));
887 : :
3743 888 : 136 : state = PG_ARGISNULL(0) ?
889 [ + + ]: 68 : NULL :
890 : 62 : (JsonAggState *) PG_GETARG_POINTER(0);
891 : :
892 : : /* NULL result for no rows in, as is standard with aggregates */
4665 893 [ + + ]: 68 : if (state == NULL)
894 : 6 : PG_RETURN_NULL();
895 : :
896 : : /* Else return state with appropriate array terminator added */
3743 897 : 62 : PG_RETURN_TEXT_P(catenate_stringinfo_string(state->str, "]"));
898 : : }
899 : :
900 : : /* Functions implementing hash table for key uniqueness check */
901 : : static uint32
994 alvherre@alvh.no-ip. 902 : 831 : json_unique_hash(const void *key, Size keysize)
903 : : {
904 : 831 : const JsonUniqueHashEntry *entry = (JsonUniqueHashEntry *) key;
905 : 831 : uint32 hash = hash_bytes_uint32(entry->object_id);
906 : :
907 : 831 : hash ^= hash_bytes((const unsigned char *) entry->key, entry->key_len);
908 : :
131 peter@eisentraut.org 909 :GNC 831 : return hash;
910 : : }
911 : :
912 : : static int
994 alvherre@alvh.no-ip. 913 :CBC 57 : json_unique_hash_match(const void *key1, const void *key2, Size keysize)
914 : : {
915 : 57 : const JsonUniqueHashEntry *entry1 = (const JsonUniqueHashEntry *) key1;
916 : 57 : const JsonUniqueHashEntry *entry2 = (const JsonUniqueHashEntry *) key2;
917 : :
918 [ - + ]: 57 : if (entry1->object_id != entry2->object_id)
994 alvherre@alvh.no-ip. 919 [ # # ]:UBC 0 : return entry1->object_id > entry2->object_id ? 1 : -1;
920 : :
994 alvherre@alvh.no-ip. 921 [ - + ]:CBC 57 : if (entry1->key_len != entry2->key_len)
994 alvherre@alvh.no-ip. 922 [ # # ]:UBC 0 : return entry1->key_len > entry2->key_len ? 1 : -1;
923 : :
994 alvherre@alvh.no-ip. 924 :CBC 57 : return strncmp(entry1->key, entry2->key, entry1->key_len);
925 : : }
926 : :
927 : : /*
928 : : * Uniqueness detection support.
929 : : *
930 : : * In order to detect uniqueness during building or parsing of a JSON
931 : : * object, we maintain a hash table of key names already seen.
932 : : */
933 : : static void
934 : 159 : json_unique_check_init(JsonUniqueCheckState *cxt)
935 : : {
936 : : HASHCTL ctl;
937 : :
938 : 159 : memset(&ctl, 0, sizeof(ctl));
939 : 159 : ctl.keysize = sizeof(JsonUniqueHashEntry);
940 : 159 : ctl.entrysize = sizeof(JsonUniqueHashEntry);
941 : 159 : ctl.hcxt = CurrentMemoryContext;
942 : 159 : ctl.hash = json_unique_hash;
943 : 159 : ctl.match = json_unique_hash_match;
944 : :
945 : 159 : *cxt = hash_create("json object hashtable",
946 : : 32,
947 : : &ctl,
948 : : HASH_ELEM | HASH_CONTEXT | HASH_FUNCTION | HASH_COMPARE);
949 : 159 : }
950 : :
951 : : static void
952 : 43 : json_unique_builder_init(JsonUniqueBuilderState *cxt)
953 : : {
954 : 43 : json_unique_check_init(&cxt->check);
955 : 43 : cxt->mcxt = CurrentMemoryContext;
956 : 43 : cxt->skipped_keys.data = NULL;
957 : 43 : }
958 : :
959 : : static bool
960 : 831 : json_unique_check_key(JsonUniqueCheckState *cxt, const char *key, int object_id)
961 : : {
962 : : JsonUniqueHashEntry entry;
963 : : bool found;
964 : :
965 : 831 : entry.key = key;
966 : 831 : entry.key_len = strlen(key);
967 : 831 : entry.object_id = object_id;
968 : :
969 : 831 : (void) hash_search(*cxt, &entry, HASH_ENTER, &found);
970 : :
971 : 831 : return !found;
972 : : }
973 : :
974 : : /*
975 : : * On-demand initialization of a throwaway StringInfo. This is used to
976 : : * read a key name that we don't need to store in the output object, for
977 : : * duplicate key detection when the value is NULL.
978 : : */
979 : : static StringInfo
980 : 21 : json_unique_builder_get_throwawaybuf(JsonUniqueBuilderState *cxt)
981 : : {
982 : 21 : StringInfo out = &cxt->skipped_keys;
983 : :
984 [ + + ]: 21 : if (!out->data)
985 : : {
986 : 15 : MemoryContext oldcxt = MemoryContextSwitchTo(cxt->mcxt);
987 : :
988 : 15 : initStringInfo(out);
989 : 15 : MemoryContextSwitchTo(oldcxt);
990 : : }
991 : : else
992 : : /* Just reset the string to empty */
993 : 6 : out->len = 0;
994 : :
995 : 21 : return out;
996 : : }
997 : :
998 : : /*
999 : : * json_object_agg transition function.
1000 : : *
1001 : : * aggregate two input columns as a single json object value.
1002 : : */
1003 : : static Datum
1004 : 759 : json_object_agg_transfn_worker(FunctionCallInfo fcinfo,
1005 : : bool absent_on_null, bool unique_keys)
1006 : : {
1007 : : MemoryContext aggcontext,
1008 : : oldcontext;
1009 : : JsonAggState *state;
1010 : : StringInfo out;
1011 : : Datum arg;
1012 : : bool skip;
1013 : : int key_offset;
1014 : :
4341 andrew@dunslane.net 1015 [ - + ]: 759 : if (!AggCheckCallContext(fcinfo, &aggcontext))
1016 : : {
1017 : : /* cannot be called directly because of internal-type argument */
4033 tgl@sss.pgh.pa.us 1018 [ # # ]:UBC 0 : elog(ERROR, "json_object_agg_transfn called in non-aggregate context");
1019 : : }
1020 : :
4341 andrew@dunslane.net 1021 [ + + ]:CBC 759 : if (PG_ARGISNULL(0))
1022 : : {
1023 : : Oid arg_type;
1024 : :
1025 : : /*
1026 : : * Make the StringInfo in a context where it will persist for the
1027 : : * duration of the aggregate call. Switching context is only needed
1028 : : * for this initial step, as the StringInfo and dynahash routines make
1029 : : * sure they use the right context to enlarge the object if necessary.
1030 : : */
1031 : 67 : oldcontext = MemoryContextSwitchTo(aggcontext);
7 michael@paquier.xyz 1032 :GNC 67 : state = palloc_object(JsonAggState);
3743 andrew@dunslane.net 1033 :CBC 67 : state->str = makeStringInfo();
994 alvherre@alvh.no-ip. 1034 [ + + ]: 67 : if (unique_keys)
1035 : 27 : json_unique_builder_init(&state->unique_check);
1036 : : else
1037 : 40 : memset(&state->unique_check, 0, sizeof(state->unique_check));
4341 andrew@dunslane.net 1038 : 67 : MemoryContextSwitchTo(oldcontext);
1039 : :
3743 1040 : 67 : arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
1041 : :
1042 [ - + ]: 67 : if (arg_type == InvalidOid)
3743 andrew@dunslane.net 1043 [ # # ]:UBC 0 : ereport(ERROR,
1044 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1045 : : errmsg("could not determine data type for argument %d", 1)));
1046 : :
881 amitlan@postgresql.o 1047 :CBC 67 : json_categorize_type(arg_type, false, &state->key_category,
1048 : : &state->key_output_func);
1049 : :
3743 andrew@dunslane.net 1050 : 67 : arg_type = get_fn_expr_argtype(fcinfo->flinfo, 2);
1051 : :
1052 [ - + ]: 67 : if (arg_type == InvalidOid)
3743 andrew@dunslane.net 1053 [ # # ]:UBC 0 : ereport(ERROR,
1054 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1055 : : errmsg("could not determine data type for argument %d", 2)));
1056 : :
881 amitlan@postgresql.o 1057 :CBC 67 : json_categorize_type(arg_type, false, &state->val_category,
1058 : : &state->val_output_func);
1059 : :
3743 andrew@dunslane.net 1060 : 67 : appendStringInfoString(state->str, "{ ");
1061 : : }
1062 : : else
1063 : : {
1064 : 692 : state = (JsonAggState *) PG_GETARG_POINTER(0);
1065 : : }
1066 : :
1067 : : /*
1068 : : * Note: since json_object_agg() is declared as taking type "any", the
1069 : : * parser will not do any type conversion on unknown-type literals (that
1070 : : * is, undecorated strings or NULLs). Such values will arrive here as
1071 : : * type UNKNOWN, which fortunately does not matter to us, since
1072 : : * unknownout() works fine.
1073 : : */
1074 : :
4148 tgl@sss.pgh.pa.us 1075 [ + + ]: 759 : if (PG_ARGISNULL(1))
1076 [ + - ]: 6 : ereport(ERROR,
1077 : : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1078 : : errmsg("null value not allowed for object key")));
1079 : :
1080 : : /* Skip null values if absent_on_null */
994 alvherre@alvh.no-ip. 1081 [ + + + + ]: 753 : skip = absent_on_null && PG_ARGISNULL(2);
1082 : :
1083 [ + + ]: 753 : if (skip)
1084 : : {
1085 : : /*
1086 : : * We got a NULL value and we're not storing those; if we're not
1087 : : * testing key uniqueness, we're done. If we are, use the throwaway
1088 : : * buffer to store the key name so that we can check it.
1089 : : */
1090 [ + + ]: 27 : if (!unique_keys)
1091 : 12 : PG_RETURN_POINTER(state);
1092 : :
1093 : 15 : out = json_unique_builder_get_throwawaybuf(&state->unique_check);
1094 : : }
1095 : : else
1096 : : {
1097 : 726 : out = state->str;
1098 : :
1099 : : /*
1100 : : * Append comma delimiter only if we have already output some fields
1101 : : * after the initial string "{ ".
1102 : : */
1103 [ + + ]: 726 : if (out->len > 2)
1104 : 662 : appendStringInfoString(out, ", ");
1105 : : }
1106 : :
4148 tgl@sss.pgh.pa.us 1107 : 741 : arg = PG_GETARG_DATUM(1);
1108 : :
994 alvherre@alvh.no-ip. 1109 : 741 : key_offset = out->len;
1110 : :
880 amitlan@postgresql.o 1111 : 741 : datum_to_json_internal(arg, false, out, state->key_category,
1112 : : state->key_output_func, true);
1113 : :
994 alvherre@alvh.no-ip. 1114 [ + + ]: 741 : if (unique_keys)
1115 : : {
1116 : : /*
1117 : : * Copy the key first, instead of pointing into the buffer. It will be
1118 : : * added to the hash table, but the buffer may get reallocated as
1119 : : * we're appending more data to it. That would invalidate pointers to
1120 : : * keys in the current buffer.
1121 : : */
462 tomas.vondra@postgre 1122 : 654 : const char *key = MemoryContextStrdup(aggcontext,
1123 : 654 : &out->data[key_offset]);
1124 : :
994 alvherre@alvh.no-ip. 1125 [ + + ]: 654 : if (!json_unique_check_key(&state->unique_check.check, key, 0))
1126 [ + - ]: 18 : ereport(ERROR,
1127 : : errcode(ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE),
1128 : : errmsg("duplicate JSON object key value: %s", key));
1129 : :
1130 [ + + ]: 636 : if (skip)
1131 : 9 : PG_RETURN_POINTER(state);
1132 : : }
1133 : :
3743 andrew@dunslane.net 1134 : 714 : appendStringInfoString(state->str, " : ");
1135 : :
4148 tgl@sss.pgh.pa.us 1136 [ + + ]: 714 : if (PG_ARGISNULL(2))
1137 : 6 : arg = (Datum) 0;
1138 : : else
1139 : 708 : arg = PG_GETARG_DATUM(2);
1140 : :
880 amitlan@postgresql.o 1141 : 714 : datum_to_json_internal(arg, PG_ARGISNULL(2), state->str,
1142 : : state->val_category,
1143 : : state->val_output_func, false);
1144 : :
4341 andrew@dunslane.net 1145 : 714 : PG_RETURN_POINTER(state);
1146 : : }
1147 : :
1148 : : /*
1149 : : * json_object_agg aggregate function
1150 : : */
1151 : : Datum
994 alvherre@alvh.no-ip. 1152 : 75 : json_object_agg_transfn(PG_FUNCTION_ARGS)
1153 : : {
1154 : 75 : return json_object_agg_transfn_worker(fcinfo, false, false);
1155 : : }
1156 : :
1157 : : /*
1158 : : * json_object_agg_strict aggregate function
1159 : : */
1160 : : Datum
1161 : 30 : json_object_agg_strict_transfn(PG_FUNCTION_ARGS)
1162 : : {
1163 : 30 : return json_object_agg_transfn_worker(fcinfo, true, false);
1164 : : }
1165 : :
1166 : : /*
1167 : : * json_object_agg_unique aggregate function
1168 : : */
1169 : : Datum
1170 : 627 : json_object_agg_unique_transfn(PG_FUNCTION_ARGS)
1171 : : {
1172 : 627 : return json_object_agg_transfn_worker(fcinfo, false, true);
1173 : : }
1174 : :
1175 : : /*
1176 : : * json_object_agg_unique_strict aggregate function
1177 : : */
1178 : : Datum
1179 : 27 : json_object_agg_unique_strict_transfn(PG_FUNCTION_ARGS)
1180 : : {
1181 : 27 : return json_object_agg_transfn_worker(fcinfo, true, true);
1182 : : }
1183 : :
1184 : : /*
1185 : : * json_object_agg final function.
1186 : : */
1187 : : Datum
4341 andrew@dunslane.net 1188 : 52 : json_object_agg_finalfn(PG_FUNCTION_ARGS)
1189 : : {
1190 : : JsonAggState *state;
1191 : :
1192 : : /* cannot be called directly because of internal-type argument */
1193 [ - + ]: 52 : Assert(AggCheckCallContext(fcinfo, NULL));
1194 : :
3743 1195 [ + + ]: 52 : state = PG_ARGISNULL(0) ? NULL : (JsonAggState *) PG_GETARG_POINTER(0);
1196 : :
1197 : : /* NULL result for no rows in, as is standard with aggregates */
4341 1198 [ + + ]: 52 : if (state == NULL)
4101 1199 : 3 : PG_RETURN_NULL();
1200 : :
1201 : : /* Else return state with appropriate object terminator added */
3743 1202 : 49 : PG_RETURN_TEXT_P(catenate_stringinfo_string(state->str, " }"));
1203 : : }
1204 : :
1205 : : /*
1206 : : * Helper function for aggregates: return given StringInfo's contents plus
1207 : : * specified trailing string, as a text datum. We need this because aggregate
1208 : : * final functions are not allowed to modify the aggregate state.
1209 : : */
1210 : : static text *
4033 tgl@sss.pgh.pa.us 1211 : 111 : catenate_stringinfo_string(StringInfo buffer, const char *addon)
1212 : : {
1213 : : /* custom version of cstring_to_text_with_len */
1214 : 111 : int buflen = buffer->len;
1215 : 111 : int addlen = strlen(addon);
1216 : 111 : text *result = (text *) palloc(buflen + addlen + VARHDRSZ);
1217 : :
1218 : 111 : SET_VARSIZE(result, buflen + addlen + VARHDRSZ);
1219 : 111 : memcpy(VARDATA(result), buffer->data, buflen);
1220 : 111 : memcpy(VARDATA(result) + buflen, addon, addlen);
1221 : :
1222 : 111 : return result;
1223 : : }
1224 : :
1225 : : Datum
799 peter@eisentraut.org 1226 : 217 : json_build_object_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types,
1227 : : bool absent_on_null, bool unique_keys)
1228 : : {
1229 : : int i;
4148 tgl@sss.pgh.pa.us 1230 : 217 : const char *sep = "";
1231 : : StringInfo result;
1232 : : JsonUniqueBuilderState unique_check;
1233 : :
4341 andrew@dunslane.net 1234 [ + + ]: 217 : if (nargs % 2 != 0)
1235 [ + - ]: 9 : ereport(ERROR,
1236 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1237 : : errmsg("argument list must have even number of elements"),
1238 : : /* translator: %s is a SQL function name */
1239 : : errhint("The arguments of %s must consist of alternating keys and values.",
1240 : : "json_build_object()")));
1241 : :
1242 : 208 : result = makeStringInfo();
1243 : :
1244 : 208 : appendStringInfoChar(result, '{');
1245 : :
994 alvherre@alvh.no-ip. 1246 [ + + ]: 208 : if (unique_keys)
1247 : 16 : json_unique_builder_init(&unique_check);
1248 : :
4341 andrew@dunslane.net 1249 [ + + ]: 443 : for (i = 0; i < nargs; i += 2)
1250 : : {
1251 : : StringInfo out;
1252 : : bool skip;
1253 : : int key_offset;
1254 : :
1255 : : /* Skip null values if absent_on_null */
994 alvherre@alvh.no-ip. 1256 [ + + + + ]: 281 : skip = absent_on_null && nulls[i + 1];
1257 : :
1258 [ + + ]: 281 : if (skip)
1259 : : {
1260 : : /* If key uniqueness check is needed we must save skipped keys */
1261 [ + + ]: 13 : if (!unique_keys)
1262 : 7 : continue;
1263 : :
1264 : 6 : out = json_unique_builder_get_throwawaybuf(&unique_check);
1265 : : }
1266 : : else
1267 : : {
1268 : 268 : appendStringInfoString(result, sep);
1269 : 268 : sep = ", ";
1270 : 268 : out = result;
1271 : : }
1272 : :
1273 : : /* process key */
2975 andrew@dunslane.net 1274 [ + + ]: 274 : if (nulls[i])
4341 1275 [ + - ]: 12 : ereport(ERROR,
1276 : : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1277 : : errmsg("null value not allowed for object key")));
1278 : :
1279 : : /* save key offset before appending it */
994 alvherre@alvh.no-ip. 1280 : 262 : key_offset = out->len;
1281 : :
1282 : 262 : add_json(args[i], false, out, types[i], true);
1283 : :
1284 [ + + ]: 244 : if (unique_keys)
1285 : : {
1286 : : /*
1287 : : * check key uniqueness after key appending
1288 : : *
1289 : : * Copy the key first, instead of pointing into the buffer. It
1290 : : * will be added to the hash table, but the buffer may get
1291 : : * reallocated as we're appending more data to it. That would
1292 : : * invalidate pointers to keys in the current buffer.
1293 : : */
462 tomas.vondra@postgre 1294 : 47 : const char *key = pstrdup(&out->data[key_offset]);
1295 : :
994 alvherre@alvh.no-ip. 1296 [ + + ]: 47 : if (!json_unique_check_key(&unique_check.check, key, 0))
1297 [ + - ]: 16 : ereport(ERROR,
1298 : : errcode(ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE),
1299 : : errmsg("duplicate JSON object key value: %s", key));
1300 : :
1301 [ + + ]: 31 : if (skip)
1302 : 3 : continue;
1303 : : }
1304 : :
4341 andrew@dunslane.net 1305 : 225 : appendStringInfoString(result, " : ");
1306 : :
1307 : : /* process value */
2975 1308 : 225 : add_json(args[i + 1], nulls[i + 1], result, types[i + 1], false);
1309 : : }
1310 : :
4341 1311 : 162 : appendStringInfoChar(result, '}');
1312 : :
994 alvherre@alvh.no-ip. 1313 : 162 : return PointerGetDatum(cstring_to_text_with_len(result->data, result->len));
1314 : : }
1315 : :
1316 : : /*
1317 : : * SQL function json_build_object(variadic "any")
1318 : : */
1319 : : Datum
1320 : 78 : json_build_object(PG_FUNCTION_ARGS)
1321 : : {
1322 : : Datum *args;
1323 : : bool *nulls;
1324 : : Oid *types;
1325 : :
1326 : : /* build argument values to build the object */
1327 : 78 : int nargs = extract_variadic_args(fcinfo, 0, true,
1328 : : &args, &types, &nulls);
1329 : :
1330 [ + + ]: 78 : if (nargs < 0)
1331 : 3 : PG_RETURN_NULL();
1332 : :
1333 : 75 : PG_RETURN_DATUM(json_build_object_worker(nargs, args, nulls, types, false, false));
1334 : : }
1335 : :
1336 : : /*
1337 : : * degenerate case of json_build_object where it gets 0 arguments.
1338 : : */
1339 : : Datum
4341 andrew@dunslane.net 1340 : 3 : json_build_object_noargs(PG_FUNCTION_ARGS)
1341 : : {
1342 : 3 : PG_RETURN_TEXT_P(cstring_to_text_with_len("{}", 2));
1343 : : }
1344 : :
1345 : : Datum
799 peter@eisentraut.org 1346 : 115 : json_build_array_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types,
1347 : : bool absent_on_null)
1348 : : {
1349 : : int i;
4148 tgl@sss.pgh.pa.us 1350 : 115 : const char *sep = "";
1351 : : StringInfoData result;
1352 : :
41 drowley@postgresql.o 1353 :GNC 115 : initStringInfo(&result);
1354 : :
1355 : 115 : appendStringInfoChar(&result, '[');
1356 : :
4341 andrew@dunslane.net 1357 [ + + ]:CBC 319 : for (i = 0; i < nargs; i++)
1358 : : {
994 alvherre@alvh.no-ip. 1359 [ + + + + ]: 204 : if (absent_on_null && nulls[i])
1360 : 9 : continue;
1361 : :
41 drowley@postgresql.o 1362 :GNC 195 : appendStringInfoString(&result, sep);
4148 tgl@sss.pgh.pa.us 1363 :CBC 195 : sep = ", ";
41 drowley@postgresql.o 1364 :GNC 195 : add_json(args[i], nulls[i], &result, types[i], false);
1365 : : }
1366 : :
1367 : 115 : appendStringInfoChar(&result, ']');
1368 : :
1369 : 115 : return PointerGetDatum(cstring_to_text_with_len(result.data, result.len));
1370 : : }
1371 : :
1372 : : /*
1373 : : * SQL function json_build_array(variadic "any")
1374 : : */
1375 : : Datum
994 alvherre@alvh.no-ip. 1376 :CBC 27 : json_build_array(PG_FUNCTION_ARGS)
1377 : : {
1378 : : Datum *args;
1379 : : bool *nulls;
1380 : : Oid *types;
1381 : :
1382 : : /* build argument values to build the object */
1383 : 27 : int nargs = extract_variadic_args(fcinfo, 0, true,
1384 : : &args, &types, &nulls);
1385 : :
1386 [ + + ]: 27 : if (nargs < 0)
1387 : 3 : PG_RETURN_NULL();
1388 : :
1389 : 24 : PG_RETURN_DATUM(json_build_array_worker(nargs, args, nulls, types, false));
1390 : : }
1391 : :
1392 : : /*
1393 : : * degenerate case of json_build_array where it gets 0 arguments.
1394 : : */
1395 : : Datum
4341 andrew@dunslane.net 1396 : 3 : json_build_array_noargs(PG_FUNCTION_ARGS)
1397 : : {
1398 : 3 : PG_RETURN_TEXT_P(cstring_to_text_with_len("[]", 2));
1399 : : }
1400 : :
1401 : : /*
1402 : : * SQL function json_object(text[])
1403 : : *
1404 : : * take a one or two dimensional array of text as key/value pairs
1405 : : * for a json object.
1406 : : */
1407 : : Datum
1408 : 24 : json_object(PG_FUNCTION_ARGS)
1409 : : {
1410 : 24 : ArrayType *in_array = PG_GETARG_ARRAYTYPE_P(0);
1411 : 24 : int ndims = ARR_NDIM(in_array);
1412 : : StringInfoData result;
1413 : : Datum *in_datums;
1414 : : bool *in_nulls;
1415 : : int in_count,
1416 : : count,
1417 : : i;
1418 : : text *rval;
1419 : :
1420 [ + + + + ]: 24 : switch (ndims)
1421 : : {
1422 : 3 : case 0:
1423 : 3 : PG_RETURN_DATUM(CStringGetTextDatum("{}"));
1424 : : break;
1425 : :
1426 : 9 : case 1:
1427 [ + + ]: 9 : if ((ARR_DIMS(in_array)[0]) % 2)
1428 [ + - ]: 3 : ereport(ERROR,
1429 : : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1430 : : errmsg("array must have even number of elements")));
1431 : 6 : break;
1432 : :
1433 : 9 : case 2:
1434 [ + + ]: 9 : if ((ARR_DIMS(in_array)[1]) != 2)
1435 [ + - ]: 6 : ereport(ERROR,
1436 : : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1437 : : errmsg("array must have two columns")));
1438 : 3 : break;
1439 : :
1440 : 3 : default:
1441 [ + - ]: 3 : ereport(ERROR,
1442 : : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1443 : : errmsg("wrong number of array subscripts")));
1444 : : }
1445 : :
1265 peter@eisentraut.org 1446 : 9 : deconstruct_array_builtin(in_array, TEXTOID, &in_datums, &in_nulls, &in_count);
1447 : :
4341 andrew@dunslane.net 1448 : 9 : count = in_count / 2;
1449 : :
1450 : 9 : initStringInfo(&result);
1451 : :
1452 : 9 : appendStringInfoChar(&result, '{');
1453 : :
1454 [ + + ]: 933 : for (i = 0; i < count; ++i)
1455 : : {
1456 [ - + ]: 924 : if (in_nulls[i * 2])
4341 andrew@dunslane.net 1457 [ # # ]:UBC 0 : ereport(ERROR,
1458 : : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1459 : : errmsg("null value not allowed for object key")));
1460 : :
4341 andrew@dunslane.net 1461 [ + + ]:CBC 924 : if (i > 0)
1462 : 915 : appendStringInfoString(&result, ", ");
508 drowley@postgresql.o 1463 : 924 : escape_json_text(&result, (text *) DatumGetPointer(in_datums[i * 2]));
4341 andrew@dunslane.net 1464 : 924 : appendStringInfoString(&result, " : ");
1465 [ + + ]: 924 : if (in_nulls[i * 2 + 1])
1466 : 6 : appendStringInfoString(&result, "null");
1467 : : else
1468 : : {
508 drowley@postgresql.o 1469 : 918 : escape_json_text(&result,
1470 : 918 : (text *) DatumGetPointer(in_datums[i * 2 + 1]));
1471 : : }
1472 : : }
1473 : :
4341 andrew@dunslane.net 1474 : 9 : appendStringInfoChar(&result, '}');
1475 : :
1476 : 9 : pfree(in_datums);
1477 : 9 : pfree(in_nulls);
1478 : :
1479 : 9 : rval = cstring_to_text_with_len(result.data, result.len);
1480 : 9 : pfree(result.data);
1481 : :
1482 : 9 : PG_RETURN_TEXT_P(rval);
1483 : : }
1484 : :
1485 : : /*
1486 : : * SQL function json_object(text[], text[])
1487 : : *
1488 : : * take separate key and value arrays of text to construct a json object
1489 : : * pairwise.
1490 : : */
1491 : : Datum
1492 : 21 : json_object_two_arg(PG_FUNCTION_ARGS)
1493 : : {
1494 : 21 : ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(0);
1495 : 21 : ArrayType *val_array = PG_GETARG_ARRAYTYPE_P(1);
1496 : 21 : int nkdims = ARR_NDIM(key_array);
1497 : 21 : int nvdims = ARR_NDIM(val_array);
1498 : : StringInfoData result;
1499 : : Datum *key_datums,
1500 : : *val_datums;
1501 : : bool *key_nulls,
1502 : : *val_nulls;
1503 : : int key_count,
1504 : : val_count,
1505 : : i;
1506 : : text *rval;
1507 : :
1508 [ + + - + ]: 21 : if (nkdims > 1 || nkdims != nvdims)
1509 [ + - ]: 3 : ereport(ERROR,
1510 : : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1511 : : errmsg("wrong number of array subscripts")));
1512 : :
1513 [ + + ]: 18 : if (nkdims == 0)
1514 : 3 : PG_RETURN_DATUM(CStringGetTextDatum("{}"));
1515 : :
1265 peter@eisentraut.org 1516 : 15 : deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
1517 : 15 : deconstruct_array_builtin(val_array, TEXTOID, &val_datums, &val_nulls, &val_count);
1518 : :
4341 andrew@dunslane.net 1519 [ + + ]: 15 : if (key_count != val_count)
1520 [ + - ]: 6 : ereport(ERROR,
1521 : : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1522 : : errmsg("mismatched array dimensions")));
1523 : :
1524 : 9 : initStringInfo(&result);
1525 : :
1526 : 9 : appendStringInfoChar(&result, '{');
1527 : :
1528 [ + + ]: 39 : for (i = 0; i < key_count; ++i)
1529 : : {
1530 [ + + ]: 33 : if (key_nulls[i])
1531 [ + - ]: 3 : ereport(ERROR,
1532 : : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1533 : : errmsg("null value not allowed for object key")));
1534 : :
1535 [ + + ]: 30 : if (i > 0)
1536 : 21 : appendStringInfoString(&result, ", ");
508 drowley@postgresql.o 1537 : 30 : escape_json_text(&result, (text *) DatumGetPointer(key_datums[i]));
4341 andrew@dunslane.net 1538 : 30 : appendStringInfoString(&result, " : ");
1539 [ - + ]: 30 : if (val_nulls[i])
4341 andrew@dunslane.net 1540 :UBC 0 : appendStringInfoString(&result, "null");
1541 : : else
508 drowley@postgresql.o 1542 :CBC 30 : escape_json_text(&result,
1543 : 30 : (text *) DatumGetPointer(val_datums[i]));
1544 : : }
1545 : :
4341 andrew@dunslane.net 1546 : 6 : appendStringInfoChar(&result, '}');
1547 : :
1548 : 6 : pfree(key_datums);
1549 : 6 : pfree(key_nulls);
1550 : 6 : pfree(val_datums);
1551 : 6 : pfree(val_nulls);
1552 : :
1553 : 6 : rval = cstring_to_text_with_len(result.data, result.len);
1554 : 6 : pfree(result.data);
1555 : :
1556 : 6 : PG_RETURN_TEXT_P(rval);
1557 : : }
1558 : :
1559 : : /*
1560 : : * escape_json_char
1561 : : * Inline helper function for escape_json* functions
1562 : : */
1563 : : static pg_attribute_always_inline void
508 drowley@postgresql.o 1564 : 2221879 : escape_json_char(StringInfo buf, char c)
1565 : : {
1566 [ + + + + : 2221879 : switch (c)
+ + + + ]
1567 : : {
1568 : 9 : case '\b':
1569 : 9 : appendStringInfoString(buf, "\\b");
1570 : 9 : break;
1571 : 3 : case '\f':
1572 : 3 : appendStringInfoString(buf, "\\f");
1573 : 3 : break;
1574 : 12 : case '\n':
1575 : 12 : appendStringInfoString(buf, "\\n");
1576 : 12 : break;
1577 : 3 : case '\r':
1578 : 3 : appendStringInfoString(buf, "\\r");
1579 : 3 : break;
1580 : 90 : case '\t':
1581 : 90 : appendStringInfoString(buf, "\\t");
1582 : 90 : break;
1583 : 315 : case '"':
1584 : 315 : appendStringInfoString(buf, "\\\"");
1585 : 315 : break;
1586 : 45 : case '\\':
1587 : 45 : appendStringInfoString(buf, "\\\\");
1588 : 45 : break;
1589 : 2221402 : default:
1590 [ + + ]: 2221402 : if ((unsigned char) c < ' ')
1591 : 3 : appendStringInfo(buf, "\\u%04x", (int) c);
1592 : : else
1593 [ + + ]: 2221399 : appendStringInfoCharMacro(buf, c);
1594 : 2221402 : break;
1595 : : }
1596 : 2221879 : }
1597 : :
1598 : : /*
1599 : : * escape_json
1600 : : * Produce a JSON string literal, properly escaping the NUL-terminated
1601 : : * cstring.
1602 : : */
1603 : : void
5066 andrew@dunslane.net 1604 : 19738 : escape_json(StringInfo buf, const char *str)
1605 : : {
508 drowley@postgresql.o 1606 [ + + ]: 19738 : appendStringInfoCharMacro(buf, '"');
1607 : :
1608 [ + + ]: 274553 : for (; *str != '\0'; str++)
1609 : 254815 : escape_json_char(buf, *str);
1610 : :
3648 peter_e@gmx.net 1611 [ + + ]: 19738 : appendStringInfoCharMacro(buf, '"');
508 drowley@postgresql.o 1612 : 19738 : }
1613 : :
1614 : : /*
1615 : : * Define the number of bytes that escape_json_with_len will look ahead in the
1616 : : * input string before flushing the input string to the destination buffer.
1617 : : * Looking ahead too far could result in cachelines being evicted that will
1618 : : * need to be reloaded in order to perform the appendBinaryStringInfo call.
1619 : : * Smaller values will result in a larger number of calls to
1620 : : * appendBinaryStringInfo and introduce additional function call overhead.
1621 : : * Values larger than the size of L1d cache will likely result in worse
1622 : : * performance.
1623 : : */
1624 : : #define ESCAPE_JSON_FLUSH_AFTER 512
1625 : :
1626 : : /*
1627 : : * escape_json_with_len
1628 : : * Produce a JSON string literal, properly escaping the possibly not
1629 : : * NUL-terminated characters in 'str'. 'len' defines the number of bytes
1630 : : * from 'str' to process.
1631 : : */
1632 : : void
1633 : 198472 : escape_json_with_len(StringInfo buf, const char *str, int len)
1634 : : {
1635 : : int vlen;
1636 : :
499 1637 [ - + ]: 198472 : Assert(len >= 0);
1638 : :
1639 : : /*
1640 : : * Since we know the minimum length we'll need to append, let's just
1641 : : * enlarge the buffer now rather than incrementally making more space when
1642 : : * we run out. Add two extra bytes for the enclosing quotes.
1643 : : */
1644 : 198472 : enlargeStringInfo(buf, len + 2);
1645 : :
1646 : : /*
1647 : : * Figure out how many bytes to process using SIMD. Round 'len' down to
1648 : : * the previous multiple of sizeof(Vector8), assuming that's a power-of-2.
1649 : : */
1650 : 198472 : vlen = len & (int) (~(sizeof(Vector8) - 1));
1651 : :
3648 peter_e@gmx.net 1652 [ - + ]: 198472 : appendStringInfoCharMacro(buf, '"');
1653 : :
499 drowley@postgresql.o 1654 : 198472 : for (int i = 0, copypos = 0;;)
1655 : : {
1656 : : /*
1657 : : * To speed this up, try searching sizeof(Vector8) bytes at once for
1658 : : * special characters that we need to escape. When we find one, we
1659 : : * fall out of the Vector8 loop and copy the portion we've vector
1660 : : * searched and then we process sizeof(Vector8) bytes one byte at a
1661 : : * time. Once done, come back and try doing vector searching again.
1662 : : * We'll also process any remaining bytes at the tail end of the
1663 : : * string byte-by-byte. This optimization assumes that most chunks of
1664 : : * sizeof(Vector8) bytes won't contain any special characters.
1665 : : */
1666 [ + + ]: 213222 : for (; i < vlen; i += sizeof(Vector8))
1667 : : {
1668 : : Vector8 chunk;
1669 : :
1670 : 14750 : vector8_load(&chunk, (const uint8 *) &str[i]);
1671 : :
1672 : : /*
1673 : : * Break on anything less than ' ' or if we find a '"' or '\\'.
1674 : : * Those need special handling. That's done in the per-byte loop.
1675 : : */
1676 [ + + + + ]: 29464 : if (vector8_has_le(chunk, (unsigned char) 0x1F) ||
1677 [ + + ]: 29425 : vector8_has(chunk, (unsigned char) '"') ||
1678 : 14711 : vector8_has(chunk, (unsigned char) '\\'))
1679 : : break;
1680 : :
1681 : : #ifdef ESCAPE_JSON_FLUSH_AFTER
1682 : :
1683 : : /*
1684 : : * Flush what's been checked so far out to the destination buffer
1685 : : * every so often to avoid having to re-read cachelines when
1686 : : * escaping large strings.
1687 : : */
1688 [ + + ]: 14693 : if (i - copypos >= ESCAPE_JSON_FLUSH_AFTER)
1689 : : {
1690 : 15 : appendBinaryStringInfo(buf, &str[copypos], i - copypos);
1691 : 15 : copypos = i;
1692 : : }
1693 : : #endif
1694 : : }
1695 : :
1696 : : /*
1697 : : * Write to the destination up to the point that we've vector searched
1698 : : * so far. Do this only when switching into per-byte mode rather than
1699 : : * once every sizeof(Vector8) bytes.
1700 : : */
1701 [ + + ]: 198529 : if (copypos < i)
1702 : : {
1703 : 13312 : appendBinaryStringInfo(buf, &str[copypos], i - copypos);
1704 : 13312 : copypos = i;
1705 : : }
1706 : :
1707 : : /*
1708 : : * Per-byte loop for Vector8s containing special chars and for
1709 : : * processing the tail of the string.
1710 : : */
1711 [ + + ]: 2165593 : for (int b = 0; b < sizeof(Vector8); b++)
1712 : : {
1713 : : /* check if we've finished */
1714 [ + + ]: 2165536 : if (i == len)
1715 : 198472 : goto done;
1716 : :
1717 [ - + ]: 1967064 : Assert(i < len);
1718 : :
1719 : 1967064 : escape_json_char(buf, str[i++]);
1720 : : }
1721 : :
1722 : 57 : copypos = i;
1723 : : /* We're not done yet. Try the vector search again. */
1724 : : }
1725 : :
1726 : 198472 : done:
508 1727 [ - + ]: 198472 : appendStringInfoCharMacro(buf, '"');
1728 : 198472 : }
1729 : :
1730 : : /*
1731 : : * escape_json_text
1732 : : * Append 'txt' onto 'buf' and escape using escape_json_with_len.
1733 : : *
1734 : : * This is more efficient than calling text_to_cstring and appending the
1735 : : * result as that could require an additional palloc and memcpy.
1736 : : */
1737 : : void
1738 : 2415 : escape_json_text(StringInfo buf, const text *txt)
1739 : : {
1740 : : /* must cast away the const, unfortunately */
1741 : 2415 : text *tunpacked = pg_detoast_datum_packed(unconstify(text *, txt));
1742 [ - + - - : 2415 : int len = VARSIZE_ANY_EXHDR(tunpacked);
- - - - +
+ ]
1743 : : char *str;
1744 : :
1745 [ + + ]: 2415 : str = VARDATA_ANY(tunpacked);
1746 : :
1747 : 2415 : escape_json_with_len(buf, str, len);
1748 : :
1749 : : /* pfree any detoasted values */
1750 [ - + ]: 2415 : if (tunpacked != txt)
508 drowley@postgresql.o 1751 :UBC 0 : pfree(tunpacked);
5066 andrew@dunslane.net 1752 :CBC 2415 : }
1753 : :
1754 : : /* Semantic actions for key uniqueness check */
1755 : : static JsonParseErrorType
992 alvherre@alvh.no-ip. 1756 : 90 : json_unique_object_start(void *_state)
1757 : : {
1758 : 90 : JsonUniqueParsingState *state = _state;
1759 : : JsonUniqueStackEntry *entry;
1760 : :
1761 [ - + ]: 90 : if (!state->unique)
992 alvherre@alvh.no-ip. 1762 :UBC 0 : return JSON_SUCCESS;
1763 : :
1764 : : /* push object entry to stack */
7 michael@paquier.xyz 1765 :GNC 90 : entry = palloc_object(JsonUniqueStackEntry);
992 alvherre@alvh.no-ip. 1766 :CBC 90 : entry->object_id = state->id_counter++;
1767 : 90 : entry->parent = state->stack;
1768 : 90 : state->stack = entry;
1769 : :
1770 : 90 : return JSON_SUCCESS;
1771 : : }
1772 : :
1773 : : static JsonParseErrorType
1774 : 87 : json_unique_object_end(void *_state)
1775 : : {
1776 : 87 : JsonUniqueParsingState *state = _state;
1777 : : JsonUniqueStackEntry *entry;
1778 : :
1779 [ + + ]: 87 : if (!state->unique)
1780 : 33 : return JSON_SUCCESS;
1781 : :
1782 : 54 : entry = state->stack;
1783 : 54 : state->stack = entry->parent; /* pop object from stack */
1784 : 54 : pfree(entry);
1785 : 54 : return JSON_SUCCESS;
1786 : : }
1787 : :
1788 : : static JsonParseErrorType
1789 : 130 : json_unique_object_field_start(void *_state, char *field, bool isnull)
1790 : : {
1791 : 130 : JsonUniqueParsingState *state = _state;
1792 : : JsonUniqueStackEntry *entry;
1793 : :
1794 [ - + ]: 130 : if (!state->unique)
992 alvherre@alvh.no-ip. 1795 :UBC 0 : return JSON_SUCCESS;
1796 : :
1797 : : /* find key collision in the current object */
992 alvherre@alvh.no-ip. 1798 [ + + ]:CBC 130 : if (json_unique_check_key(&state->check, field, state->stack->object_id))
1799 : 107 : return JSON_SUCCESS;
1800 : :
1801 : 23 : state->unique = false;
1802 : :
1803 : : /* pop all objects entries */
1804 [ + + ]: 56 : while ((entry = state->stack))
1805 : : {
1806 : 33 : state->stack = entry->parent;
1807 : 33 : pfree(entry);
1808 : : }
1809 : 23 : return JSON_SUCCESS;
1810 : : }
1811 : :
1812 : : /* Validate JSON text and additionally check key uniqueness */
1813 : : bool
1814 : 661 : json_validate(text *json, bool check_unique_keys, bool throw_error)
1815 : : {
1816 : : JsonLexContext lex;
1817 : 661 : JsonSemAction uniqueSemAction = {0};
1818 : : JsonUniqueParsingState state;
1819 : : JsonParseErrorType result;
1820 : :
804 1821 : 661 : makeJsonLexContext(&lex, json, check_unique_keys);
1822 : :
992 1823 [ + + ]: 661 : if (check_unique_keys)
1824 : : {
804 1825 : 116 : state.lex = &lex;
992 1826 : 116 : state.stack = NULL;
1827 : 116 : state.id_counter = 0;
1828 : 116 : state.unique = true;
1829 : 116 : json_unique_check_init(&state.check);
1830 : :
1831 : 116 : uniqueSemAction.semstate = &state;
1832 : 116 : uniqueSemAction.object_start = json_unique_object_start;
1833 : 116 : uniqueSemAction.object_field_start = json_unique_object_field_start;
1834 : 116 : uniqueSemAction.object_end = json_unique_object_end;
1835 : : }
1836 : :
804 1837 [ + + ]: 661 : result = pg_parse_json(&lex, check_unique_keys ? &uniqueSemAction : &nullSemAction);
1838 : :
992 1839 [ + + ]: 661 : if (result != JSON_SUCCESS)
1840 : : {
1841 [ - + ]: 108 : if (throw_error)
804 alvherre@alvh.no-ip. 1842 :UBC 0 : json_errsave_error(result, &lex, NULL);
1843 : :
992 alvherre@alvh.no-ip. 1844 :CBC 108 : return false; /* invalid json */
1845 : : }
1846 : :
1847 [ + + + + ]: 553 : if (check_unique_keys && !state.unique)
1848 : : {
1849 [ + + ]: 23 : if (throw_error)
1850 [ + - ]: 4 : ereport(ERROR,
1851 : : (errcode(ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE),
1852 : : errmsg("duplicate JSON object key value")));
1853 : :
1854 : 19 : return false; /* not unique keys */
1855 : : }
1856 : :
804 1857 [ + + ]: 530 : if (check_unique_keys)
1858 : 81 : freeJsonLexContext(&lex);
1859 : :
992 1860 : 530 : return true; /* ok */
1861 : : }
1862 : :
1863 : : /*
1864 : : * SQL function json_typeof(json) -> text
1865 : : *
1866 : : * Returns the type of the outermost JSON value as TEXT. Possible types are
1867 : : * "object", "array", "string", "number", "boolean", and "null".
1868 : : *
1869 : : * Performs a single call to json_lex() to get the first token of the supplied
1870 : : * value. This initial token uniquely determines the value's type. As our
1871 : : * input must already have been validated by json_in() or json_recv(), the
1872 : : * initial token should never be JSON_TOKEN_OBJECT_END, JSON_TOKEN_ARRAY_END,
1873 : : * JSON_TOKEN_COLON, JSON_TOKEN_COMMA, or JSON_TOKEN_END.
1874 : : */
1875 : : Datum
4451 andrew@dunslane.net 1876 : 30 : json_typeof(PG_FUNCTION_ARGS)
1877 : : {
992 alvherre@alvh.no-ip. 1878 : 30 : text *json = PG_GETARG_TEXT_PP(0);
1879 : : JsonLexContext lex;
1880 : : char *type;
1881 : : JsonParseErrorType result;
1882 : :
1883 : : /* Lex exactly one token from the input and check its type. */
804 1884 : 30 : makeJsonLexContext(&lex, json, false);
1885 : 30 : result = json_lex(&lex);
1203 andrew@dunslane.net 1886 [ - + ]: 30 : if (result != JSON_SUCCESS)
804 alvherre@alvh.no-ip. 1887 :UBC 0 : json_errsave_error(result, &lex, NULL);
1888 : :
804 alvherre@alvh.no-ip. 1889 [ + + + + :CBC 30 : switch (lex.token_type)
+ + - ]
1890 : : {
4347 andrew@dunslane.net 1891 : 6 : case JSON_TOKEN_OBJECT_START:
1892 : 6 : type = "object";
1893 : 6 : break;
1894 : 6 : case JSON_TOKEN_ARRAY_START:
1895 : 6 : type = "array";
1896 : 6 : break;
1897 : 3 : case JSON_TOKEN_STRING:
1898 : 3 : type = "string";
1899 : 3 : break;
1900 : 6 : case JSON_TOKEN_NUMBER:
1901 : 6 : type = "number";
1902 : 6 : break;
1903 : 6 : case JSON_TOKEN_TRUE:
1904 : : case JSON_TOKEN_FALSE:
1905 : 6 : type = "boolean";
1906 : 6 : break;
1907 : 3 : case JSON_TOKEN_NULL:
1908 : 3 : type = "null";
1909 : 3 : break;
4347 andrew@dunslane.net 1910 :UBC 0 : default:
804 alvherre@alvh.no-ip. 1911 [ # # ]: 0 : elog(ERROR, "unexpected json token: %d", lex.token_type);
1912 : : }
1913 : :
4420 peter_e@gmx.net 1914 :CBC 30 : PG_RETURN_TEXT_P(cstring_to_text(type));
1915 : : }
|
