PostgreSQL Source Code: src/backend/utils/adt/json.c Source File

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

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